【LeetCode】1710.卡车上的最大单元数

题目描述

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：
numberOfBoxesi 是类型 i 的箱子的数量。
numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。
返回卡车可以装载 单元 的 最大 总数。

示例 1：

输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
输出：8
解释：箱子的情况如下：

• 1 个第一类的箱子，里面含 3 个单元。
• 2 个第二类的箱子，每个里面含 2 个单元。
• 3 个第三类的箱子，每个里面含 1 个单元。
  可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
  单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8

示例 2：

输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
输出：91

提示：

1 <= boxTypes.length <= 1000
1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
1 <= truckSize <= 106

方法一：冒泡排序+贪心

class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
        int len = boxTypes.size();
        int sum=0;
        
        // 冒泡排序
        for(int i=0; i<len-1 ; i++){
            for(int j=0; j<len-i-1; j++){
                if(boxTypes[j][1] < boxTypes[j+1][1]){
                    int unit = boxTypes[j][1];
                    int num = boxTypes[j][0];
                    boxTypes[j][1] = boxTypes[j+1][1];
                    boxTypes[j][0] = boxTypes[j+1][0];
                    boxTypes[j+1][1] = unit;
                    boxTypes[j+1][0] = num;
                }
            }
        }
				
		// 贪心思想：每次都拿最大的
        for(int i=0; i<len; i++){
            if(truckSize-boxTypes[i][0] >0){
                truckSize -= boxTypes[i][0];
                sum += boxTypes[i][0] * boxTypes[i][1];
            }
            else{
                sum += truckSize * boxTypes[i][1];
                break;
            }
        }
        return sum;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

方法二：sort排序+迭代器+贪心

class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
        sort(boxTypes.begin(), boxTypes.end(), [](const vector<int> &a, const vector<int> &b){
            return a[1] > b[1];
        });
        int res=0;
        for(auto &boxType : boxTypes){
            int numberOfBoxes = boxType[0];
            int numberOfUnits = boxType[1];

            if(truckSize >= numberOfBoxes){
                res += numberOfBoxes * numberOfUnits;
                truckSize -= numberOfBoxes;
            }
            else{
                res += truckSize * numberOfUnits;
                break;
            }
        }

    return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

心得

• 这道题不难，完成对给定数组的排序后，就可以使用贪心算法，从大到小依次拿。
• 我在这道题的不足：

1. 很多排序算法都已经忘记了，最后还是百度搜索了冒泡排序。需要多掌握排序算法！
2. 在排序的交换步骤中，只记得交换[i][1]项，其实[i][0]项也需要手动交换！
3. 我的方法时间复杂度达到了O(n²)，太慢了！

---

方法二

• 官方题解使用了sort排序，该排序的具体用法见参考资料。sort排序的速度更快，并且可以直接交换一整个数组，方便很多。另外，该方法遍历的时候使用了迭代器，也是我需要学习的。
• 时间复杂度：O(n logn)
• 空间复杂度：O(n logn)

参考资料：
[1]C++ sort比较函数的写法，最全面的总结