Codeforces Round 930(Div.1)&(Div.2) 2A~2D

2A.Shuffle Party（枚举）

题意：

给你一个数组$a_1,a_2,\dots ,a_n$。最初，每个$1\le i\le n$都有$a_i=i$。

整数$k\ge 2$的运算$\text{swap}(k)$定义如下：

• 设$d$是不等于$k$的$k$的最大除数${}^{†}$。然后交换元素$a_d$和$a_k$。

假设你按照这样的顺序对每一个$i=2,3,\dots ,n$进行$\text{swap}(i)$。找出$1$在数组中的位置。换句话说，在执行这些操作后，找出$j$和$a_j=1$的位置。

${}^{†}$ 如果存在一个整数$z$使得$y=x\cdot z$是$y$的整除数，那么整数$x$就是$y$的整除数。

分析：

关注$1$的位置可以发现规律。$1$可以换到位置$2$，位置$2$只能换到位置$4$，位置$4$换到位置$8$，以此类推发现换到的位置都是$2$的幂次，枚举一下最大的幂次即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 30; i >= 0; i--) {
            if (n >= (1 << i)) {
                cout << (1 << i) << endl;
                break;
            }
        }
    }
    return 0;
}

2B.Binary Path（模拟）

题意：

给你一个$2\times n$的网格，网格中充满了"0"和"1"。假设第$i$行和第$j$列的交叉点上的数字是$a_{i,j}$。

在左上角的$(1,1)$网格中有一只蚱蜢，它只能向右或向下跳一格。它想到达右下方的$(2,n)$网格。考虑一个长度为$n+1$的二进制字符串，它由路径单元格中的数字按经过的顺序组成。

题目目标是

1. 通过选择任意一条可用路径，找出字典序最小的${}^{†}$字符串；
2. 找出能得到这个字典序最小字符串的路径数。

${}^{†}$如果两个字符串$s$和$t$的长度相同，那么当且仅当在$s$和$t$不同的第一个位置上，字符串$s$的元素小于$t$中的相应元素时，$s$在词法上小于$t$。

分析：

由于每一次只能往下和往右，所以其实我们只需要找到一个特殊点，从这个点往下走即可。如果右侧字符小于下面字符，一定向右走，这个位置记为$x$。如果右侧字符大于下面字符，此时一定得向下走,这个位置记为$y$。

我们在$[x+1,y]$之间随时都可以向下走，这样得到的都是最小字典序字符串。
。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        string a, b;
        cin >> a >> b;
        a = ' ' + a;
        b = ' ' + b;
        string ans;
        int y = n;
        int x = 0;
        for (int i = 1; i < n; i++) {
            if (b[i] < a[i + 1]) {
                y = i;
                break;
            }
            if (b[i] > a[i + 1]) {
                x = i;
            }
        }
        if (y == n && x == 0) {
            ans = a + b.back();
            cout << ans << endl;
            cout << n << endl;
        } else {
            ans = a.substr(1, y) + b.substr(y);
            cout << ans << endl;
            if (x == 0) {
                cout << y << endl;
            } else {
                cout << y - x << endl;
            }
        }
    }
    return 0;
}

2C(1A).Bitwise Operation Wizard（数学）

题意：

本题是一个互动问题。

有一个秘密序列$p_0,p_1,\dots ,p_{n-1}$，它是{0,1,…,n−1}\{0,1,\ldots,n-1\}{0,1,…,n−1}的排列组合。

您需要找到任意两个索引$i$和$j$使$p_i\oplus p_j$最大化。

为此，可以提出查询。每个查询的形式如下：可以选择任意的索引$a$、$b$、$c$和$d$($0\le a,b,c,d<n$)。($0\le a,b,c,d<n$)。接下来会计算$x=(p_a\mid p_b)$和$y=(p_c\mid p_d)$。最后，你会得到$x$和$y$的比较结果。换句话说，你会被告知是$x<y$、$x>y$还是$x=y$。

请找出任意两个索引$i$和$j$($0\le i,j<n$)，使得$p_i\oplus p_j$在所有这样的索引对中最大，最多可以有$3n$个查询。如果有多对索引满足条件，输出其中任何一个。

分析：

这道题考虑从特殊的地方入手，题目中给的数组是一个从$0$到$n-1$的排列，那么最大的数显然是$n-1$,然后要找出$n-1$为$0$的哪些位置为$1$的数，显然两者进行$\mid$运算的值应该最大，但是如果仅仅是找或运算的话，那么$n-1$为$1$的位置，且找到的数对应位置也为$1$的位置的那种值需要排除，显然我们的目标值中$1$的个数最少，目标值为$1$的位置所有找到的值对应的位置应该也是$1$，但是应该比目标值大。所以就要找到所有值中最小的一个。比较两个数的大小可以通过询问$a,a,b,b$来得到。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        if (n == 2) {
            cout << "! 0 1" << endl;
        } else {
            char op[2];
            int mx = 0, mi = 0;
            for (int i = 1; i < n; i++) {
                cout << "? " << mx << " " << mx << " " << i << " " << i << endl;
                cin >> op;
                if (op[0] == '<')
                    mx = i;
            }
            for (int i = 1; i < n; i++) {
                cout << "? " << mx << " " << mi << " " << mx << " " << i << endl;
                cin >> op;
                if (op[0] == '<')
                    mi = i;
                else if (op[0] == '=') {
                    cout << "? " << mi << " " << mi << " " << i << " " << i << endl;
                    cin >> op;
                    if (op[0] == '>')
                        mi = i;
                }
            }
            cout << "! " << mx << " " << mi << endl;
        }
    }
    return 0;
}

