# Leetcode 1710. Maximum Units 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] = [numberOfBoxesi, numberOfUnitsPerBoxi]`

:

`numberOfBoxesi`

is the number of boxes of type`i`

.`numberOfUnitsPerBoxi`

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.*

# Test Cases

**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

**Constraints**

`1 <= boxTypes.length <= 1000`

`1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000`

`1 <= truckSize <= 10^6`

# Approach

Our task is to find the maximum total number of units that can be put on the truck. We are given a 2d array where `boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi].`

So the idea is quite straight that we just need to do a sort based on **numberOfUnitsPerBox in descending order. Then just calculate the unit until our track have enough size.**

## Algorithm

- Sort the given 2d array based on
**numberOfUnitsPerBox in descending order.** - Traverse through the sorted array.
- If we have enough truck size, put the box into the truck and calculate the unit.
- Stop the iteration if we can’t no more hold anymore box in the truck.
- Return the resultant unit which will be the maximum total number of unit.

# Time and Space Complexity

Here we are sorting the given array and traversing through the array once. So if the length of array=n, then time complexity will be **O(nlogn + n).**

We are not making use of any extra space, so space complexity will be **O(1).**