Codeforces Round 1063 (Div. 2)题解

A. Souvlaki VS. Kalamaki

【题目】

给定一个长为n的数组nums，A，B两个人轮流行动。A先开始

第i轮，当前行动人可以跳过或者交换nums[i]和nums[i+1]

开始时A可以对nums任意排序。

要求最后nums必须是非递减，则A胜否则A败。

比如数组[3,1,2,2] 可以调整为[2,1,2,3] 开始A调整顺序为[1,2,2,3]则B无论调整顺序还是跳过，最后数组都是[1,2,2,3]满足非递减要求。

【题解】

要对题意抽象的更精准。

• 显然B的操作是可以任意交换两个元素，则B的轮次这两个元素必须【相等】。
  也就是必须注意到，B是可以任意破坏数组稳定的。

• 把相等的元素安排到B的轮次就可以吗？
  不可以，因为最终要求的是全数组非递减，而非全数组跟初始数组一致。

比如[2,3,3,1] B虽然无法修改数组，但是整个数组不是非递减。

• 因此A的轮次也必须要满足非递减

开始A的轮次就必须非递减吗？似乎不这样也行？比如[2,1,2,3]

注意如果不递减，则A交换一次，又变回了非递减，贪心的角度不如直接初始非递减即可。

A的轮次是否可能调整一次更优？

其实不可能，假设不更优，交换一次后，必然需要下一轮两个数相同。

【代码】

#include<bits/stdc++.h>
using namespace std;
void solve(){int n; cin >> n;vector<int> nums(n);for(int i = 0; i < n; i++) cin >> nums[i];sort(nums.begin(), nums.end());for(int i = 1; i < n - 1; i += 2){if(nums[i] != nums[i + 1]){cout << "NO" << endl;return;}}cout << "YES" << endl;
}
int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int t; cin >> t;while(t-- > 0) solve();return 0;
}

B. Siga ta Kymata

【题目】

给定n的一个排列p，初始你有一个长度为n的全0字符串s，你每次可以执行如下操作：

选择任意的一个[L,R]闭区间

对于所有的 L < i < R ，并且 min(p[L], p[R]) < i < max(pL], p[R])

设置s[i]='1' 即把[L,R]内符合条件的下标位置对应s置为1

给定另一个01字符串t

问能否通过至多5次操作，是的对于所有i 均满足如果t[i]=='1' 则必有s[i]=='1'

注意不需要考虑t中为0的下标，即如果t[i]如果为0, s[i]既可以为0也可以为1。

【题解】

不妨设下标为1-based

• 首先注意题意，i的区间是开区间，则左右两端的下标1和n处均是不可能变化的。

• 值的范围注意是取的区间两个端点的值，并非整个区间的极值

• 注意取值范围也是开区间的，意味着最小值1和最大值n的位置也是无法转换的。

• 去掉上述四个位置（也可能是两个 取决于值1和值n的位置是否恰好位于左右端点）别的位置是否一定可以转换？

这个是个重要观察，对于任意一个位置i上的值x 且1 < i < n 并且 1 < x < n

那么想要使x可以变化，必须要在i左侧找到一个比x小的位置，右侧找到一个比x大的位置

当然，反之亦可。

显然，最优的贪心解是左侧找 值1的位置，右侧找值n的位置，不妨分别设为pos[1] pos[n]

这样对于所有的其它位置也可以用类似操作，以减少操作数量。

但是问题在于，pos[1]和pos[n]可能在x的一侧，而非分布在两侧。

• 假设在x的右侧

那么由于pos[1]和pos[n]代表了最大或者最小值

此时左侧起点，即【下标是1】，设值为y

• 假如 y > x

则必然有区间[1, pos[1]]是一个能够把i位置置1的操作。

因为此时值的关系上有1 < x < y 且下标也是分布在两侧。

• 假如y < x 则可以选择区间[1, pos[n]]。此时 y < x < n

• 如果这两个极值都在x的左侧

通过同样分析可以得到区间[pos[1],n] [pos[n], n]两个有效区间

综上我们得到了五个操作区间即

[pos[1],pos[n]] 注意这个可能是反的，因为pos[1]可能在pos[n]右侧

[1,pos[1]]

[1,pos[n]]

[pos[1],n]

[pos[n],1]

区间[1,n]是否是个备选项？

不需要，原因

• [1,pos[1]]和[pos[1],n]覆盖了区间[1,n] 不需要再单独使用[1,n]

• 区间[1,n]并非值得操作的区间，比如[1,3,4,5,6,7,8,9,2] 这种左右端点的区间其实没有什么价值。

【代码】

#include <bits/stdc++.h>
using namespace std;
void solve(){int n; cin >> n;vector<int> nums(n);for(int i = 0; i < n; i++) cin >> nums[i];string t; cin >> t;string s(n, '0');int p1, pn;for(int i = 0; i < n; i++){if(nums[i] == 1) p1 = i;if(nums[i] == n) pn = i;}auto check = [&](int L, int R)->void{int mn = min(nums[L], nums[R]);int mx = max(nums[L], nums[R]);for(int i = L + 1; i < R; i++){if(nums[i] > mn && nums[i] < mx) s[i] = '1';}  };if(p1 < pn) check(p1, pn);else check(pn, p1);check(0, p1);check(0, pn);check(p1, n - 1);check(pn, n - 1);bool flag = true;for(int i = 0; i < n; i++){if(t[i] == '1' && s[i] == '0'){flag = false;break;}}if(!flag){cout << -1 << endl;return;}cout << 5 << endl;if(p1 < pn) cout << p1 + 1 << " " << pn + 1 << endl;else cout << pn + 1 << " " << p1 + 1 << endl;cout << 1 << " " << p1 + 1 << endl;cout << 1 << " " << pn + 1 << endl;cout << p1 + 1 << " " << n << endl;cout << pn + 1 << " " << n << endl;
}
int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int t; cin >> t;while(t-- > 0) solve();return 0;
}

C. Monopati

【题目】

给定一个2行n列矩阵 grid，且1 <= grid[i][j] <= 2n

定义f(L,R) 表示一个2行n列矩阵，代表的是原grid里如果L <= grid[i][j] <= R

这个矩阵的位置为1，否则为0，1 <= L <= R <= 2n

对于某个矩阵f(L,R) 如果存在一条从位置[1,1]到位置[2,n]的路线满足

• 只能向右或者向下移动

• 经过的格子值全为1

则该矩阵是个有效矩阵。

返回不同的有效矩阵个数。

【题解】

这题实际上属于经典题目，相对来说并没有思维难度

重点是读清题意，并联系已有的知识框架

• 2行矩阵右下路线 必然只有一种形式，就是在某一列上从第一行移动到第二行。

之前全在第一行水平移动，之后全在第二行水平移动

• 一种极端的情况，比如L=1,R=2n必然是有效的

因为所有元素的值均在[1,2n]之间，剩余的可能情况就是L增加，R减少

• 考虑任意一种路线，比如在第一行第i列向下，有效的[L,R]需要满足什么？

  • 第一行i列之前所有数字的最小值均应>=L，最大值均应<=R

  • 第二行i列之后所有数字的最小值均应>=L，最大值均应<=R

  也就是L的范围应该在[1, min(grid[0][i])]均为合法的

  R的范围应该在[max(grid[1][i]), 2n]均为合法的

• 预处理第一行的前缀最大最小值，第二行的后缀最大最小值列表。

然后枚举每个可能的向下的列即可。

• 一个误区，单看每种情况，可能的区间个数实际上是个乘法原理的值。

比如某一列，最终L的取值范围是[1,2] R的取值范围是[4,6]

则可能的区间情况是2*3=6种。

能否直接累加？错误的，因为会与其他列的区间重复。

题目并没有要求统计列数不同+区间不同，而是只统计区间不同。

一个简单的例子，[1,2n]对于所有的列都是符合的区间，但是只能计数一次。

