Maximum Units on a Truck - Practice Coding Problems

Maximum Units on a Truck - Problem

Imagine you're a logistics coordinator tasked with optimizing truck loading! You have one truck with limited capacity and multiple types of boxes, each containing different numbers of valuable units.

Given a 2D array boxTypes where boxTypes[i] = [numberOfBoxes, unitsPerBox]:

numberOfBoxes - how many boxes of type i are available
unitsPerBox - value/units contained in each box of type i

You're also given truckSize - the maximum number of boxes the truck can carry.

Goal: Select boxes to maximize the total units loaded onto the truck without exceeding the truck's capacity.

Example: If you have box types [[1,3], [2,2], [3,1]] and truck capacity 4, you should prioritize high-value boxes first: take 1 box with 3 units, then 2 boxes with 2 units each, then 1 box with 1 unit = 10 total units.

Input & Output

example_1.py — Basic Example

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

› Output: 8

💡 Note: Take 1 box of type with 3 units, 2 boxes of type with 2 units each, and 1 box of type with 1 unit. Total = 1×3 + 2×2 + 1×1 = 8 units using exactly 4 boxes.

example_2.py — Excess 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 all: 5×10 + 3×9 + 2×7 = 91 units using exactly 10 boxes.

example_3.py — Limited Capacity

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

› Output: 13

💡 Note: Sort by units per box: [5,5], [2,4], [1,3], [4,1]. Take 3 boxes with 5 units each = 3×5 = 15 units, but we can only take 3 boxes total, so we get 3×5 = 15. Wait, let me recalculate: we have [5,5] so we can take all 5 boxes, but truck only holds 3, so 3×5 = 15. Actually, we take 3 out of the 5 boxes of type [5,5] = 15 units.

Constraints

1 ≤ boxTypes.length ≤ 1000
1 ≤ numberOfBoxes_i, numberOfUnitsPerBox_i ≤ 1000
1 ≤ truckSize ≤ 10⁶
Box types can have duplicate unit values
You must respect the truck capacity exactly

Visualization

Tap to expand

Understanding the Visualization

Assess the Treasure

Line up all chest types and identify their gold-per-chest value

Sort by Value

Arrange chests from most valuable to least valuable per chest

Load Greedily

Always take the most valuable chests first until ship is full

Maximize Gold

This greedy strategy guarantees maximum treasure value

Key Takeaway

🎯 Key Insight: Greedy works because there's never a benefit to taking lower-value items when higher-value items are available - always prioritize maximum value per unit of capacity!

Asked in

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

The optimal solution uses a greedy algorithm: sort box types by units per box in descending order, then greedily select boxes starting from the highest value ones. This works because taking higher-value boxes first always leads to the maximum total units. Time complexity: O(n log n) for sorting, space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Algorithm (Optimal)	O(n log n)	O(1)	Sort by units per box descending, then greedily take highest value boxes first
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible combinations of boxes and find the maximum units

Greedy Algorithm (Optimal) — Algorithm Steps

Sort boxTypes by units per box in descending order
Initialize total units to 0 and remaining capacity to truckSize
For each box type (highest value first):
Take min(available boxes, remaining capacity) boxes
Add corresponding units to total and decrease remaining capacity
Return total units when truck is full or no more boxes available

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Value

Sort box types by units per box in descending order

Select Greedily

Take boxes from highest value type first

Update Capacity

Reduce remaining truck capacity after each selection

Continue Until Full

Repeat until truck is full or no more boxes available

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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 maximumUnits(int** boxTypes, int boxTypesSize, int* boxTypesColSize, 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++) {
        if (remainingCapacity <= 0) {
            break;
        }
        
        int numBoxes = boxTypes[i][0];
        int unitsPerBox = boxTypes[i][1];
        
        // Take as many boxes as possible from this type
        int boxesToTake = (numBoxes < remainingCapacity) ? numBoxes : remainingCapacity;
        totalUnits += boxesToTake * unitsPerBox;
        remainingCapacity -= boxesToTake;
    }
    
    return totalUnits;
}

int main() {
    // Example usage
    int data[3][2] = {{1,3},{2,2},{3,1}};
    int* boxTypes[3] = {data[0], data[1], data[2]};
    int boxTypesColSize[3] = {2, 2, 2};
    int truckSize = 4;
    
    printf("%d\n", maximumUnits(boxTypes, 3, boxTypesColSize, truckSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, where n is number of box types

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space if we sort in-place

✓ Linear Space

68.4K Views

High Frequency

~12 min Avg. Time

2.8K 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

Greedy Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler