Codeforces Round 925(Div.3) A~G

A.Recovering a Small String（模拟）

题意：

尼基塔有一个由$3$个小写拉丁字母组成的单词。拉丁字母的编号为$1$到$26$，其中字母"a"的编号为$1$，字母"z"的编号为$26$。

他将这个单词编码为这个单词的每个字母在字母表中的位置的总和。例如，他将单词"cat"编码为整数 $3+1+20=24$，字母"c"在字母表中的编号为$3$，字母"a"的编号为$1$，字母"t"的编号为$20$。

然而，这种编码结果是模糊的！例如，对单词"ava"进行编码时，也会得到整数$1+22+1=24$。

请找出满足要求的由$3$个字母组成的词法最小的单词。

当且仅当以下条件之一成立时，字符串$a$在词法上小于字符串$b$ ：

• $a$是$b$的前缀，但$a\ne b$；
• 在$a$和$b$字母不同的第一个位置，$a$的字母在字母表中编号小于$b$中的相应字母。

分析：

由题意得，要让前面的字符尽量小，就要让后面的字符尽量大。使用三重循环进行枚举即可。

代码：

#include<bits/stdc++.h>

using namespace std;

void solve() {
    int n;
    cin >> n;
    for (int i = 'a'; i <= 'z'; i++) {
        for (int j = 'a'; j <= 'z'; j++) {
            for (int k = 'a'; k <= 'z'; k++) {
                if (i + j + k - 'a' - 'a' - 'a' + 3 == n) {
                    cout << (char) i << (char) j << (char) k << endl;
                    return;
                }
            }
        }
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

B.Make Equal（循环）

题意：

有$n$个盛水的容器一字排开，从左到右依次编号为$1$到$n$。每个容器可以装任意数量的水；最初，$i_{th}$号容器装有$a_i$单位的水。$a_i$的和能被$n$整除。

你可以任意（可能是零）次地执行下面的操作：从$i_{th}$号容器把任意数量的水倒入$j_{th}$容器中，其中$i$必须小于$j$（即$i<j$）。

请判断是否有可能通过这种操作使所有容器中的水量相同。

分析：

由题目要求可知，后面的水量无法影响前面的水量，如果最后能全都相等，显然每一个都取到了平均值。求出平均值然后从后向前枚举，如果当前位置的水量大于平均值，则不满足要求，若当前水量小于平均值，则可以将前一个数$a_{i-1}$减去(平均值-$a_i$)的水量。

代码：

#include<bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10;
int a[N];

void solve() {
    int n;
    cin >> n;
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        sum += a[i];
    }
    sum /= n;
    for (int i = n; i >= 1; i--) {
        if (a[i] > sum) {
            cout << "NO" << endl;
            return;
        } else if (a[i] == sum)
            continue;
        else {
            a[i - 1] -= sum - a[i];
        }
    }
    if (a[0] < 0) cout << "NO" << endl;
    else cout << "YES" << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

C.Make Equal Again（二分答案）

题意：

有一个由$n$个整数组成的数组$a$。

你可以进行一次以下操作：选择三个整数$i$,$j$,$x$($1\le i\le j\le n$)，并将数组中索引为$i$至$j$的所有元素赋值为$x$。这个操作的代价取决于所选的索引，代价等于$(j-i+1)$。

例如，数组等于$[1,2,3,4,5,1]$。如果我们选择$i=2,j=4,x=8$，那么执行此操作后，数组将变为$[1,8,8,8,5,1]$。

要使数组中的所有元素相等，最小代价为多少？

分析：

答案有单调性，最大范围是$l=1$，$r=n$，即全部修改。考虑二分答案，不断缩小区间，如果左端点值等于右端点，则需修改中间部分；若左端点不等于右端点，则需要修改两侧中的某一段。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;
const LL N = 2e5 + 10;

LL n, a[N];

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    LL l = 1, r = n;
    if (a[l] != a[r]) {
        while (a[l] == a[1]) l++;
        while (a[r] == a[n]) r--;
        cout << min(n - l + 1, r) << endl;
    } else {
        while (a[l] == a[1]) l++;
        while (a[r] == a[n]) r--;
        if (l <= r)
            cout << r - l + 1 << endl;
        else
            cout << 0 << endl;
    }
    for (int i = 1; i <= n; i++) a[i] = 0;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

D.Divisible Pairs（数学）

题意：

波利卡普有两个最喜欢的整数$x$和$y$（它们可以相等），他找到了一个长度为$n$的数组$a$。

如果出现以下情况，波利卡普认为一对数$⟨i,j⟩$($1\le i<j\le n$) 很美：

• $a_i+a_j$可以被$x$整除；
• $a_i-a_j$可以被$y$整除。

例如，如果$x=5$，$y=2$，$n=6$，$a=$[$1,2,7,4,9,6$]，那么美丽的两对数是：

• $⟨1,5⟩$:$a_1+a_5=1+9=10$ $10$能被$5$整除）和$a_1-a_5=1-9=-8$（$-8$能被$5$整除）。$-8$能被$2$整除）；
• $⟨4,6⟩$:$a_4+a_6=4+6=10$ $10$能被$5$整除）和$a_4-a_6=4-6=-2$（$-2$能被$2$整除($-2$能被$2$整除）。

求数组$a$中美丽的数对的个数。

分析：

对于数列中的某种权值$p$，发现能与其凑成一对美丽数的权值$q$ 一定满足：

• $q\mathrm{mod}x=(x-p)\mathrm{mod}x$
• $q\mathrm{mod}y=p\mathrm{mod}y$

考虑枚举数列元素，用$map$记录每种数对$(a_i\mathrm{mod}x,a_i\mathrm{mod}y)$的数量，检查数对$((a_i-p)\mathrm{mod}x,a_i\mathrm{mod}y)$的数量并累加即为答案。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 2e5 + 10;

LL n, x, y, a[N], ans;

void solve() {
    cin >> n >> x >> y;
    ans = 0;
    map<pair<int, int>, int> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        ans += m[make_pair((x - a[i] % x) % x, a[i] % y)];
        ++m[make_pair(a[i] % x, a[i] % y)];
    }
    cout << ans << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

E.Anna and the Valentine’s Day Gift（模拟）

题意：

情人节那天，萨沙给了安娜一张有$n$个整数的列表。安娜不需要这个列表，所以她建议通过玩游戏来销毁它。

玩家轮流玩。萨沙是个绅士，所以他让安娜先手。

• 轮到安娜时，她必须从列表中选择一个元素$a_i$，并颠倒其数字顺序。例如，如果安娜选择了数值为$42$的元素，它就会变成$24$；如果安娜选择了数值为$1580$的元素，它就会变成$851$。注意，前导零会被去掉。在这一轮之后，列表中元素的数量不会改变。
• 轮到萨沙时，他必须从列表中选择两个元素$a_i$和$a_j$（$i\ne j$），以任意顺序将它们连接起来，并将结果插回列表。例如，如果萨沙选择了等于$2007$和$19$的元素，他将从列表中删除这两个元素，并添加整数$200719$或$192007$。这样转一圈后，列表中的元素数会减少$1$ 。

玩家不能跳过回合。当萨沙无法下棋时，即安娜下棋后，列表中只剩下$1$个数字时，游戏结束。如果这个整数不小于$10^m$ （即$\ge 10^m$），萨沙获胜。否则，安娜获胜。

由此可以看出，游戏总会结束。如果双方都以最优方法下棋，谁会获胜？

分析：

只考虑两人操作对数字长度的影响，容易发现：

• 安娜一次翻转，可以把末尾的$0$全都去掉，对答案的贡献取决于末尾$0$的长度。
• 萨沙一次合并，并不影响其长度之和，但会把$x0$合并到$xx$前面变成$x0xx$，这样安娜就没办法去掉这个$0$。

所以，只需要按末尾$0$的个数从大到小排序，将安娜能去掉的$0$去掉，剩下的数字个数即为答案。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;
const LL N = 2e5 + 10;

struct Num {
    string s;
    int z;

    friend bool operator<(const Num &o1, const Num &o2) {
        return o1.z > o2.z;
    }
} a[N];

void solve() {
    LL n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> a[i].s;
        LL p = a[i].s.size() - 1;
        while (a[i].s[p] == '0')
            p--;
        a[i].z = a[i].s.size() - p - 1;
    }
    sort(a, a + n);
    LL cnt = 0, sum = 0;
    for (int i = 0; i < n; i++) {
        sum += a[i].s.size();
        if (!(i & 1))
            cnt += a[i].z;
    }
    cout << (sum - cnt > m ? "Sasha" : "Anna") << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

F.Chat Screenshots（拓扑排序）

题意：

编程竞赛聊天室有$n$人。聊天参与者按活跃度排序，但每个人都把自己排在最前面。

例如，有$4$人参加聊天，他们的顺序是$[2,3,1,4]$ 。那么

• $1$（第一个用户）看到的顺序是$[1,2,3,4]$ 。
• $2$ 用户看到的顺序是 $[2,3,1,4]$ 。
• $3$ 用户看到的顺序是$[3,2,1,4]$ 。
• $4$ 用户看到的顺序是$[4,2,3,1]$ 。

$k$人在聊天中发布了截图，显示了该用户看到的参与者顺序。这些截图是在很短的时间内截取的，参与者的顺序并没有改变。

确定是否存在一种特定的次序，使得所有屏幕截图都可以对应于该次序。

分析：

因为是排列，所以没有相同数字，每一个人给出的排列，都可以确定除自己以外的相对顺序，那么如果这个排列不存在,就是相对的顺序出现了矛盾，如果让排在前面的数向后面的数连一条有向边，那么对于第一个数来说，那么它是肯定没有入度的，因为有明确的顺序，所以图中肯定不会出现环，如果出现了环就无法判断顺序，排列就不存在。本题转换为根据条件来建图，然后拓扑排序来检查是否有环，有环就不存在满足要求的顺序。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;

void solve() {
    int n, k;
    cin >> n >> k;
    int last = 0;
    vector<vector<int>> e(n + 1, vector<int>());
    vector<int> edge(n + 1, 0);
    for (int i = 1; i <= k; i++) {
        for (int j = 1; j <= n; j++) {
            int x;
            cin >> x;
            if (j > 2) {
                e[last].push_back(x);
                edge[x]++;
            }
            last = x;
        }
    }
    queue<int> q;
    for (int i = 1; i <= n; i++) {
        if (edge[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        auto u = q.front();
        q.pop();
        for (auto v: e[u]) {
            edge[v]--;
            if (edge[v]) {
                continue;
            }
            q.push(v);
        }
    }
    for (int i = 1; i <= n; i++) {
        if (edge[i]) {
            cout << "NO" << endl;
            return;
        }
    }
    cout << "YES" << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

G.One-Dimensional Puzzle（构造）

题意：

有一个一维拼图，所有元素都需要排成一行，并相互连接。所有拼图元素都是完全白色的，只有当它们的形状不同时才能相互区分。

每个元素的顶部和底部都有直线边框，左右两侧都有连接点，每个连接点都可以是一个突起或一个凹槽。不能旋转元素。

可以看出，元素的类型正好有$4$种。如果左边元素的右边连接点与右边元素的左边连接点相对，那么两个元素就可以连接起来。

所有可能的元素类型。

每种类型包含$c_1,c_2,c_3,c_4$这几个元素。如果您成功地将所有元素组合成一条长链，那么拼图就算完成了。计算有多少种方法可以完成。

分析：

$1、2$得交替出现。所以二者数量不能差距过大。

$3、4$能无限自拼接。

$3$连续段能出现在$2$的前面，$1$的后面，
$4$连续段能出现在$2$后$1$前。

所以，构建出$(1,2)$基本的交替情况，然后考虑插入$3,4$的方法即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;

LL qmi(LL a, LL k) {
    LL ret = 1;
    while (k) {
        if (k & 1) ret = ret * a % mod;
        a = a * a % mod;
        k >>= 1;
    }
    return ret;
}

LL C(LL a, LL b) {
    LL u = 1, d = 1;
    for (LL i = 1, j = a; i <= b; i++, j--) {
        u = u * j % mod;
        d = d * i % mod;
    }
    return u * qmi(d, mod - 2) % mod;
}

void solve() {
    LL a, b, c, d;
    cin >> a >> b >> c >> d;
    if (abs(a - b) >= 2) {
        cout << "0" << endl;
        return;
    }
    int m = max(a, b);
    if (a != b) {
        cout << C(c + m - 1, m - 1) * C(d + m - 1, m - 1) % mod << endl;
    } else {
        if (!m)
            cout << (!c || !d) << endl;
        else
            cout << (C(c + m - 1, m - 1) * C(d + m, m) + C(c + m, m) * C(d + m - 1, m - 1)) % mod << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

赛后交流

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

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