• 典型的计数技巧是，锁定一端，比如枚举左侧所有的可能开始位置

计算右侧可选位置，累加这个数量是不会重复的，毕竟起点不同，则区间必然不同。

• 如何枚举，抽象一下可以得到这一个模型

区间总的范围为[1,2n]，给定一组区间列表，每个区间可能的范围为[L,R]

从总的区间范围内，选择一个区间[S,T]

易知这种选择方式有[2n, 2n-1,2n-2,...2,1] 总共有n*(2n+1)种

要求至少能够覆盖区间列表中任意一个[L,R]即可。

问能有多少种选择？

左端点从1枚举到2n，右端点如何选择？已知的区间列表如何处理？

比如其中一个区间[L,R]，表示如果左侧起点是L，则右侧【至少】是R。

那么如果左侧起点是L-1呢？显然【右侧也应该至少是R】

因此对于每个区间，记录到左侧到右侧的对应范围后，还应当从大到小更新一下右侧范围

比如[3,5], [2,6], [1,4]

如果左侧起点是3，右侧至少是5，那么对于这一列，显然左侧是2的时候，右侧也可以选择从5开始。

所以对于起点是2，右侧是6的那个区间，可能在另一列是这个结果，但是[3,5]的显然是个更优解。

所以起点是2的时候应当更新为右侧可以从5开始。

而起点是1的时候保持为4即可。

再次强调，有可能所有都是从固定一列下去

目标求的是可能的区间选择。

【代码】

#include <bits/stdc++.h>
using namespace std;void solve() {int n; cin >> n;vector<vector<int>> grid(2, vector<int>(n));for (int i = 0; i < 2; i++) {for (int j = 0; j < n; j++) cin >> grid[i][j];}vector<vector<int>> premin(2, vector<int>(n, n * 2));vector<vector<int>> premax(2, vector<int>(n, 1));for (int i = 0; i < 2; i++) {for (int j = 0; j < n; j++) {int v = grid[i][j];if (j == 0) {premin[i][j] = v;premax[i][j] = v;}else {premin[i][j] = min(premin[i][j - 1], v);premax[i][j] = max(premax[i][j - 1], v);}}}vector<vector<int>> sufmin(2, vector<int>(n, n * 2));vector<vector<int>> sufmax(2, vector<int>(n, 1));for (int i = 0; i < 2; i++) {for (int j = n - 1; j >= 0; j--) {int v = grid[i][j];if (j == n - 1) {sufmin[i][j] = v;sufmax[i][j] = v;}else {sufmin[i][j] = min(sufmin[i][j + 1], v);sufmax[i][j] = max(sufmax[i][j + 1], v);}}}vector<int> best(n * 2 + 1, n * 2 + 1);for (int i = 0; i < n; i++) {int mn = min(premin[0][i], sufmin[1][i]);int mx = max(premax[0][i], sufmax[1][i]);best[mn] = min(best[mn], mx);}for (int i = n * 2 - 1; i >= 1; i--) best[i] = min(best[i], best[i + 1]);long long ans = 0;for (int i = 1; i <= n * 2; i++) {ans += 1LL * (n * 2 - best[i] + 1);}cout << ans << endl;
}
int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int t; cin >> t;while (t-- > 0) {solve();}
}

D1. Diadrash (Easy Version)

【题目】

给定长为n的一个排列，给定长为m的一个查询区间

要求计算所有查询的区间代表的子数组的Mex值的最大值。

交互题，这里查询Mex值是一次交互操作

查询可以任意指定区间

查询只能最多max(300, n/2)次（D1)

查询只能最多25次（D2)

【题解】

这似乎并不是很难的一道题。

但是ABC太难了...

另外D1可查询次数是max(300,n/2 + 2) 注意max，也就是允许查询n/2次

对于D1来说，考察的技巧就是把m个查询区间缩减到n/2个以内。

• 什么是Mex？就是数组中最早未出现的非负整数

比如 Mex([0, n - 1]) 即整个数组的Mex显然是 n + 1

• 查询区间中最大Mex值显然应该位于一个尽量多的包含从0-x的区间中

