LeetCode 第 222 场周赛 题解

第 222 场周赛

题目1：5641. 卡车上的最大单元数

题目描述：

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 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 <= 10^6

思路：贪心

先装单元多的箱子

代码：

class Solution {
    
    
public:
    /* 按照箱子中单元数量，降序排序 */
    static bool cmp(vector<int>& a, vector<int>& b){
    
    
        return a[1] > b[1];
    }
    
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
    
    
        sort(boxTypes.begin(), boxTypes.end(), cmp);
        int ans = 0;
        for(int i = 0; i < boxTypes.size(); i++){
    
    
            /* 从单元多的箱子到单元少的箱子依次选取，加入到卡车中 */
            if(truckSize - boxTypes[i][0] >= 0){
    
    
                ans += boxTypes[i][0] * boxTypes[i][1];
                truckSize -= boxTypes[i][0];
            }
            /* 若剩余容量不足全部装箱，特判处理 */
            else{
    
    
                int left = truckSize;
                ans += left * boxTypes[i][1];
                break;
            }
        }
        return ans;
    }
};

复杂度分析：

• 时间复杂度为 $O(n)$

• 空间复杂度为 $O(1)$

---

题目2：5642. 大餐计数

题目描述：

大餐 是指 恰好包含两道不同餐品 的一餐，其美味程度之和等于 2 的幂。

你可以搭配 任意 两道餐品做一顿大餐。

给你一个整数数组 deliciousness ，其中 deliciousness[i] 是第 i 道餐品的美味程度，返回你可以用数组中的餐品做出的不同 大餐 的数量。结果需要对 10^9 + 7 取余。

注意，只要餐品下标不同，就可以认为是不同的餐品，即便它们的美味程度相同。

示例 1：

输入：deliciousness = [1,3,5,7,9]
输出：4
解释：大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。
它们各自的美味程度之和分别为 4 、8 、8 和 16 ，都是 2 的幂。

示例 2：

输入：deliciousness = [1,1,1,3,3,3,7]
输出：15
解释：大餐的美味程度组合为 3 种 (1,1) ，9 种 (1,3) ，和 3 种 (1,7) 。

提示：

• 1 <= deliciousness.length <= 10^5
• 0 <= deliciousness[i] <= 2^20

思路：哈希

• 题目要求计算两道不同餐品的美味程度之和为2的幂次，想到利用哈希表的方式将复杂度降低为线性级别。
• 对于任一餐品，我们将其“互补”美味程度计入哈希表，这里的“互补”是指，与该餐品美味程度之和为 $2$ 的幂次的餐品。

代码：

class Solution {
    
    
public:
    int countPairs(vector<int>& d) {
    
    
        sort(d.begin(),d.end());
        const int M = 1e9 + 7;
        vector<int> vec(3000000);
        long long ans = 0;
        for(int i = 0;i < d.size(); i++){
    
    
            ans += vec[d[i]];
            for(int j = 0; j < 22; j++){
    
    
                if(((1<<j)-d[i])>=0) vec[(1<<j)-d[i]]++;
            }
        }
        return ans % M;
    }
};

复杂度分析：

• 时间复杂度为 $O(22n)$
• 空间复杂度为 $O(n)$

---

题目3：5643. 将数组分成三个子数组的方案数

题目描述：

我们称一个分割整数数组的方案是 好的 ，当它满足：

• 数组被分成三个 非空 连续子数组，从左至右分别命名为 left ， mid ， right 。
• left 中元素和小于等于 mid 中元素和，mid 中元素和小于等于 right 中元素和。

给你一个 非负 整数数组 nums ，请你返回 好的 分割 nums 方案数目。由于答案可能会很大，请你将结果对 10^9 + 7 取余后返回。

示例 1：

输入：nums = [1,1,1]
输出：1
解释：唯一一种好的分割方案是将 nums 分成 [1] [1] [1] 。

示例 2：

输入：nums = [1,2,2,2,5,0]
输出：3
解释：nums 总共有 3 种好的分割方案：
[1] [2] [2,2,5,0]
[1] [2,2] [2,5,0]
[1,2] [2,2] [5,0]

示例 3：

输入：nums = [3,2,1]
输出：0
解释：没有好的分割方案。

提示：

• 3 <= nums.length <= 10^5
• 0 <= nums[i] <= 10^4

思路：前缀和 + 二分

• 根据题意，需要用到某段区间内的元素和，所以提前维护一个前缀和数组 $v$ ，$v[i]$ 记录给定数组中 $[0,i-1]$ 区间的元素和（其中 $i=1,2,...,n$）。
• 遍历 $n$ 个位置，将位置 $i$ 作为 $left$ 和 $mid$ 子数组的分界线，二分查找 $mid$ 和 $right$ 的分界线范围。
• 假设分界线范围为 $[x,y]$，则 $x$ 位置需满足的条件是 $v[x]$ - $v[i]>=v[i]$，此时才能满足 $left<mid$，同理 $y$ 位置需满足的条件是 $v[n]$ - $v[y]>=v[y]$ - $v[i]$，这样才能满足 $mid<right$。求出 $x,y$ 后，这段区间内的任一位置都能作为 $mid$ 和 $right$ 的分界线。

代码：

class Solution {
    
    
public:
    int waysToSplit(vector<int>& a) {
    
    
        int n = a.size();
        vector<int> v(n + 1, 0);
        // 初始化前缀和数组
        for(int i = 1; i <= n; i++) {
    
    
            v[i] = v[i - 1] + a[i - 1];
        }
        // 返回值 ret
        long long ret = 0;
        const int M = 1e9 + 7;
        
        for(int i = 1; i < n; i++) {
    
    
            // 特判
            if(v[i] * 3 > v[n]) break;
            
            // 第一次二分找右边界
            int l = i + 1, r = n - 1;
            while(l <= r) {
    
    
                int mid = (l + r) / 2;
                if(v[n] - v[mid] < v[mid] - v[i]) {
    
    
                    r = mid - 1;
                } else {
    
    
                    l = mid + 1;
                }
            }
            
            // 第二次二分找左边界
            int ll = i + 1, rr = n - 1;
            while(ll <= rr) {
    
    
                int mid = (ll + rr) / 2;
                if(v[mid] - v[i] < v[i]) {
    
    
                    ll = mid + 1;
                } else {
    
    
                    rr = mid - 1;
                }
            }
            ret += l - ll;
        }
        return ret % M;
    }   
};

复杂度分析：

• 时间复杂度为 $O(nlgn)$，遍历 $left$ 和 $mid$ 边界复杂度 $O(n)$，两次二分复杂度 $O(lgn)$

• 空间复杂度为 $O(n)$，维护了前缀和数组

---

关注GTAlgorithm，专注周赛、面经题解分享，陪大家一起攻克算法难关~