2D(1B).Pinball（思维）

题意：

有一个长度为$n$的一维网格。网格的第$i$个单元格包含一个字符$s_i$，该字符可以是’<‘或者’>'。

当一个弹球被放置在其中一个单元格上时，它会按照以下规则移动：

• 如果弹球位于第$i$个单元格上，且$s_i$为’<‘, 弹球下一秒向左移动一个单元格。如果$s_i$ 是’>'，则向右移动一个单元格。
• 弹球移动后，字符$s_i$将被反转（即如果$s_i$以前是’<‘，将变为’>'，反之亦然）。
• 当弹球离开网格时，它将停止移动：无论是从左边界还是从右边界。

本题需要回答$n$个独立查询。在第$i$次查询中，弹球将被放置在第$i$个单元格中。请注意，我们总是在初始网格上放置一个弹球。

对于每个查询，计算弹球离开网格需要多少秒。可以证明，弹球总是会在有限步数内离开网格。

分析：

会改变最初放置在位置$p$的弹球的方向的单元格是$p$左边的’>‘和$p$右边的’<'。

为方便起见，假设$s_p$为’>'、$k=min(countright(1,p),countleft(p+1,n))$，弹球从左边界离开（其他情况也可以类似方法处理）。

可以通过前缀相加+二进制搜索得到$right[1,\dots ,k]$和$left[1,\dots ,k]$，其中$right$表示$p$左边的’>‘的单元格序列（按递减顺序），$left$表示$p$右边的’<'的单元格序列（按递增顺序）。

用$right$和$left$来描述弹球的轨迹：

• 第一段：弹球从$righ{t}_1$移动到$lef{t}_1$；

• 第二段：弹球从$lef{t}_1$移动到$righ{t}_2$；

• 第三段：弹球从$righ{t}_2$移动到$lef{t}_3$；

• $\dots$

• 第$2k$段：弹球从$lef{t}_k$移动到左边界。

不难发现，可以使用前缀和来存储序列之和，然后快速计算弹球移动的时间。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 1000010;
int T, n;
ll Sl[N], Sr[N], IDl[N], IDr[N];
char s[N];

int findpre(int x) {
    int L = 0, R = n + 1, M;
    while (L + 1 != R) {
        M = (L + R) >> 1;
        if (Sr[M] < x)
            L = M;
        else
            R = M;
    }
    return R;
}

int findsuf(int x) {
    int L = 0, R = n + 1, M;
    while (L + 1 != R) {
        M = (L + R) >> 1;
        if (Sl[n] - Sl[M - 1] < x) R = M;
        else L = M;
    }
    return L;
}

int main() {
    scanf_s("%d", &T);
    while (T--) {
        scanf_s("%d %s", &n, s);
        for (int i = 1; i <= n; i++) {
            Sr[i] = Sr[i - 1] + (s[i - 1] == '>');
            Sl[i] = Sl[i - 1] + (s[i - 1] == '<');
            IDr[i] = IDr[i - 1] + i * (s[i - 1] == '>');
            IDl[i] = IDl[i - 1] + i * (s[i - 1] == '<');
        }
        for (int i = 1; i <= n; i++) {
            if (s[i - 1] == '>') {
                if (Sr[i] > Sl[n] - Sl[i]) {
                    int p = findpre(Sr[i] - (Sl[n] - Sl[i]));
                    printf_s("%lld ", 2 * ((IDl[n] - IDl[i]) - (IDr[i] - IDr[p - 1])) + i + (n + 1));
                } else {
                    int p = findsuf((Sl[n] - Sl[i]) - Sr[i] + 1);
                    printf_s("%lld ", 2 * ((IDl[p] - IDl[i]) - (IDr[i] - IDr[0])) + i);
                }
            } else {
                if (Sr[i] >= Sl[n] - Sl[i - 1]) {
                    int p = findpre(Sr[i] - (Sl[n] - Sl[i - 1]) + 1);
                    printf_s("%lld ", 2 * ((IDl[n] - IDl[i - 1]) - (IDr[i] - IDr[p - 1])) - i + (n + 1));
                } else {
                    int p = findsuf((Sl[n] - Sl[i - 1]) - Sr[i]);
                    printf_s("%lld ", 2 * ((IDl[p] - IDl[i - 1]) - (IDr[i] - IDr[0])) - i);
                }
            }
        }
        printf("\n");
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。