此时Mex取到最大x+1

• 以某个下标为起点的区间中，显然只需要保留最后一个，因为包含的可能更多

这一条可以轻易的把m>n个区间 合并为不超过n个区间，这样可以把查询次数降为n

• 而本题重点地方在于要求查询次数不能超过n/2

考虑0所在的位置p0，显然最终答案应该包含p0。否则不包含的其Mex为0。

也就是最终答案的区间[L, R]应该满足 L <= p0 <= R

显然可以从p0的一侧所有位置枚举查询

如果是左侧则查询位置为[0, p0]，右侧为[p0, n - 1]

显然可以取较短的一侧。

如果p0正好位于数组中间位置 n为奇数，则左右两侧均为 n / 2 + 1，这个是最大值。

比如[3,4,0,1,2] ，给定的区间为[0,2],[1,2],[2,3] 必须得枚举到0所在的2

另外查询0的位置需要消耗一次。所以题目中给的n/2+2的上限充分且必要。

注意0的位置不需要准确知道，只需要知道是在中间位置的哪一册即可。

【代码】

仅D1

#include <bits/stdc++.h>
using namespace std;void solve() {int n, q; cin >> n >> q;vector<int> left(n + 1, n + 1);vector<int> right(n + 1, -1);for (int i = 0; i < q; i++) {int L, R; cin >> L >> R;right[L] = max(right[L], R);left[R] = min(left[R], L);}auto ask = [&](int L, int R)->int {if (L > n || R <= 0) return 0;cout << "? " << L << " " << R << endl;int res; cin >> res;return res;};int mid = (n + 1) / 2; //比如5个元素需要返回3int v0 = ask(1, mid);int ans = 0;if (v0) {//在左侧for (int i = 1; i <= mid; i++) {ans = max(ans, ask(i, right[i]));}}else{//在右侧for (int i = mid; i <= n; i++) {ans = max(ans, ask(left[i], i));}}cout << "! " << ans << endl; //输出答案 注意交互题的格式
}
int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int t; cin >> t;while (t-- > 0) {solve();}
}

D2. Diadrash (Hard Version)

【题解】

D2限制只允许25次，很显然一个log信号提示。

【二分】

这是一个很古怪的二分，难以想象的技巧。红名题就是离谱

二分需要单调性，什么地方是单调的？

容易想到的是Mex(L,R) 不管是L--还是R++都是有单调不减的。

但是这个性质如何应用呢？

我们逐个观察和思考Mex的性质。

• 排列是随机的，最大区间可能出现在任意位置，所以必然不能简单枚举端点

• 不过可以先预处理一下所有的区间，同D1一样，最后显然只会保留至多n个区间

• 不同区间之间必然不存在完全包含的情况。否则可以简单被替代

比如[1,5] [2,4]显然mex(1,5) >= mex(2,4)。所以不同区间可能是完全无交集，或者是部分交集。

这个区间有个隐藏的特性，比如两个区间[L1,R1] [L2,R2]

不妨假设L1 <= L2 则必然有 R1 <= R2

• 不妨假设处理到某个区间[L,R] 其Mex值为x，则[L,R]包含了[0,x-1]所有值。

那么如果想让[L,R]的Mex增加，应该L减少还是R增加？

或者说x+1这个值只能在左侧或者右侧，如何确定？

• 检测包含[L,R]的整个左侧区间 [1,R] mexL

• 检测包含[L,R]的整个右侧侧区间 [L,n] mexR

如果mexL < mexR, 那么必然这个x+1在左侧，需要向左去寻找。反之亦然

• 重申 检测的区间是 [1,R]和[L,n] 是个交集为[L,R]的两个区间

• 二分这个过程

• 不需要额外计算Mex(L,R) 因为Mex(L,R) = min(mexL, mexR)

【代码】

