Codeforces Rounds on 练习本

Codeforces Round 1044 (Div. 2) ABCD

Tue, 18 Nov 2025 16:22:35 +0800

A. Redstone?

列公式发现要求最后一个齿轮的大小要和第一个齿轮的大小一样。也就是要求数组中存在出现至少两次的数字。

void solve() {
 int n;
 cin >> n;

 vector<int> a(n + 1), vis(120);
 bool ok = false;
 For1(i, 1, n) {
 cin >> a[i];
 if (vis[a[i]]) {
 ok = true;
 }
 vis[a[i]] = true;
 }
 if (ok)
 YES();
 else
 NO();
}

B. Villagers

为了让总花费最小，把数组排序，选择最大的两个，让这两个元素和解。这样从大到小两两配对即可。

void solve() {
 int n;
 cin >> n;

 vector<int> a(n + 1);
 for (int i = 1; i <= n; i++) {
 cin >> a[i];
 }
 sort(a.begin() + 1, a.begin() + 1 + n);
 ll ans{};
 for (int i = n; i >= 1; i -= 2) {
 ans += a[i];
 }
 cout << ans << '\n';
}

C. The Nether

以每个节点作为起点询问，容易找到最大路径的长度 $len$

考虑如何找到路径的第二个节点，设这个节点是 $p$ ，那么以 $p$ 开头的最长路径必然是 $len - 1$ , 并且以 $start$ 作为起点， $p$ 作为终点，路径长度需要恰好是 2.

在第一遍询问的过程中，我们可以记录每个长度对应的点的列表。我们就可以容易找到 $len - 1$ 对应的点，然后以 $start$ 为起点， $p$ 作为另外一个点询问，找答案恰好是 2 的元素。依此类推，可以找到所有的 $len$ 个点。

问题的关键：我们发现第二遍询问的过程中，每个点最多只会被询问一次。所以这个做法是正确的。

void solve() {
 int n;
 cin >> n;

 auto query = [&](int start) -> int {
 cout << "? " << start << " " << n;
 for (int i = 1; i <= n; i++) {
 cout << " " << i;
 }
 cout << endl;

 int len;
 cin >> len;
 return len;
 };
 auto query2 = [&](int p1, int p2) -> bool {
 cout << "? " << p1 << " 2 " << p1 << ' ' << p2 << endl;
 int len;
 cin >> len;
 return len == 2;
 };

 map<int, vector<int>> mp;
 int mx = 0;
 for (int i = 1; i <= n; i++) {
 int len = query(i);
 mp[len].push_back(i);
 ckmax(mx, len);
 }

 vector<int> ans;
 int p1 = mp[mx][0], len = mx;
 ans.push_back(p1);
 for (int i = len - 1; i >= 1; i--) {
 for (auto v : mp[i]) {
 if (query2(p1, v)) {
 ans.push_back(v);
 p1 = v;
 break;
 }
 }
 }

 cout << "! " << mx;
 for (auto i : ans) {
 cout << " " << i;
 }
 cout << endl;
}

D. Chicken Jockey

有趣的 DP 题

注意到我们需要造成的伤害总量是固定的，总伤害分为两个部分：坠落伤害和普攻伤害。我们需要最大化坠落伤害，最小化普攻伤害。

设 $d_i$ 代表，消灭前 $i$ 个元素，需要的普攻伤害的最小值。

对于位置 $i$ ，如果要对它造成坠落伤害，我们需要考虑前 $i - 1$ 个位置。直接对 $i$ 造成坠落伤害的时刻，一定是 $i - 1$ 消失的时刻。

最简单的情况是，直接杀掉 $i - 1$ ，此时状态转移是 $d_{i - 2} + a_{i - 1} + max(0, a_i - (i - 1))$

另外一种情况是，不直接杀掉 $i - 1$ , 总之我们需要让前 $i - 1$ 给被消灭，此时只剩下第 $i - 1$ 个元素，第 $i$ 个元素的坠落伤害只有 1. 而消灭前 $i - 1$ 个元素的最小代价，恰好是我们的状态定义，这是一个子问题，因此状态转移是 $d_i = d_{i - 1} + (a_i - 1)$

