Maximum Price to Fill a Bag - Practice Coding Problems

Maximum Price to Fill a Bag - Problem

Imagine you're a master trader at a precious metals market, and you have access to various fractional items that can be divided into any portions you want! 💰

You're given a collection of items where each item has a price and weight. The fascinating twist? You can split any item into fractional parts - if you take 30% of an item, you get 30% of its price and 30% of its weight.

Your goal is to fill a bag of exactly capacity weight to achieve the maximum possible total price. Think of it like a fractional knapsack where you must use the entire capacity - no more, no less!

Key Points:

Each item can be split: part1 + part2 = 1.0
Split item value: price × part1, weight × part1
You must fill the bag to exactly the given capacity
Return -1 if impossible to fill exactly

Input & Output

example_1.py — Basic Case

$ Input: items = [[60,10],[100,20],[120,30]], capacity = 50

› Output: 240.00000

💡 Note: Take all of item 1 (60 price, 10 weight) and item 2 (100 price, 20 weight). For the remaining 20 weight capacity, take 20/30 = 2/3 of item 3, giving us 2/3 * 120 = 80 price. Total: 60 + 100 + 80 = 240.

example_2.py — Exact Fit

$ Input: items = [[20,50],[30,60]], capacity = 110

› Output: 50.00000

💡 Note: We can take the complete first item (20 price, 50 weight) and complete second item (30 price, 60 weight) to exactly fill capacity 110. Total price: 20 + 30 = 50.

example_3.py — Impossible Case

$ Input: items = [[10,20],[20,30]], capacity = 60

› Output: -1

💡 Note: Total weight of all items is 20 + 30 = 50, which is less than required capacity of 60. It's impossible to fill the bag exactly to capacity 60, so return -1.

Constraints

1 ≤ items.length ≤ 10⁵
items[i].length == 2
1 ≤ price_i, weight_i ≤ 10⁴
1 ≤ capacity ≤ 10⁵
Answers within 10^-5 of actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Calculate Value Density

Determine the 'bang for buck' of each treasure by dividing value by weight

Sort by Density

Arrange treasures from highest to lowest value density - most profitable first

Greedy Selection

Take complete treasures starting with the most valuable per unit weight

Perfect Fit

Cut the final treasure to exactly fill the remaining capacity

Key Takeaway

🎯 Key Insight: The greedy approach works perfectly for fractional knapsack because we can always take the optimal fraction of the last item to exactly fill the remaining capacity, ensuring maximum value density throughout.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

This is a fractional knapsack problem with an exact capacity constraint. The optimal approach uses a greedy algorithm that sorts items by their value density (price/weight ratio) and selects items with the highest density first. The key insight is that we can take fractional parts of items, so we greedily fill the knapsack and use a fraction of the last item to exactly meet the capacity requirement.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × n)	O(n)	Try all possible fractional combinations of items to find maximum value
Greedy by Value Density (Optimal)	O(n log n)	O(n)	Sort items by price-to-weight ratio and greedily select highest value density first

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible fractional combinations of items
For each combination, check if total weight equals capacity
Calculate total price for valid combinations
Return maximum price found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty bag

Begin with capacity = 50, current weight = 0

Try all fractions of first item

For item [60,10], try 0%, 10%, 20%, ..., 100%

Recursively try remaining items

For each fraction, continue with next items

Check exact capacity match

Only count solutions that exactly fill the bag

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double maxPrice = -1;

typedef struct {
    int price;
    int weight;
} Item;

void backtrack(Item* items, int n, int index, double currentWeight, double currentPrice, int capacity) {
    if (fabs(currentWeight - capacity) < 1e-6) {
        if (currentPrice > maxPrice) {
            maxPrice = currentPrice;
        }
        return;
    }
    
    if (currentWeight > capacity || index >= n) {
        return;
    }
    
    double price = items[index].price;
    double weight = items[index].weight;
    
    if (weight == 0) {
        backtrack(items, n, index + 1, currentWeight, currentPrice, capacity);
        return;
    }
    
    // Try different fractions
    for (double fraction = 0; fraction <= 1; fraction += 0.1) {
        double newWeight = currentWeight + weight * fraction;
        if (newWeight <= capacity + 1e-6) {
            double newPrice = currentPrice + price * fraction;
            backtrack(items, n, index + 1, newWeight, newPrice, capacity);
        }
    }
}

double maxPriceToFillBag(Item* items, int n, int capacity) {
    if (!items || n == 0 || capacity <= 0) {
        return -1;
    }
    
    maxPrice = -1;
    backtrack(items, n, 0, 0.0, 0.0, capacity);
    return maxPrice;
}

int main() {
    Item items[] = {{60, 10}, {100, 20}, {120, 30}};
    int n = 3;
    int capacity = 50;
    double result = maxPriceToFillBag(items, n, capacity);
    if (result == -1) {
        printf("-1\n");
    } else {
        printf("%.5f\n", result);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

For each item, we have infinite fractional choices, making this exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current combination

⚡ Linearithmic Space

67.8K Views

Medium-High Frequency

~18 min Avg. Time

2.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler