【视频题解】

---

A

解题思路

1. 计算已摄入热量：已摄入的热量为 $Y \times Z$。
2. 判断是否超标：
   • 如果 $Y \times Z > X$，说明已超过每日限额，输出 $-1$。
   • 否则，计算剩余热量 $X - Y \times Z$ 并输出。

参考代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int x, y, z;
    cin >> x >> y >> z;  // 输入每日最大摄入量 x，已吃甜点数量 y，每个甜点热量 z
    
    if (y * z > x) {    // 如果已摄入热量超过限额
        cout << -1;     // 输出 -1
    } else {
        cout << x - y * z;  // 否则输出剩余热量
    }
    
    return 0;
}

B

解题思路

因为 $n, k, p$ 和 $q$ 四个数都是已知的，因此我们设需要增加的绿球数量为 $x$，我们可以列出如下不等式：

$$\frac{k}{n + x} \leq \frac{p}{q}$$

将 $x$ 用 $n, k, p, q$ 表示，可以得到：

$$x \geq \frac{q \times k}{p} - n$$

由于 $\frac{q \times k}{p}$ 的结果可能不是整数，而 $x$ 应该是满足这个不等式的最小整数，因此：

$$x = \left \lceil \frac{q \times k}{p} \right \rceil - n$$

其中 $[a]$ 表示对 $a$ 向上取整。例如，$a = 1.5$ 时，$[a] = 2$。

在 C++ 中，由于非负整数除法具有对结果向下取整（例如，$a = 1.5$ 时，$a$ 的向下取整为 1）的性质，所以有：

$$\left \lceil \frac{a}{b} \right \rceil = \left \lfloor \frac{a + b - 1}{b} \right \rfloor$$

其中 $[a]$ 表示对 $a$ 向下取整。代入我们上面推导出来的 $x$ 可以得到：

$$x = \left \lfloor \frac{q \times k + p - 1}{p} \right \rfloor - n$$

直接输出即可。

值得注意的是，如果 $\frac{k}{n} \leq \frac{p}{q}$ 在一开始就成立（即不需要增加新的绿球），那么直接输出 0 即可，无需进行上述计算。

参考代码

#include<bits/stdc++.h>
using namespace std;

int main(){
	int n, k, p, q;
	cin >> n >> k >> p >> q;
	if (1.0 * k / n <= 1.0 * p / q) cout << "0";
	else cout << (q * k + p - 1) / p - n;

}

C

解题思路

由于每周游戏结果可能有胜平负三种，因此小A和小B的得分差值应该是 3 的倍数，因为每周游戏胜者得到 3 分，败者不得分，若打平则双方都得 1 分。这意味着他们的得分差值只能是 0、3、-3、6、-6 等值。

因此只需要判断 $(X - Y) \mod 3$ 是否为零即可。

时间复杂度：$O(1)$

参考代码：

#include<bits/stdc++.h>
using namespace std;

int main(){
	int T;
	cin >> T;
	while(T--){
		int x, y;
		cin >> x >> y;
		if((x - y) % 3 == 0){
			cout << "Yes" << endl;
		}else {
			cout << "No" << endl;
		}
	}
}

D

解题思路

采用线性扫描的方法：

1. 遍历数组，检查当前元素与前一个元素的差值
2. 如果差值绝对值小于2（即0或1），则当前稳定子数组长度加1
3. 如果差值绝对值大于等于2，则重置当前稳定子数组长度为1
4. 在遍历过程中记录遇到的最大长度

参考代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N];

int main(){
    int n;
    cin >> n >> a[0];  // 读取数组大小和第一个元素
    int ans = 1, now = 1;  // 初始化答案和当前稳定子数组长度
    
    for(int i = 1; i < n; i++){
        cin >> a[i];  // 读取当前元素
        if(abs(a[i] - a[i-1]) < 2){  // 检查是否稳定
            now++;  // 稳定则延长当前子数组
            ans = max(now, ans);  // 更新最大值
        }
        else{
            now = 1;  // 不稳定则重置当前子数组
        }
    }
    cout << ans;  // 输出结果
}

E

解题思路

• $N = 4$ 的情况：只有一组四元组，直接比较即可。
• $N > 4$ 的情况：
  • 如果所有元素相同，则所有两个数的和都相等，无法找到满足条件的四元组。
  • 只要数组中有至少两个不同的元素，就必然存在两个不同的数对和，且由于 $N > 4$，可以确保存在四个不重叠的下标对应这些数对。

参考代码

#include <iostream>
using namespace std;

int a[100005];
int main() {
	int t;
	cin >> t;
	while(t--){
	    int n;
	    cin >> n;
	    for(int i = 0;i<n;i++){
	        cin >> a[i];
	    }
	    if(n == 4){
	        if(a[0] + a[1] == a[2] + a[3]){
	            cout << "No" << endl;
	        }
	        else{
	            cout << "Yes" << endl;
	        }
	    }
	    else{
	        bool allsame = true;
	        int temp = a[0];
	        
	        for(int i = 1;i<n;i++){
	            if(a[i] != temp){
	                allsame = false;
	                break;
	            }
	        }
	        
	        if(allsame){
	            cout << "No" << endl;
	        }
	        else{
	            cout << "Yes" << endl;
	        }
	    }
	}
	return 0;
}

F

解题思路

要最小化前 $N$ 个元素的和，需要将较大的元素交换到最后一个位置（不计入前 $N$ 个元素的和）。交换操作受条件限制：只能交换满足 $A_i \leq 2 \cdot A_{N+1}$ 的元素。策略是通过交换将前 $N$ 个元素中的大值移出，同时将最后一个位置的小值移入。

关键观察

• 如果交换一个比 $A_{N+1}$ 小的元素，前 $N$ 个元素的和反而会增大（因为换走一个小值，换入一个更大的值）。因此，只应考虑交换比 $A_{N+1}$ 大的元素。
• 交换后，最后一个元素的值会变大，这使得后续交换条件更易满足（因为 $2 \cdot A_{N+1}$ 变大），从而可能交换更大的元素。所以我们可以从小往大找合适的元素，只要找到就和最后一个交换。

参考代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];

int main() {
    int n, c;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    cin >> c;
    sort(a, a + n);
    int ans = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] > c && a[i] <= 2 * c) {
            swap(a[i], c);
        }
        ans += a[i];
    }
    cout << ans << endl;
    return 0;
}