void solve() {
 int n;
 cin >> n;

 VI a(n + 1);
 for (int i = 1; i <= n; i++)
 cin >> a[i];

 VL d(n + 1, INFL);
 d[0] = 0;
 d[1] = a[1];

 For1(i, 2, n) {
 d[i] = d[i - 1] + a[i] - 1;
 ckmin(d[i], d[i - 2] + a[i - 1] + max(0, a[i] - (i - 1)));
 }

 cout << d[n] << '\n';
}

Codeforces Round 1045 (Div. 2) ABC

Mon, 17 Nov 2025 21:02:23 +0800

比赛🔗 Codeforces Round 1045 (Div. 2)

A. Painting With Two Colors

容易想到根据奇偶性进行讨论。特殊情况是，如果 $b > a$ ，那么 $a$ 的奇偶性不需要考虑，因为它会被 $b$ 覆盖。

void solve() {
 int n, a, b;
 cin >> n >> a >> b;

 if (n & 1) {
 if ((b & 1) && ((a & 1) || (a < b)))
 YES();
 else
 NO();
 } else {
 if ((b % 2 == 0) && (a % 2 == 0 || (a < b)))
 YES();
 else
 NO();
 }
}

B. Add 0 or K

神奇的构造题。

我们要让 $a_i + kc_i \equiv 0 \pmod {g}$ ，也就是 $k c_i \equiv -a_i \pmod g$

要让这个方程比较好处理，我们可以让 $k \equiv -1 \pmod {g}$ ，带入上式得到 $c_i \equiv a_i \pmod {g}$ 。此时有 $k + 1 \equiv 0 \pmod {g}$ ，我们可以直接取 $g = k + 1$

因此可以这么构造，取 $g = k + 1$ , $c_i = a_i \bmod g$ ， $b_i = a_i + k c_i$ 。数组 $b$ 就是答案。

void solve() {
 int n, k;
 cin >> n >> k;

 VL a(n + 1);
 For1(i, 1, n) cin >> a[i];

 int g = k + 1;
 VL c(n + 1);
 For1(i, 1, n) {
 c[i] = a[i] % g;
 a[i] += k * c[i];
 cout << a[i] << ' ';
 }
 cout << '\n';
}

C. Even Larger

这道题目比 B 题简单多了。

容易想到我们需要让所有的偶数位置大于等于左右位置的奇数位置的和。

void solve() {
 int n;
 cin >> n;

 VI a(n + 10);
 For1(i, 1, n) { cin >> a[i]; }

 ll ans{};
 for (int i = 2; i <= n; i += 2) {
 int sum = a[i - 1] + a[i + 1];
 if (a[i] >= sum)
 continue;
 int g = sum - a[i];
 ans += g;
 a[i + 1] -= min(g, a[i + 1]);
 }
 cout << ans << '\n';
}

Codeforces Round 1046 (Div. 2) ABCD

Mon, 17 Nov 2025 15:16:28 +0800

比赛🔗 Codeforces Round 1046 (Div. 2)

A. In the Dream

在一个半场中，最坏情况下胜负情况是 $AABAABAA$ 这种形式。设分数较小的是 $x$ ，那么另外一个人的得分满足 $y \le 2x + 2$

void solve() {
 int a, b, c, d;

 cin >> a >> b >> c >> d;

 auto check = [&](int a, int b) -> bool {
 if (a > b)
 swap(a, b);
 return 2 * a + 2 >= b;
 };

 if (check(a, b) && check(c - a, d - b))
 YES();
 else
 NO();
}

B. Like the Bitset

要求不能有连续的 $k$ 个 1. 构造的时候，先填 0 的位置，尽可能填比较大的数字，剩下的数字填在 1 的位置。

void solve() {
 int n, k;
 cin >> n >> k;

 string s;
 cin >> s;
 s = " " + s;

 int cur = 0, cnt = 0;
 bool ok = true;
 VI zeros, ones;

 For1(i, 1, n) {
 if (s[i] == '1') {
 cur++;
 ones.pb(i);
 } else {
 cur = 0;
 zeros.pb(i);
 }

 ckmax(cnt, cur);
 if (cnt >= k) {
 ok = false;
 break;
 }
 }

 if (!ok) {
 NO();
 return;
 }

 int idx = n;
 VI ans(n + 1);
 for (auto x : zeros) {
 ans[x] = idx--;
 }
 for (auto x : ones) {
 ans[x] = idx--;
 }
 YES();
 For1(i, 1, n) { cout << ans[i] << ' '; }
 cout << '\n';
}

