Maximum Units on a Truck

Maximum Units on a Truck - Problem

You are assigned to put some amount of boxes onto one truck. You are given a 2D array boxTypes, where boxTypes[i] = [numberOfBoxes_i, numberOfUnitsPerBox_i]:

numberOfBoxes_i is the number of boxes of type i.
numberOfUnitsPerBox_i is the number of units in each box of the type i.

You are also given an integer truckSize, which is the maximum number of boxes that can be put on the truck. You can choose any boxes to put on the truck as long as the number of boxes does not exceed truckSize.

Return the maximum total number of units that can be put on the truck.

Input & Output

Example 1 — Basic Case

$ Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4

› Output: 8

💡 Note: Take 1 box of type 1 (3 units), 2 boxes of type 2 (4 units), and 1 box of type 3 (1 unit). Total = 3 + 4 + 1 = 8 units.

Example 2 — Limited Capacity

$ Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10

› Output: 91

💡 Note: Sort by units per box: [5,10], [3,9], [4,7], [2,5]. Take 5 boxes (50 units) + 3 boxes (27 units) + 2 boxes (14 units) = 91 units.

Example 3 — Single Type

$ Input: boxTypes = [[1,1]], truckSize = 1

› Output: 1

💡 Note: Only one box type available, take 1 box with 1 unit.

Constraints

1 ≤ boxTypes.length ≤ 1000
1 ≤ numberOfBoxes_i, numberOfUnitsPerBox_i ≤ 1000
1 ≤ truckSize ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 25 A Apple 15 M Microsoft 10

The key insight is that we should prioritize boxes with the highest units per box to maximize total units. The optimal approach is to sort box types by units per box in descending order and use a greedy strategy to fill the truck. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible way to select boxes within the truck size limit. For each combination, calculate total units and keep track of the maximum.

Greedy Approach - Sort by Units per Box

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

The key insight is that to maximize total units, we should always pick boxes with the highest units per box first. Sort all box types by their unit value and fill the truck greedily.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible combinations of box selections
For each valid combination (≤ truckSize boxes), calculate total units
Return the maximum units found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible subsets of box types

Check Validity

Ensure total boxes ≤ truck capacity

Find Maximum

Track combination with highest units

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* boxA = *(int**)a;
    int* boxB = *(int**)b;
    return boxB[1] - boxA[1]; // Sort by units per box descending
}

int solution(int** boxTypes, int boxTypesSize, int truckSize) {
    // Sort by units per box in descending order
    qsort(boxTypes, boxTypesSize, sizeof(int*), compare);
    
    int totalUnits = 0;
    int remainingCapacity = truckSize;
    
    for (int i = 0; i < boxTypesSize; i++) {
        int boxes = boxTypes[i][0];
        int unitsPerBox = boxTypes[i][1];
        
        if (remainingCapacity <= 0) {
            break;
        }
        
        // Take as many boxes as possible from this type
        int boxesToTake = (boxes < remainingCapacity) ? boxes : remainingCapacity;
        totalUnits += boxesToTake * unitsPerBox;
        remainingCapacity -= boxesToTake;
    }
    
    return totalUnits;
}

void parseBoxTypes(const char* str, int*** boxTypes, int* size) {
    // Count pairs first
    *size = 0;
    const char* p = str;
    while (*p) {
        if (*p == '[' && *(p+1) != ']') (*size)++;
        p++;
    }
    (*size)--; // subtract outer brackets
    
    // Allocate memory
    *boxTypes = (int**)malloc(*size * sizeof(int*));
    for (int i = 0; i < *size; i++) {
        (*boxTypes)[i] = (int*)malloc(2 * sizeof(int));
    }
    
    // Parse pairs
    p = str;
    while (*p && *p != '[') p++; // find first [
    p++; // skip [
    
    int pairIndex = 0;
    while (*p && pairIndex < *size) {
        while (*p && *p != '[') p++; // find next [
        if (!*p) break;
        p++; // skip [
        
        // Parse first number
        (*boxTypes)[pairIndex][0] = (int)strtol(p, (char**)&p, 10);
        while (*p && *p != ',') p++; // find comma
        p++; // skip comma
        
        // Parse second number
        (*boxTypes)[pairIndex][1] = (int)strtol(p, (char**)&p, 10);
        while (*p && *p != ']') p++; // find ]
        p++; // skip ]
        
        pairIndex++;
    }
}

int main() {
    char line1[1000], line2[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int** boxTypes;
    int boxTypesSize;
    parseBoxTypes(line1, &boxTypes, &boxTypesSize);
    
    int truckSize = atoi(line2);
    
    printf("%d\n", solution(boxTypes, boxTypesSize, truckSize));
    
    // Free memory
    for (int i = 0; i < boxTypesSize; i++) {
        free(boxTypes[i]);
    }
    free(boxTypes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

We try all possible subsets of box types, which is exponential

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth for generating combinations

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

892 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