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$ ，因此：

1. 当需要修改的位置 $cnt\geq 4$ 时，可以每次隔一个取，使花费永远是 $y$ ，最终花费是 $\dfrac{cnt}{2} \cdot y$ 。
2. 当 $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)$ ：

1. 修改了前 $i-2$ 个位置的花费，加上链式 $x$ 修改第 $i-1$ 和 $i$ 个的花费。
2. 修改了前 $i-1$ 个位置除了一个位置没修改（可能在任何位置，也即包括了在第 $i-1$ 处）的花费，加上不相邻修改 $y$ 的花费。

取最小值。其中前者修改不需要考虑 $y$ ，因为后者包括了；后者不需要考虑 $x$ 链式修改，可以证明不可能更优。

当 $i$ 为奇数时，$dp[i] = \min(dp[i - 2] + (v[i] - v[i - 1]) \cdot x, dp[i - 1])$ ：

1. 修改了前 $i-2$ 个位置除了一个位置没修改的花费，加上链式 $x$ 修改第 $i-1$ 和 $i$ 个的花费。
2. 修改了前 $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;
}