C. Against the Difference

设状态 $d_i$ 表示前 $i$ 个位置，最长合法子序列的长度。我们记录每个数字的位置到数组 $b$ 中， $b[x]$ 是 $x$ 出现过的位置的数组。对于位置 $i$ ，如果 $b_{a_i}$ 的长度不小于 $a_i$ ，那么状态转移到 $d_{pre - 1}$ 其中 $pre = b[x][len - a_i]$

void solve() {
 int n;
 cin >> n;

 VI a(n + 1);
 For1(i, 1, n) cin >> a[i];

 VI d(n + 1);
 VVI b(n + 1);
 int ans = 0;

 For1(i, 1, n) {
 int x = a[i];
 b[x].pb(i);

 int len = SZ(b[x]);
 if (len >= x) {
 int pre = b[x][len - x];
 ckmax(d[i], d[pre - 1] + x);
 }

 ckmax(d[i], d[i - 1]);
 ckmax(ans, d[i]);
 }

 cout << ans << '\n';
}

D. For the Champion

给定的式子 $min(|x_i - c| + |y_i - d|)$ 中的绝对值不好处理。考虑如何去掉绝对值。

从起始位置移动到右下角到 $c_1 = c + 2U, d_1 = d - 2U$ , 其中 $U = 10^9$ . 这样可以保证 $(c_1, d_1)$ 一定在所有点的右下方。

同理，从起始位置移动到右上角 $c_2 = c + 2U, d_2 = d + 2U$ , 其中 $U = 10^9$ . 这样可以保证 $(c_2, d_2)$ 一定在所有点的右上方。

然后可以根据对 $(c_1, d_1)$ 和 $(c_2, d_2)$ 的询问，得到不带绝对值的式子对应的答案。得到二元一次方程组。

void solve() {
 int n;
 cin >> n;

 vector<PII> a(n + 1);
 int sub = 2e9 + 10, add = -2e9 - 10;

 For1(i, 1, n) {
 cin >> a[i].first >> a[i].second;
 ckmin(sub, a[i].second - a[i].first);
 ckmax(add, a[i].first + a[i].second);
 }

 auto query = [&](char ch, int k) -> ll {
 cout << "? " << ch << ' ' << k << endl;
 ll dis;
 cin >> dis;
 return dis;
 };

 int U = 1e9;
 query('R', U);
 query('R', U);
 query('D', U);
 ll val1 = query('D', U);

 query('U', U);
 query('U', U);
 query('U', U);
 ll val2 = query('U', U);

 ll t = 1LL * val2 + add - 4LL * U, s = 1LL * val1 - sub - 4LL * U;
 ll x = (t + s) / 2, y = t - x;
 cout << "! " << x << ' ' << y << endl;
}

Educational Codeforces Round 184 ABCD1

Sat, 15 Nov 2025 11:27:20 +0800

A. Alice and Bob

取每个点只得 1 分，也就是让 Bob 能够取得的值最多。
我们发现我们总是可以让 Bob 取 $a + 1$ 或者 $a - 1$ . 我们只需要求出在这两种情况下，Bob 能够取得的数量是多少。这可以使用二分。

void solve() {
 int n, x;
 cin >> n >> x;

 VI a(n);
 For(i, 0, n) cin >> a[i];

 int bscore = -1, ans = -1;
 int tmp = n - (upper_bound(a.begin(), a.end(), x) - a.begin());
 if (ckmax(bscore, tmp))
 ans = x + 1;

 tmp = n - (a.end() - lower_bound(a.begin(), a.end(), x));
 if (ckmax(bscore, tmp))
 ans = x - 1;
 cout << ans << '\n';
}

B. Drifting Away

