Maximum Price to Fill a Bag

Maximum Price to Fill a Bag - Problem

You are given a 2D integer array items where items[i] = [price_i, weight_i] denotes the price and weight of the i^th item, respectively.

You are also given a positive integer capacity.

Each item can be divided into two items with ratios part1 and part2, where part1 + part2 == 1.

The weight of the first item is weight_i * part1 and the price of the first item is price_i * part1. Similarly, the weight of the second item is weight_i * part2 and the price of the second item is price_i * part2.

Return the maximum total price to fill a bag of capacity capacity with given items. If it is impossible to fill a bag return -1. Answers within 10^-5 of the actual answer will be considered accepted.

Input & Output

Example 1 — Basic Fractional Knapsack

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

› Output: 240.0

💡 Note: Take full Item1 (60, 10kg), full Item2 (100, 20kg), and 2/3 of Item3 (80, 20kg). Total: 240 price, 50kg weight.

Example 2 — Exact Fit with Full Items

$ Input: items = [[10,5],[40,4],[30,6],[50,3]], capacity = 10

› Output: 105.0

💡 Note: Items sorted by ratio: [50,3]=16.67, [40,4]=10.0, [30,6]=5.0, [10,5]=2.0. Take [50,3] (3kg) + [40,4] (4kg) = 7kg total, 90 price so far. Need 3kg more, take 3/6 = 0.5 of [30,6] = 15 price, 3kg. Total: 50 + 40 + 15 = 105 price, 10kg weight.

Example 3 — Impossible Case

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

› Output: -1

💡 Note: No item can fit in capacity 10 since minimum weight is 20. Return -1.

Constraints

1 ≤ items.length ≤ 1000
items[i].length == 2
1 ≤ price_i, weight_i ≤ 1000
1 ≤ capacity ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

This is a fractional knapsack problem where items can be split. The key insight is to use a greedy approach: sort items by price-to-weight ratio and take the most efficient items first. The challenge is that we must fill the bag to exactly the given capacity. Best approach is greedy selection with fractional filling. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible ways to split each item into fractions and try every combination that fits within capacity. This involves exploring exponential combinations of fractional splits.

Greedy by Price-to-Weight Ratio

⏱️ Time: O(n log n) Space: O(n)

Calculate the price-to-weight ratio for each item, sort in descending order, then greedily take as much as possible of each item starting from the highest ratio until the bag is exactly filled.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible fractional splits for each item
Try every combination of fractional items
Check if total weight <= capacity
Track maximum price achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Splits

Create all possible fractional combinations

Check Each

Verify weight constraint for each combination

Find Maximum

Track highest price that exactly fills capacity

Code -

solution.c — C

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

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

int compareItems(const void* a, const void* b) {
    Item* itemA = (Item*)a;
    Item* itemB = (Item*)b;
    if (itemA->ratio > itemB->ratio) return -1;
    if (itemA->ratio < itemB->ratio) return 1;
    return 0;
}

double solution(int items[][2], int n, int capacity) {
    if (n == 0 || capacity <= 0) {
        return -1.0;
    }
    
    // Sort by price-to-weight ratio for optimal greedy selection
    Item validItems[n];
    int validCount = 0;
    
    for (int i = 0; i < n; i++) {
        int price = items[i][0];
        int weight = items[i][1];
        if (weight > 0) {
            validItems[validCount].ratio = (double)price / weight;
            validItems[validCount].price = price;
            validItems[validCount].weight = weight;
            validCount++;
        }
    }
    
    // If no valid items (all have weight <= 0), impossible
    if (validCount == 0) {
        return -1.0;
    }
    
    qsort(validItems, validCount, sizeof(Item), compareItems);
    
    // Greedily fill the knapsack
    double remainingCapacity = capacity;
    double totalPrice = 0.0;
    
    for (int i = 0; i < validCount; i++) {
        if (remainingCapacity <= 0) {
            break;
        }
        
        if (remainingCapacity >= validItems[i].weight) {
            // Take full item
            totalPrice += validItems[i].price;
            remainingCapacity -= validItems[i].weight;
        } else {
            // Take fraction to fill remaining capacity
            double fraction = remainingCapacity / validItems[i].weight;
            totalPrice += validItems[i].price * fraction;
            remainingCapacity = 0;
            break;
        }
    }
    
    return totalPrice;
}

int parseItems(char* input, int items[][2]) {
    int n = 0;
    char* ptr = input;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '[')) ptr++;
        if (!*ptr || *ptr == ']') break;
        
        // Read price
        items[n][0] = strtol(ptr, &ptr, 10);
        
        // Skip comma
        while (*ptr && *ptr != ',') ptr++;
        if (*ptr == ',') ptr++;
        
        // Read weight
        items[n][1] = strtol(ptr, &ptr, 10);
        
        // Skip to next item
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        n++;
    }
    
    return n;
}

int main() {
    char input[1000];
    int capacity;
    int items[100][2];
    
    fgets(input, sizeof(input), stdin);
    scanf("%d", &capacity);
    
    int n = parseItems(input, items);
    
    double result = solution(items, n, capacity);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Exponential combinations of fractional item splits

✓ Linear Growth

Space Complexity

O(n)

Storage for tracking current combination

⚡ Linearithmic Space

12.8K Views

Medium Frequency

~15 min Avg. Time

425 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