A. Upload More RAM (贪心)
题意:
你想上传 n n n G B GB GB 的 R A M RAM RAM。每秒,你能上传 0 0 0 或 1 1 1 G B GB GB 的 R A M RAM RAM。但是,你的网络速度有限制:在任何连续 k k k 秒内,你最多只能上传 1 1 1 G B GB GB 的 R A M RAM RAM。
输出上传 n n n G B GB GB的 R A M RAM RAM 所需的最少秒数。
分析:
我们贪心地叠加,答案为 ( 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 (思维)
题意:
给出一个长度为 n n n 的整数数组 a a a 。
你可以多次(可能是零次)执行以下操作:
- 选择一个整数 k k k ,使得 1 ≤ k ≤ n 1 \le k \le n 1≤k≤n ,并支付 k + 1 k + 1 k+1 个硬币。
- 然后,选择 k k k 个索引 i x {i_x} ix。
- 然后,对于从 1 1 1 到 k k k 的每个 x x x ,将 a i x a_{i_x} aix 增加 1 1 1 。
找到使 a a a 非降序所需的最小硬币数量。
分析:
令 p i = m a x ( 0 , a i − 1 − a i ) p_i=max(0,a_{i-1}-a_i) pi=max(0,ai−1−ai),那么我们得到一个数组 p p p,将其升序排序,将题目转化为将数组 p p p全变为 0 0 0,操作的代价为 ∑ i = 1 n p i + m a x ( p i ) \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 (思维)
题意:
一排有
n
n
n 朵花,其中第
i
i
i 朵花的初始高度为
h
i
h_i
hi 米。
每一秒,风都会从左侧吹来,导致一些花的高度降低。
具体来说,每一秒,对于从
1
1
1 到
n
n
n 的每个
i
i
i ,按此顺序,会发生以下情况:
- 如果是 i = n i = n i=n 或 h i > h i + 1 h_i > h_{i + 1} hi>hi+1 ,则 h i h_i hi 的值变为 max ( 0 , h i − 1 ) \max(0, h_i - 1) max(0,hi−1) 。
询问对于所有 1 ≤ i ≤ n 1 \le i \le n 1≤i≤n ,第一次出现 h i = 0 h_i=0 hi=0 之前需要经过多少秒?
分析:
设 f i f_i fi表示第 i i i朵花的高度第一次变为 0 0 0的时间,那么对于第 i i i朵花:
- 若其高度小于等于第 i + 1 i+1 i+1朵,则其高度变为 0 0 0的时间为第 i + 1 i+1 i+1朵高度变为 0 0 0的时间 + 1 +1 +1
- 若其高度大于第 i + 1 i+1 i+1 朵,则其高度变为 0 0 0的时间为第 i + 1 i+1 i+1朵高度变为 0 0 0的时间 + 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)
题意:
A l i c e Alice Alice 和 B o b Bob Bob 正在玩游戏。最初,有 n n n 个蛋糕,第 i i i 个蛋糕的美味值为 a i a_i ai 。
A l i c e Alice Alice 和 B o b Bob Bob 轮流吃蛋糕, A l i c e Alice Alice 先吃:
- 轮到 A l i c e Alice Alice选择并吃掉满足下列条件的一块蛋糕,其美味度严格大于她之前吃过的任何蛋糕的最大美味度。请注意,在第一轮,她可以选择任何蛋糕。
- 轮到 B o b Bob Bob选择并吃掉任何剩下的一块蛋糕。
当当前玩家吃不到合适的蛋糕时,游戏结束。让 x x x 为 A l i c e Alice Alice 吃过的蛋糕数量。然后, A l i c e Alice Alice 想要最大化 x x x ,而 B o b Bob Bob 想要最小化 x x x 。
计算如果两个玩家都发挥最佳的话,爱丽丝会吃多少个蛋糕。
分析:
A
l
i
c
e
Alice
Alice的最优策略肯定是永远选可以选的数里最小的,那么
B
o
b
Bob
Bob的策略就是应该取完一些数字,使得
A
l
i
c
e
Alice
Alice选不着这些数字。令
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]表示对于前
i
i
i个数字,后手取完了其中
j
j
j个,至少需要多少次操作。
假设前
i
i
i个数字共有
x
x
x个,取走
j
j
j个数字中的共有
y
y
y个,那么必须要有
i
−
j
≥
y
i-j \ge y
i−j≥y才可以,否则不能在
A
l
i
c
e
Alice
Alice取之前完成所有操作。用
d
p
dp
dp转移即可。
代码:
#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)
题意:
给定一棵树,有
n
n
n 个顶点,根节点为
1
1
1 。第
i
i
i 个顶点上写有一个整数
a
i
a_i
ai 。
让
L
L
L 为
v
v
v 的所有直接子节点的集合。如果对于所有
L
L
L不为空的顶点
v
v
v ,满足
a v ≤ ∑ u ∈ L a u . a_v \le \sum_{u \in L}{a_u}. av≤u∈L∑au.
则称这棵树为奇妙树。
你可以选择任意顶点
v
v
v 并将
a
v
a_v
av 增加
1
1
1 。
找到使给定的树变得奇妙树所需的最少操作数!
如果满足以下条件,则顶点
u
u
u 称为顶点
v
v
v 的直接子节点:
- u u u 和 v v v 由一条边连接,并且
- v v v 位于从 u u u 到树根的(唯一)路径上。
分析:
如果一个结点不满足要求,那么我们需要增加其儿子的值,但是增加儿子的值有可能导致儿子不满足要求,所以又要增加儿子的儿子的值。我们通过
d
p
dp
dp,自底向上考虑,如果是叶子的父亲不满足要求,我们只需要增加叶子的值即可,一次只需要一个单位的代价。并且没有任何限制。
所以可以令父亲继承儿子的所有操作,只需要把儿子的所有操作代价加一即可(加上这个父亲结点的代价)。当需要操作时,贪心地使用代价最小的操作即可。
代码:
#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)
题意:
给出一个长度为
n
n
n 的整数数组
a
a
a 。
在一次操作中,你可以执行以下两步过程:
- 选择一个索引 i i i ,使得 1 ≤ i < ∣ a ∣ 1 \le i < |a| 1≤i<∣a∣ 和 a i = i a_i = i ai=i 。
- 从数组中删除 a i a_i ai 和 a i + 1 a_{i+1} ai+1 ,并连接剩余部分。
找出你可以执行上述操作的最大次数。
分析:
我们观察可以发现,消除的每一个区间,都是以类似括号序列的形式消去的,并且当前区间能被操作多少次只跟其之前的区间操作了多少次有关。令 d p 1 [ l ] [ r ] [ x ] dp1[l][r][x] dp1[l][r][x]表示之前的区间操作了 x x x次时 [ l , r ] [l,r] [l,r]的答案, d p 2 [ l ] [ r ] [ x ] dp2[l][r][x] dp2[l][r][x]表示之前的区间操作了 x x x次时 [ l , r ] [l,r] [l,r]完全消去的答案。在计算 d p 2 dp2 dp2的时候,如果此时选择要消除的位置为 l , j l,j l,j,之前的操作数为 x x x,那么需要计算 d p 2 [ l ] [ j ] [ x ] dp2[l][j][x] dp2[l][j][x]。并且不能直接把 x x x传到下一层中,因为如果 x x x次操作全部用掉,那么最外面这一层 [ 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)
题意:
给出一个长度为
n
n
n 的整数数组
a
a
a 。
在一次操作中,你可以执行以下两步过程:
- 选择一个索引 i i i ,使得 1 ≤ i < ∣ a ∣ 1 \le i < |a| 1≤i<∣a∣ 和 a i = i a_i = i ai=i 。
- 从数组中删除 a i a_i ai 和 a i + 1 a_{i+1} ai+1 ,并连接剩余部分。
找出你可以执行上述操作的最大次数。
分析:
令 d p i dp_i dpi表示前 i i i个数字最多能消去多少个数字,我们枚举下一个需要删除的段进行删除。我们首先要计算 f [ l ] [ r ] f[l][r] f[l][r]表示想要删除完 [ l , r ] [l,r] [l,r]至少需要删除多少个元素,并以此来判断某一段能否被删除。接下来就可以用区间 d p dp dp的思想去解决问题。
代码:
#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,赛后大家可以一起交流做题思路,分享做题技巧,欢迎大家的加入。