How To Put As Many Things As You Can On a Truck
Problem statement
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 typei
.numberOfUnitsPerBox_i
is the number of units in each box of the typei
.
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.
Example 1
Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
Output: 8
Explanation: There are:
 1 box of the first type that contains 3 units.
 2 boxes of the second type that contain 2 units each.
 3 boxes of the third type that contain 1 unit each.
You can take all the boxes of the first and second types, and one box of the third type.
The total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.
Example 2
Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
Output: 91
Explanation: (5 * 10) + (3 * 9) + (2 * 7) = 91.
Constraints
1 <= boxTypes.length <= 1000
.1 <= numberOfBoxes_i, numberOfUnitsPerBox_i <= 1000
.1 <= truckSize <= 10^6
.
Solution: Greedy algorithm
Put the boxes having more units first.
Code
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int maximumUnits(vector<vector<int>>& boxTypes, int truckSize)
{
// sort for the boxes based on their number of units
sort(boxTypes.begin(), boxTypes.end(),
[](const vector<int>& a, const vector<int>& b)
{
return a[1] > b[1];
});
int maxUnits = 0;
int i = 0;
while (truckSize > 0 && i < boxTypes.size())
{
if (boxTypes[i][0] <= truckSize)
{
maxUnits += boxTypes[i][0] * boxTypes[i][1];
truckSize = boxTypes[i][0];
}
else
{
maxUnits += truckSize * boxTypes[i][1];
break;
}
i++;
}
return maxUnits;
}
int main()
{
vector<vector<int>> boxTypes{{1,3},{2,2},{3,1}};
cout << maximumUnits(boxTypes, 4) << endl;
boxTypes = {{5,10},{2,5},{4,7},{3,9}};
cout << maximumUnits(boxTypes, 10) << endl;
}
Output:
8
91
Code explanation

The
boxTypes
vector is sorted in descending order based on the number of units per box. This is done using a lambda function as the sorting criterion. Sorting in this way ensures that the boxes with the most units per box come first in the sorted list. 
The code initializes
maxUnits
to 0. This variable will keep track of the maximum units that can be loaded onto the truck. 
It initializes an index variable
i
to 0, which will be used to iterate through the sortedboxTypes
list. 
The code enters a loop that continues as long as there is available space on the truck (
truckSize > 0
) and there are more box types to consider (i < boxTypes.size()
). 
It checks if the current box type (specified by
boxTypes[i]
) can be loaded entirely onto the truck without exceeding its capacity. IfboxTypes[i][0]
(the number of boxes available for this type) is less than or equal totruckSize
, it loads all available boxes of this type onto the truck: It adds
boxTypes[i][0] * boxTypes[i][1]
tomaxUnits
(the total units loaded).  It subtracts
boxTypes[i][0]
fromtruckSize
(reduce the remaining truck capacity).
 It adds

If the current box type cannot be loaded entirely onto the truck without exceeding its capacity, it loads as many boxes as possible to maximize the units:
 It adds
truckSize * boxTypes[i][1]
tomaxUnits
(the total units loaded).  It breaks out of the loop since the truck is now at full capacity.
 It adds

The code increments
i
to move to the next box type. 
After the loop finishes,
maxUnits
will contain the maximum number of units that can be loaded onto the truck without exceeding its capacity. 
The code returns the value of
maxUnits
as the result.
In summary, the code optimally loads boxes onto a truck to maximize the total number of units that can be transported, considering both the number of boxes available and their units per box.
Complexity
 Runtime:
O(N*logN)
, whereN = boxTypes.length
.  Extra space:
O(1)
.
Modern C++ STL notes
Note that two vector
s can be compared. That is why you can sort them.
But in this case you want to sort them based on the number of units. That is why you need to define the comparison function like the code above. Otherwise, the sort
algorithm will use the dictionary order to sort them by default.
If you found this helpful, please share it with a friend and consider subscribing if you haven’t already. Also, if you have feedback about how we can make the content better, please share it here. Thank you very much!