A. Upload More RAM （贪心）
题意：
你想上传 nnn GBGBGB 的 RAMRAMRAM。每秒，你能上传 000 或 111 GBGBGB 的 RAMRAMRAM。但是，你的网络速度有限制：在任何连续 kkk 秒内，你最多只能上传 111 GBGBGB 的 RAMRAMRAM。
输出上传 nnn GBGBGB的RAMRAMRAM 所需的最少秒数。
分析：
我们贪心地叠加，答案为(n−1)×k+1(n-1) \times k+1(n−1)×k+1
代码：
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
cout << (n - 1) * k + 1 << endl;
}
return 0;
}
B.K-Sort （思维）
题意：
给出一个长度为 nnn 的整数数组 aaa 。
你可以多次（可能是零次）执行以下操作：
- 选择一个整数 kkk ，使得 1≤k≤n1 \le k \le n1≤k≤n ，并支付 k+1k + 1k+1 个硬币。
- 然后，选择kkk 个索引ix{i_x}ix。
- 然后，对于从 111 到 kkk 的每个 xxx ，将 aixa_{i_x}aix 增加 111 。
找到使 aaa 非降序所需的最小硬币数量。
分析：
令pi=max(0,ai−1−ai)p_i=max(0,a_{i-1}-a_i)pi=max(0,ai−1−ai)，那么我们得到一个数组ppp，将其升序排序，将题目转化为将数组ppp全变为000，操作的代价为∑i=1npi+max(pi)\sum_{i=1}^n p_i +max(p_i)∑i=1npi+max(pi)。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<LL> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<LL> p{0};
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
p.push_back(a[i - 1] - a[i]);
a[i] = a[i - 1];
}
}
sort(p.begin(), p.end());
LL ans = 0;
LL maxval = 0;
for (int i = 0; i < p.size(); i++) {
maxval = max(maxval, p[i]);
ans += p[i];
}
ans += maxval;
cout << ans << endl;
}
return 0;
}
C.Basil’s Garden （思维）
题意：
一排有 nnn 朵花，其中第 iii 朵花的初始高度为hih_ihi 米。
每一秒，风都会从左侧吹来，导致一些花的高度降低。
具体来说，每一秒，对于从 111 到 nnn 的每个 iii ，按此顺序，会发生以下情况：
- 如果是 i=ni = ni=n 或 hi>hi+1h_i > h_{i + 1}hi>hi+1 ，则 hih_ihi 的值变为 max(0,hi−1)\max(0, h_i - 1)max(0,hi−1) 。
询问对于所有 1≤i≤n1 \le i \le n1≤i≤n ，第一次出现 hi=0h_i=0hi=0 之前需要经过多少秒？
分析：
设fif_ifi表示第iii朵花的高度第一次变为000的时间，那么对于第iii朵花：
- 若其高度小于等于第i+1i+1i+1朵，则其高度变为000的时间为第i+1i+1i+1朵高度变为000的时间+1+1+1
- 若其高度大于第 i+1i+1i+1 朵，则其高度变为000的时间为第i+1i+1i+1朵高度变为000的时间+1+1+1和其高度之间的最大值。
代码：
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
a[n + 1] = 0;
for (int i = 1; i <= n; ++i)
cin >> a[i];
int ans, num;
ans = num = 1ll * a[n];
for (int i = n - 1; i; --i)
if (a[i + 1] >= a[i])
num++, ans = max(ans, num);
else {
num = max(1ll * a[i] - 1ll * (num - a[i + 1] + 1), 1ll * a[i + 1]) + 1ll * (num - a[i + 1] + 1);
ans = max(ans, num);
}
cout << ans << endl;
}
return 0;
}
D.World is Mine （dp）
题意：
AliceAliceAlice 和 BobBobBob 正在玩游戏。最初，有 nnn 个蛋糕，第 iii 个蛋糕的美味值为 aia_iai 。
AliceAliceAlice 和 BobBobBob 轮流吃蛋糕，AliceAliceAlice 先吃：
- 轮到AliceAliceAlice选择并吃掉满足下列条件的一块蛋糕，其美味度严格大于她之前吃过的任何蛋糕的最大美味度。请注意，在第一轮，她可以选择任何蛋糕。
- 轮到BobBobBob选择并吃掉任何剩下的一块蛋糕。
当当前玩家吃不到合适的蛋糕时，游戏结束。让 xxx 为 AliceAliceAlice 吃过的蛋糕数量。然后，AliceAliceAlice 想要最大化 xxx ，而 BobBobBob 想要最小化 xxx 。
计算如果两个玩家都发挥最佳的话，爱丽丝会吃多少个蛋糕。
分析：
AliceAliceAlice的最优策略肯定是永远选可以选的数里最小的，那么BobBobBob的策略就是应该取完一些数字，使得AliceAliceAlice选不着这些数字。令dp[i][j]dp[i][j]dp[i][j]表示对于前iii个数字,后手取完了其中jjj个,至少需要多少次操作。
假设前iii个数字共有xxx个,取走jjj个数字中的共有yyy个,那么必须要有i−j≥yi-j \ge yi−j≥y才可以,否则不能在AliceAliceAlice取之前完成所有操作。用dpdpdp转移即可。
代码：
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> tmp(n + 1);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
tmp[x] += 1;
}
vector<int> cake;
for (int i = 1; i <= n; i++) {
if (tmp[i] > 0) {
cake.push_back(tmp[i]);
}
}
const int m = cake.size();
vector<int> dp(m + 1, INF);
dp[0] = 0;
for (int i = 0; i < m; i++) {
auto tmp1 = dp;
for (int j = 0; j < i; j++) {
if (dp[j] + cake[i] <= i - j) {
tmp1[j + 1] = min(tmp1[j + 1], dp[j] + cake[i]);
}
}
dp.swap(tmp1);
}
int ans = INF;
for (int i = 0; i <= m; i++) {
if (dp[i] < INF / 2) {
ans = min(ans, m - i);
}
}
cout << ans << endl;
}
return 0;
}
E.Wonderful Tree! （dp）
题意：
给定一棵树，有 nnn 个顶点，根节点为 111 。第 iii 个顶点上写有一个整数 aia_iai 。
让 LLL 为 vvv 的所有直接子节点的集合。如果对于所有LLL不为空的顶点 vvv ，满足
av≤∑u∈Lau. a_v \le \sum_{u \in L}{a_u}. av≤u∈L∑au.
则称这棵树为奇妙树。
你可以选择任意顶点 vvv 并将 ava_vav 增加 111 。
找到使给定的树变得奇妙树所需的最少操作数！
如果满足以下条件，则顶点 uuu 称为顶点 vvv 的直接子节点：
- uuu 和 vvv 由一条边连接，并且
- vvv 位于从 uuu 到树根的（唯一）路径上。
分析：
如果一个结点不满足要求，那么我们需要增加其儿子的值，但是增加儿子的值有可能导致儿子不满足要求，所以又要增加儿子的儿子的值。我们通过dpdpdp，自底向上考虑，如果是叶子的父亲不满足要求，我们只需要增加叶子的值即可，一次只需要一个单位的代价。并且没有任何限制。
所以可以令父亲继承儿子的所有操作，只需要把儿子的所有操作代价加一即可（加上这个父亲结点的代价）。当需要操作时，贪心地使用代价最小的操作即可。
代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 1e9;
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &x: a)
cin >> x;
vector<int> d(n);
vector<vector<int>> g(n);
for (int i = 1; i < n; i++) {
int x;
cin >> x;
x--;
g[x].push_back(i);
d[i] = d[x] + 1;
}
vector<LL> b(n);
for (int v = 0; v < n; v++) {
if (g[v].empty()) {
b[v] = INF;
} else {
b[v] = -a[v];
for (int u: g[v]) {
b[v] += a[u];
}
}
}
LL ans = 0;
for (int v = n - 1; v >= 0; v--) {
queue<int> q;
q.push(v);
while (!q.empty()) {
int i = q.front();
q.pop();
for (int u: g[i]) {
LL delta = min(-b[v], b[u]);
if (delta > 0) {
b[v] += delta;
b[u] -= delta;
ans += delta * (d[u] - d[v]);
}
q.push(u);
}
}
}
cout << ans << endl;
}
return 0;
}
F1. Interesting Problem (Easy Version) （dp）
题意：
给出一个长度为 nnn 的整数数组 aaa 。
在一次操作中，你可以执行以下两步过程：
- 选择一个索引 iii ，使得 1≤i<∣a∣1 \le i < |a|1≤i<∣a∣ 和 ai=ia_i = iai=i 。
- 从数组中删除 aia_iai 和 ai+1a_{i+1}ai+1 ，并连接剩余部分。
找出你可以执行上述操作的最大次数。
分析：
我们观察可以发现，消除的每一个区间,都是以类似括号序列的形式消去的,并且当前区间能被操作多少次只跟其之前的区间操作了多少次有关。令dp1[l][r][x]dp1[l][r][x]dp1[l][r][x]表示之前的区间操作了xxx次时[l,r][l,r][l,r]的答案，dp2[l][r][x]dp2[l][r][x]dp2[l][r][x]表示之前的区间操作了xxx次时[l,r][l,r][l,r]完全消去的答案。在计算dp2dp2dp2的时候，如果此时选择要消除的位置为l,jl,jl,j，之前的操作数为xxx，那么需要计算dp2[l][j][x]dp2[l][j][x]dp2[l][j][x]。并且不能直接把xxx传到下一层中，因为如果xxx次操作全部用掉，那么最外面这一层[l,j][l,j][l,j]存在无法消去的可能。
代码：
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int INF = 1e9;
int tmp1[N][N][N], tmp2[N][N][N];
int a[N];
int solve2(int l, int r, int x) {
if ((r - l + 1) % 2 != 0)
return -INF;
if (r - l + 1 == 0)
return 0;
if (~tmp2[l][r][x])
return tmp2[l][r][x];
int ans = -INF;
if (a[l] % 2 == l % 2 and a[l] <= l and a[l] >= l - 2 * x) {
int cur = (l - a[l]) / 2;
for (int j = l + 1; j <= r; j += 2) {
int t = solve2(l + 1, j - 1, cur);
if (t < 0)
continue;
int s = t + 1;
t = solve2(j + 1, r, x + s);
if (t < 0)
continue;
s += t;
ans = max(ans, s);
}
}
return tmp2[l][r][x] = ans;
}
int solve1(int l, int r, int x) {
if (l >= r)
return 0;
if (~tmp1[l][r][x])
return tmp1[l][r][x];
int ans = 0;
ans = max(solve1(l + 1, r, x), solve1(l, r - 1, x));
for (int i = l; i < r; i++) {
int t = solve1(l, i, x);
ans = max(ans, t + solve1(i + 1, r, x + t));
}
for (int j = l + 1; j <= r; j += 2) {
int t = solve2(l, j, x);
if (t < 0)
continue;
int s = t;
s += solve1(j + 1, r, x + t);
ans = max(ans, s);
}
return tmp1[l][r][x] = ans;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
memset(tmp1, -1, sizeof(tmp1));
memset(tmp2, -1, sizeof(tmp2));
cout << solve1(1, n, 0) << endl;
}
return 0;
}
F2. Interesting Problem (Hard Version) （dp）
题意：
给出一个长度为 nnn 的整数数组 aaa 。
在一次操作中，你可以执行以下两步过程：
- 选择一个索引 iii ，使得 1≤i<∣a∣1 \le i < |a|1≤i<∣a∣ 和 ai=ia_i = iai=i 。
- 从数组中删除 aia_iai 和 ai+1a_{i+1}ai+1 ，并连接剩余部分。
找出你可以执行上述操作的最大次数。
分析：
令dpidp_idpi表示前iii个数字最多能消去多少个数字，我们枚举下一个需要删除的段进行删除。我们首先要计算f[l][r]f[l][r]f[l][r]表示想要删除完[l,r][l,r][l,r]至少需要删除多少个元素，并以此来判断某一段能否被删除。接下来就可以用区间dpdpdp的思想去解决问题。
代码：
#include <bits/stdc++.h>
using namespace std;
const int N = 805;
const int INF = 1e9;
int a[N];
int f[N][N];
int solve1(int l, int r) {
if (r - l + 1 == 0)
return 0;
if (a[l] % 2 != l % 2 or a[l] > l)
return INF;
if (~f[l][r])
return f[l][r];
int ans = INF;
int tmp = (l - a[l]) / 2;
for (int i = l + 1; i <= r; i += 2) {
if (solve1(l + 1, i - 1) > tmp)
continue;
int t = solve1(i + 1, r);
ans = min(ans, max(tmp, t - (i - l + 1) / 2));
}
return f[l][r] = ans;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
memset(f, -1, sizeof f);
vector<int> g(n + 1);
for (int i = 0; i < n; i++) {
g[i + 1] = max(g[i + 1], g[i]);
for (int j = i + 2; j <= n; j += 2) {
if (solve1(i + 1, j) <= g[i]) {
g[j] = max(g[j], g[i] + (j - i) / 2);
}
}
}
cout << g[n] << endl;
}
return 0;
}
赛后交流
在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。
群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。
扫一扫
2079
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
