第 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 <= 10001 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 10001 <= 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;
}
};
复杂度分析：
-
时间复杂度为
-
空间复杂度为
题目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^50 <= deliciousness[i] <= 2^20
思路：哈希
- 题目要求计算两道不同餐品的美味程度之和为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;
}
};
复杂度分析：
- 时间复杂度为
- 空间复杂度为
题目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^50 <= nums[i] <= 10^4
思路：前缀和 + 二分
- 根据题意，需要用到某段区间内的元素和，所以提前维护一个前缀和数组 ， 记录给定数组中 区间的元素和（其中 ）。
- 遍历 个位置，将位置 作为 和 子数组的分界线，二分查找 和 的分界线范围。
- 假设分界线范围为 ，则 位置需满足的条件是 - ，此时才能满足 ，同理 位置需满足的条件是 - - ，这样才能满足 。求出 后，这段区间内的任一位置都能作为 和 的分界线。
代码：
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;
}
};
复杂度分析：
-
时间复杂度为 ，遍历 和 边界复杂度 ，两次二分复杂度
-
空间复杂度为 ，维护了前缀和数组