如果出现了以下几种情况，那么可以无限循环：
- **, ><, >*, *<
通过观察和模拟，我们发现如果没有无限循环，那么字符串中最多只有一个 *。如果出现了一次 >，那么它的右侧只能出现 >，不能再出现其他字符。如果出现了一次 <，那么它的左侧只能出现 <，不能出现其他字符。
总结一下，其实就是求字符串中，最长连续相同的子字符串的长度。
特殊判断一下字符串中只含有一个 * 的情况，这种情况在样例中已经给出了。

void solve() {
 string s;
 cin >> s;

 int n = SZ(s);
 bool ok = false;

 For(i, 0, n - 1) {
 if ((s[i] == '>' && s[i + 1] == '<') || (s[i] == '>' && s[i + 1] == '*') ||
 (s[i] == '*' && s[i + 1] == '<') || (s[i] == '*' && s[i + 1] == '*')) {
 ok = true;
 break;
 }
 }

 if (ok) {
 cout << "-1\n";
 return;
 }

 int cnt = 0;
 For(i, 0, n) {
 if (s[i] == '*')
 cnt++;
 }

 int cur = 1, ans = 1;
 char ch = s[0];

 For(i, 1, n) {
 if (s[i] == s[i - 1]) {
 cur++;
 } else {
 if (ckmax(ans, cur)) {
 ch = s[i - 1];
 }
 cur = 1;
 }
 }
 ckmax(ans, cur);

 if (n > 1)
 ans += cnt;
 cout << ans << '\n';
}

C. Range Operation

很有意思的一道题目。
当区间 $[l, r]$ 变化的时候， $l + r$ 也会变化，很难找到单调性，也就是找不到贪心的性质。不妨从增量的角度考虑。
如果选择的区间是 $[l, r]$ ，数组和的增量是 $\Delta_{1} = (l + r) len - sum(l, r)$ ，其中 $len = r - l + 1$ .
如果把区间往右扩展一个位置变成 $[l, r + 1]$ , 数组和的增量是 $\Delta_2 = (l + r + 1)(len + 1) - sum(l, r + 1) = \Delta_1 + 2(r + 1) - a_{r + 1}$
我们发现一个很整齐的形式： $2(r + 1) - a_{r + 1}$
也就是说，把区间往右扩展一位，它的增量恰好就是 $2(r + 1) - a_{r + 1}$ 。也就是说每一个位置的贡献是 $2i - a_i$ 。
设数组 $b_i = 2i - a_i$ ，因为我们只能进行最多一次操作，也就是我们只需要取一段区间，使得这个区间的贡献最大，也就是取一段连续的 $b_i$ ，使得区间和最大。这是线性 DP 的例题：“求最大子数组和”。

void solve() {
 int n;
 cin >> n;

 VL a(n + 1), b(n + 1);
 ll sum{};
 For1(i, 1, n) {
 cin >> a[i];
 sum += a[i];
 b[i] = 2 * i - a[i];
 }

 VL d(n + 1);
 ll ans = 0;
 For1(i, 1, n) {
 d[i] = max(b[i], d[i - 1] + b[i]);
 ckmax(ans, d[i]);
 }

 ans = ans + sum;
 cout << ans << '\n';
}

D1. Removal of a Sequence (Easy Version)

很有意思的一道题目。

如果要从删除掉了哪些数字的角度考虑，可能就有点复杂了。

这道题目的操作次数比较少，我们可以从全部操作完之后，剩下了多少个数字的角度考虑。对于给定的范围 $[1, n]$ ，操作完之后，剩下多少个数字是比较容易求出来的。

我们对 $n$ 进行二分，如果操作完之后，剩下的数字个数 $\ge k$ ，说明 $n$ 是合法的。我们找到最小的 $n$ ，此时 $n$ 就是答案。

void solve() {
 ll x, y, k;
 cin >> x >> y >> k;

 auto check = [&](ll p) -> bool {
 For(i, 0, x) { p -= p / y; }
 return p >= k;
 };

 ll l = 1, r = 1e12, mid;
 while (l < r) {
 mid = (l + r) / 2;
 if (check(mid))
 r = mid;
 else
 l = mid + 1;
 }
 if (check(r))
 cout << r << '\n';
 else
 cout << "-1\n";
}