#include <bits/stdc++.h>
using namespace std;void solve() {int n, q; cin >> n >> q;vector<int> right(n + 1, -1);for (int i = 0; i < q; i++) {int L, R; cin >> L >> R;right[L] = max(right[L], R);}auto ask = [&](int L, int R)->int {if (L > n || R <= 0) return 0;cout << "? " << L << " " << R << endl;int res; cin >> res;return res;};vector<pair<int, int>> pairs;int mxR = -1;for (int i = 1; i <= n; i++) {if (right[i] > mxR) {pairs.push_back({ i, right[i] });mxR = max(mxR, right[i]);}}int ans = 0;int m = pairs.size();int low = 0, high = m - 1;while (low <= high) {int mid = low + (high - low) / 2;int L = pairs[mid].first, R = pairs[mid].second;int mexL = ask(1, R);int mexR = ask(L, n);ans = max(ans, min(mexL, mexR));if(mexL > mexR) high = mid - 1;else low = mid + 1;}cout << "! " << ans << endl; //输出答案 注意交互题的格式
}
int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int t; cin >> t;while (t-- > 0) {solve();}
}

E. Plegma

【题目】

这是一道通信题 This is a run-twice (communication) problem.

给你一个n*n 二进制矩阵，判断他的连通性。但是要求分两步处理

第一步输入n*n的矩阵，输出其中某个行r和某个列c

比如输入的是

11

10

输出其中的第二行和第一列，即输出

10

11

第二步输入就是读取的上面的输出，然后输出原矩阵是否是连通的。

即输出1 表示原矩阵是连通的（所有的1都是连通的）

【题解】

通信题是需要执行两次的，第二次里是仅知道第一次的输出结果，而不知道原始数据

本质上，需要设计一个策略，通过第一次的输出与第二次进行一个通信，把这个是否连通的信息传递过去。

这里先举几个例子说明

比如最简单的例子，我就用输出的这一行数据的第一位的值表示是否是连通的（甚至都没有用列的信息）

比如2*2矩阵

10

10

会发送一个[1,0]数组，表示他是连通的

而如果是矩阵

10

01

就会发送[0,1]数组，表示不连通。

这个做法显然是不完备的

比如矩阵

01

01

也是连通的，但是显然无论选择哪一行都无法使第一个值为1，所以策略无效，通信失败

进阶一点，考虑另一个方案，比如输出行第一个值和输出列的第一个值相同，则连通，否则不连通。

好像上面的情况都可以满足。

但是也容易举出反例 比如

11111

10001

10101

10001

11111

最中间如果是1，则不连通，否则连通。而输出的行和列第一位均只能是1，这个策略也是不完备的。

【所以需要充分利用整行/列的信息】

官解的策略挺难理解的。

下面介绍一个来自评论区的策略

如果矩阵是连通的，则必然能找到row<=col（即字符串字典序）

否则必然能找到row > col 暴力找一下就可以了。（注意n^2是可行的）

事实上除非矩阵全为1，否则必然能找到row>col也必然能找到row<col

【代码】

#include <bits/stdc++.h>
using namespace std;
void send() {int n, c; cin >> n >> c;vector<string> rows(n);vector<vector<char>> grid(n, vector<char>(n));for (int i = 0; i < n; i++) {string s;cin >> s;rows[i] = s;for (int j = 0; j < n; j++) grid[i][j] = s[j];}vector<string> cols(n);for (int j = 0; j < n; j++) {string s;for (int i = 0; i < n; i++) s += grid[i][j];cols[j] = s;}if (c == 1) {for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {if (rows[i] <= cols[j]) {cout << i + 1 << " " << j + 1 << endl;return;}}}}else {for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {if (rows[i] > cols[j]) {cout << i + 1 << " " << j + 1 << endl;return;}}}}
}void receive() {int n; cin >> n;string row, col;cin >> row >> col;if (row <= col) cout << 1 << endl;else cout << 0 << endl;
}void solve() {string opt; cin >> opt;int t; cin >> t;if (opt == "first") for (int i = 1; i <= t; i++) send();else for (int i = 1; i <= t; i++) receive();
}
int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int t = 1; // cin >> t;while (t-- > 0) {solve();}
}