Codeforces Round #821 (Div. 2) A-E
A
题解
知识点：贪心。
下标模 \(k\) 相同分为一组，共有 \(k\) 组，组间不能互换，组内任意互换。
题目要求连续 \(k\) 个数字，一定能包括所有的 \(k\) 组，现在只要在每组中选取最大的加在一起即可。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int a[107];
bool solve() {
int n, k;
cin >> n >> k;
for (int i = 1;i <= n;i++) cin >> a[i];
ll ans = 0;
for (int i = 1;i <= k;i++) {
int mx = 0;
for (int j = i;j <= n;j += k)
mx = max(mx, a[j]);
ans += mx;
}
cout << ans << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
B
题解
知识点：构造。
注意到，必然会有人赢 \(0\) 次，有人会赢非 \(0\) 次，因此 \(x, y = 0\) 或者 \(x,y \neq 0\) 都是不存在的。
假设非 \(0\) 数为 \(x\) ，即赢的人都赢 \(x\) 次，其他人都直接输掉，因为共有 \(n-1\) 次机会，那么只有 \(x | n-1\) 时合法，其余情况不存在。
在合法的情况下，尝试构造。我们只需要确定第一场赢的人，然后每隔 \(x\) 场换个人即可。为了方便，我们确定 \(2\) 为第一场赢的人，这样我们对人的编号加 \(x\) 就是下一个人。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool solve() {
int n, x, y;
cin >> n >> x >> y;
if (x && y || !x && !y) return false;
if (x < y) swap(x, y);
if ((n - 1) % x) return false;
else {
for (int i = 2;i <= n;i += x) {
for (int j = 1;j <= x;j++)
cout << i << ' ';
}
cout << '\n';
}
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
C
题解
知识点：构造。
考虑通过 \(n-1\) 次操作使得序列元素全部相等。
注意到同奇同偶和为偶数使数字向左转移，否则为奇数使数字向右转移。
显然，可以通过第一个数字把右侧所有与之奇偶性不同的数字变成相等的，现在考虑与第一个数字奇偶性相同的数字相等。
因为同奇偶性，所以只能向左转移。考虑找到最后一个与第一个数字同奇偶性的数字，随后通过这个数字向左把同奇偶性的数字都变为相等，之后再执行上一步把不同奇偶性的数字变成相等的。
上述操作，每次都能增加一个与初始数字确定相等的数字，所以共操作 \(n-1\) 次。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool vis[100007];
bool solve() {
int n;
cin >> n;
int ls = 1;
for (int i = 1, x;i <= n;i++) {
cin >> x;
vis[i] = x & 1;
if (vis[1] == vis[i]) ls = i;
}
cout << n - 1 << '\n';
for (int i = ls - 1;i >= 1;i--) {
if (vis[i] == vis[1])
cout << i << ' ' << ls << '\n';
}
for (int i = 2;i <= n;i++) {
if (vis[1] != vis[i])
cout << 1 << ' ' << i << '\n';
}
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
D
题解
知识点：区间dp，贪心。
任何时候，如果需要修改的地方是奇数，则不存在解法，即 \(-1\) 情况。
简单版本，规定 \(x \geq y\) ，因此：
- 当需要修改的位置 \(cnt\geq 4\) 时，可以每次隔一个取，使花费永远是 \(y\) ，最终花费是 \(\dfrac{cnt}{2} \cdot y\) 。
- 当 \(cnt = 2\) 时，除了花费 \(x\) 直接消掉，还可以通过一个其他不相邻的位置中转，两次不相邻修改实现一次相邻修改，花费 \(2y\) ，因此总花费是 \(\min(x,2y)\) 。
困难版本，没有规定 \(x,y\) 关系，但 \(x \geq y\) 那部分可以直接用贪心结论解决，\(x < y\) 只能dp解决了，这里采用线性dp，其他dp也能做。
设 \(dp[i]\) 表示从 \(1\) 到 \(i\) 修改成一样的最小花费。
当 \(i\) 为偶数时，\(dp[i] = \min(dp[i - 2] + (v[i] - v[i - 1]) \cdot x, dp[i - 1] + y)\) ：
- 修改了前 \(i-2\) 个位置的花费，加上链式 \(x\) 修改第 \(i-1\) 和 \(i\) 个的花费。
- 修改了前 \(i-1\) 个位置除了一个位置没修改（可能在任何位置，也即包括了在第 \(i-1\) 处）的花费，加上不相邻修改 \(y\) 的花费。
取最小值。其中前者修改不需要考虑 \(y\) ，因为后者包括了；后者不需要考虑 \(x\) 链式修改，可以证明不可能更优。
当 \(i\) 为奇数时，\(dp[i] = \min(dp[i - 2] + (v[i] - v[i - 1]) \cdot x, dp[i - 1])\) ：
- 修改了前 \(i-2\) 个位置除了一个位置没修改的花费，加上链式 \(x\) 修改第 \(i-1\) 和 \(i\) 个的花费。
- 修改了前 \(i-1\) 个位置的花费，留下第 \(i\) 处没修改。
取最小值。其中前者修改不需要考虑 \(y\) 不相邻修改，因为前者如果使用 \(y\) 修改 \(i-1\) 和 \(i\)，花费等价于 \(dp[i-1]\) 的情况之一，即 \(dp[i-2]+y \geq dp[i-1]\) ，后者更优在于保留了第 \(i\) 个位置而非更前的位置，对偶数情况有更好的影响。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp[5007];
bool solve() {
int n;
ll x, y;
string a, b;
vector<int> v;
cin >> n >> x >> y;
cin >> a >> b;
v.clear();
for (int i = 0;i < n;i++) {
if (a[i] != b[i]) v.push_back(i);
}
if (v.size() & 1) return false;
if (!v.size()) {
cout << 0 << '\n';
return true;
}
if (x >= y) {
if (v.size() == 2 && v.front() + 1 == v.back()) cout << min(x, 2 * y) << '\n';
else cout << v.size() / 2LL * y << '\n';
}
else {
dp[0] = 0;
dp[1] = min((v[1] - v[0]) * x, y);
for (int i = 2;i < v.size();i++) {
if (i & 1) dp[i] = min(dp[i - 2] + (v[i] - v[i - 1]) * x, dp[i - 1] + y);
else dp[i] = min(dp[i - 2] + (v[i] - v[i - 1]) * x, dp[i - 1]);
}
cout << dp[v.size() - 1] << '\n';
}
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
E
题解
知识点：数学，线性dp。
显然，直接求第 \(t\) 秒 \((x,y)\) 是否有球非常困难，但是求 \([0,t]\) 秒内经过 \((x,y)\) 的数量（包括这个格子本身）是比较容易的。
每个位置都是方向右下交替进行，且初始是朝右。因此，假设 \([0,t]\) 秒内经过 \((i,j)\) 的球有 \(n\) 个，那么可以得知 \([0,t+1]\) 秒内经过 \((i+1,j)\) 的球有 \(\lceil \frac{n}{2} \rceil\) 个，经过 \((i,j+1)\) 的球有 \(\lfloor \frac{n}{2} \rfloor\) 个。
但是，在 \(t+1\) 秒及其之后到达 \((i,j)\) 的球不可能在 \([0,t+1]\) 秒内经过 \((i+1,j)\) 和 \((i,j+1)\) ，因为从 \((i,j)\) 到 \((i+1,j)\) 或 \((i,j+1)\) 需要 \(1\) 秒。因此，要求 \([0,t]\) 秒内经过 \((x,y)\) 的数量，则只需要 \([0,t-(i+j)]\) 秒内经过 \((i,j)\) 的数量。
我们知道 \([0,t]\) 内经过 \((0,0)\) 的球有 \(t+1\) 个。因此，能递推得出 \([0,t]\) 秒内经过 \((x,y)\) 的球的个数。。
设 \(dp[i][j]\) 是 \([0,t]\) 秒内 \((i,j)\) 经过了多少能到达 \((x,y)\) 的球的数量，初始条件是 \(dp[0][0] = \min(t - (x+y)+1,0)\) 。转移方程为：
dp[i + 1][j] += dp[i][j] / 2;
dp[i][j + 1] += dp[i][j] - dp[i + 1][j];
时间复杂度 \(O(q)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll get(ll t, int x, int y) {
vector<vector<ll>> dp(x + 7, vector<ll>(y + 7));
dp[0][0] = max(t - (x + y) + 1, 0LL);
for (int i = 0;i <= x;i++) {
for (int j = 0;j <= y;j++) {
dp[i + 1][j] += dp[i][j] / 2;
dp[i][j + 1] += dp[i][j] - dp[i + 1][j];
}
}
return dp[x][y];
}
bool solve() {
ll t;
int x, y;
cin >> t >> x >> y;
cout << (get(t, x, y) - get(t - 1, x, y) ? "YES" : "NO") << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/16755843.html
