力扣OJ（2600+）
目录
2600. K 件物品的最大和
2601. 质数减法运算
2604. 吃掉所有谷子的最短时间
2607. 使子数组元素和相等
2611. 老鼠和奶酪
2614. 对角线上的质数
2652. 倍数求和
2654. 使数组所有元素变成 1 的最少操作次数
2679. 矩阵中的和
2680. 最大或值
2681. 英雄的力量
2682. 找出转圈游戏输家
2709. 最大公约数遍历
2748. 美丽下标对的数目
2761. 和等于目标值的质数对
2818. 操作使得分最大
2829. k-avoiding 数组的最小总和
2600. K 件物品的最大和
水题
2601. 质数减法运算
素数检测
2604. 吃掉所有谷子的最短时间
一条线上有 n 只母鸡和 m 颗谷子。给定两个整数数组 hens 和 grains ，它们的大小分别为 n 和 m ，表示母鸡和谷子的初始位置。
如果一只母鸡和一颗谷子在同一个位置，那么这只母鸡可以吃掉这颗谷子。吃掉一颗谷子的时间可以忽略不计。一只母鸡也可以吃掉多颗谷子。
在 1 秒钟内，一只母鸡可以向左或向右移动 1 个单位。母鸡可以同时且独立地移动。
如果母鸡行动得当，返回吃掉所有谷子的 最短 时间。
示例 1 ：
输入：hens = [3,6,7], grains = [2,4,7,9] 输出：2 解释： 母鸡吃掉所有谷子的一种方法如下： - 第一只母鸡在 1 秒钟内吃掉位置 2 处的谷子。 - 第二只母鸡在 2 秒钟内吃掉位置 4 处的谷子。 - 第三只母鸡在 2 秒钟内吃掉位置 7 和 9 处的谷子。 所以，需要的最长时间为2秒。 可以证明，在2秒钟之前，母鸡不能吃掉所有谷子。
示例 2 ：
输入：hens = [4,6,109,111,213,215], grains = [5,110,214] 输出：1 解释： 母鸡吃掉所有谷子的一种方法如下： - 第一只母鸡在 1 秒钟内吃掉位置 5 处的谷子。 - 第四只母鸡在 1 秒钟内吃掉位置 110 处的谷子。 - 第六只母鸡在 1 秒钟内吃掉位置 214 处的谷子。 - 其他母鸡不动。 所以，需要的最长时间为 1 秒。
提示：
1 <= hens.length, grains.length <= 2*1040 <= hens[i], grains[j] <= 109
class TimeOk:public Bsearch {
public:
bool timeok(const vector &hens, const vector& grains, int t) {
int id = 0;
this->grains = grains;
for (int i = 0; i < hens.size(); i++) {
int t2 = t - abs(hens[i] - grains[id]);
if (t2 < 0)continue;
s = hens[i] <= grains[id] ? hens[i] + t : max(hens[i] + t2 / 2, grains[id] + t2);
id = find(id, int(grains.size())-1);
if (id >= grains.size())return true;
}
return false;
}
virtual bool isOk(int x) const //若isOk(x)且!isOk(y)则必有y s;
}
vector grains;
int s;
};
class Solution :public Bsearch {
public:
int minimumTime(vector& hens, vector& grains) {
sort(hens.begin(), hens.end());
sort(grains.begin(), grains.end());
this->hens = hens;
this->grains = grains;
return find(0,1000000000);
}
virtual bool isOk(int x) const //若isOk(x)且!isOk(y)则必有y hens;
vector grains;
}; 2607. 使子数组元素和相等
欧几里得
2611. 老鼠和奶酪
有两只老鼠和 n 块不同类型的奶酪，每块奶酪都只能被其中一只老鼠吃掉。
下标为 i 处的奶酪被吃掉的得分为：
如果第一只老鼠吃掉，则得分为 reward1[i] 。
如果第二只老鼠吃掉，则得分为 reward2[i] 。
给你一个正整数数组 reward1 ，一个正整数数组 reward2 ，和一个非负整数 k 。
请你返回第一只老鼠恰好吃掉 k 块奶酪的情况下，最大 得分为多少。
示例 1：
输入：reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2
输出：15
解释：这个例子中，第一只老鼠吃掉第 2 和 3 块奶酪（下标从 0 开始），第二只老鼠吃掉第 0 和 1 块奶酪。
总得分为 4 + 4 + 3 + 4 = 15 。
15 是最高得分。
示例 2：
输入：reward1 = [1,1], reward2 = [1,1], k = 2
输出：2
解释：这个例子中，第一只老鼠吃掉第 0 和 1 块奶酪（下标从 0 开始），第二只老鼠不吃任何奶酪。
总得分为 1 + 1 = 2 。
2 是最高得分。
提示：
1 <= n == reward1.length == reward2.length <= 105
1 <= reward1[i], reward2[i] <= 1000
0 <= k <= n
class Solution {
public:
int miceAndCheese(vector& reward1, vector& reward2, int k) {
Fcheng(reward1,-1);
reward1=VecAdd(reward1,reward2);
Fcheng(reward1,-1);
int s=0;
for(auto x:reward2)s+=x;
cout<=int(reward1.size())-k;i--)s+=reward1[i];
return s;
}
}; 2614. 对角线上的质数
素数检测
2652. 倍数求和
欧几里得
2654. 使数组所有元素变成 1 的最少操作次数
欧几里得
2679. 矩阵中的和
水题
2680. 最大或值
环非域
2681. 英雄的力量
排列组合
2682. 找出转圈游戏输家
n 个朋友在玩游戏。这些朋友坐成一个圈，按 顺时针方向 从 1 到 n 编号。从第 i 个朋友的位置开始顺时针移动 1 步会到达第 (i + 1) 个朋友的位置（1 <= i < n），而从第 n 个朋友的位置开始顺时针移动 1 步会回到第 1 个朋友的位置。
游戏规则如下：
第 1 个朋友接球。
- 接着，第
1个朋友将球传给距离他顺时针方向k步的朋友。 - 然后，接球的朋友应该把球传给距离他顺时针方向
2 * k步的朋友。 - 接着，接球的朋友应该把球传给距离他顺时针方向
3 * k步的朋友，以此类推。
换句话说，在第 i 轮中持有球的那位朋友需要将球传递给距离他顺时针方向 i * k 步的朋友。
当某个朋友第 2 次接到球时，游戏结束。
在整场游戏中没有接到过球的朋友是 输家 。
给你参与游戏的朋友数量 n 和一个整数 k ，请按升序排列返回包含所有输家编号的数组 answer 作为答案。
示例 1：
输入：n = 5, k = 2
输出：[4,5]
解释：以下为游戏进行情况：
1）第 1 个朋友接球，第 1 个朋友将球传给距离他顺时针方向 2 步的玩家 —— 第 3 个朋友。
2）第 3 个朋友将球传给距离他顺时针方向 4 步的玩家 —— 第 2 个朋友。
3）第 2 个朋友将球传给距离他顺时针方向 6 步的玩家 —— 第 3 个朋友。
4）第 3 个朋友接到两次球，游戏结束。
示例 2：
输入：n = 4, k = 4
输出：[2,3,4]
解释：以下为游戏进行情况：
1）第 1 个朋友接球，第 1 个朋友将球传给距离他顺时针方向 4 步的玩家 —— 第 1 个朋友。
2）第 1 个朋友接到两次球，游戏结束。
提示：
1 <= k <= n <= 50
class Solution {
public:
vector circularGameLosers(int n, int k) {
mapm;
for (int i = 0;; i++)
{
int a = ((i*i + i) / 2 * k + 1) % n;
if (m[a])break;
m[a] = 1;
}
vectorans;
for (int i = 1; i < n; i++) {
if (m[i] == 0)ans.push_back(i);
}
if (m[0] == 0)ans.push_back(n);
return ans;
}
};
2709. 最大公约数遍历
因式分解
2748. 美丽下标对的数目
欧几里得
2761. 和等于目标值的质数对
素数筛法
2818. 操作使得分最大
因式分解
2829. k-avoiding 数组的最小总和
给你两个整数 n 和 k 。
对于一个由 不同 正整数组成的数组，如果其中不存在任何求和等于 k 的不同元素对，则称其为 k-avoiding 数组。
返回长度为 n 的 k-avoiding 数组的可能的最小总和。
示例 1：
输入：n = 5, k = 4 输出：18 解释：设若 k-avoiding 数组为 [1,2,4,5,6] ，其元素总和为 18 。 可以证明不存在总和小于 18 的 k-avoiding 数组。
示例 2：
输入：n = 2, k = 6 输出：3 解释：可以构造数组 [1,2] ，其元素总和为 3 。 可以证明不存在总和小于 3 的 k-avoiding 数组。
提示：
1 <= n, k <= 50
class Solution {
public:
int minimumSum(int n, int k) {
if (n <= k / 2)return n * (n + 1) / 2;
return k / 2 * (k / 2 + 1) / 2 + (n - k / 2)*(n + k * 2 - k / 2 - 1) / 2;
}
};