Codeforces think cell Round 1 A~E

A.Maximise The Score（贪心）

题意：

白板上写着 $2n$ 个正整数。你觉得无聊，决定用白板上的数字玩一个单人游戏。

开始时，你的分数为$0$。你可以通过走下面的棋$n$次来增加你的分数：

• 选择写在白板上的两个整数$x$和$y$。
• 将$\min (x,y)$加到您的分数中。
• 擦去白板上的$x$和$y$。

注意，在走完$n$步之后，白板上不会有任何整数。

如果你以最佳方式走完$n$步棋，计算你最终能得到的最高分。

分析：

将数组从大到小排序，每次加分为两数中的最小值，能够发现数组中的最大值一定不会作为分数加入，若一次选择最大值与任意数，则可以将任意数加入分数，所以每次选择第二大的值与最大值一起被删除，重复此操作即为最优。

代码：

#include<bits/stdc++.h>

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

int a[N];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 0; i < 2 * n; i++) cin >> a[i];
        sort(a, a + 2 * n);
        int ans = 0;
        for (int i = 0; i < n; i++) ans += a[2 * i];
        cout << ans << endl;
    }
    return 0;
}

B.Permutation Printing（模拟）

题意：

给你一个正整数$n$。

请找出一个长度为$n$的排列${}^{†}$。要求长度为$n$的排列$p$中，不存在两个不同的索引$i$和$j$（$1\le i,j<n$；$i\ne j$），使得$p_i$整除$p_j$和$p_{i+1}$整除$p_{j+1}$。($1\le i,j<n$;$i\ne j$)。

在此问题的限制条件下，可以证明至少存在一个$p$。

${}^{†}$长度为$n$的排列是由$n$个不同的整数组成的数组，这些整数从$1$到$n$依次排列。例如，$[2,3,1,5,4]$是一个排列，但$[1,2,2]$不是一个排列（$2$出现了两次），$[1,3,4]$ 也不是一个排列（$n=3$，但数组中有$4$）。

分析：

任意$>\frac{n}{2}$的数字都不可能是任何数字的倍数。若我们大小交替排序，如果$a_i$能够整除$a_j$，那么一定会有$a_{i+1}>a_{j+1}$，不可能满足整除，交替排序即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        int i = 1, j = n;
        while (i < j) {
            cout << i << ' ' << j << ' ';
            i++;
            j--;
        }
        if (i == j)
            cout << i << ' ';
        cout << endl;
    }
    return 0;
}

C.Lexicographically Largest（模拟）

题意：

史塔克有一个长度为$n$的数组$a$。他还有一个空集$S$。注意，$S$并不是一个多重集。

他将进行以下三步操作恰好$n$次：

1. 选择一个序号$i$，使得$1\le i\le |a|$。
2. ${}^{†}$将$a_i+i$插入$S$。
3. 从$a$中删除$a_i$。注意，$a_i$右边所有元素的索引将减少$1$。

注意，$n$次操作后，$a$将为空。

现在，史塔克将构造一个新数组$b$，这个数组以$S$降序排列。形式上，$b$是一个大小为$|S|$的数组，其中$b_i$是$S$的第$i$大元素（$1\le i\le |S|$）。

求史塔克操作后可以产生的字典序最大${}^{‡}$的数组$b$。

${}^{†}$集合只能包含唯一的元素。插入一个已经存在于集合中的元素不会改变集合的元素。

${}^{‡}$如果且仅当以下情况之一成立时，数组$p$在字典序上大于序列$q$：

• $q$是$p$的前缀，但$p\ne q$；
• 或者在数组$p$和$q$不同的第一个位置上，数组$p$中有一个比$q$中对应元素更大的元素。

注意，$[3,1,4,1,5]$ 按字典序大于$[3,1,3]$、$[]$和$[3,1,4,1]$，但不大于$[3,1,4,1,5,9]$、$[3,1,4,1,5]$和$[4]$ 。

分析：

题意为先确定所有数后再进行降序去重排序，而不是先移除的数一定在后移除的数之前。因为最后会进行排序，集合中的数越大越好，先选择前面的数后面索引$i$会减小，所以先选后面的数字插入集合是最优的。

考虑集合要去重，如果数组$q$是数组$p$的前缀且$p\ne q$那么$p$的字典序大于$q$。所以需要将相同的数字减少去重达到增大数组长度的目的。即对于相同的数字，优先取其前面的数，使其索引减少，如此最终集合的长度一定可以取到$n$。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 3e5 + 10;
int a[N];

bool cmp(int x, int y) {
    return x > y;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            a[i] += i;
        }
        sort(a + 1, a + 1 + n, cmp);
        for (int i = 2; i <= n; i++) {
            a[i] = min(a[i], a[i - 1] - 1);
        }
        for (int i = 1; i <= n; i++) {
            cout << a[i] << " ";
        }
        cout << endl;
    }
    return 0;
} 

D.Sum over all Substrings（动态规划）

题意：

题目两个版本的唯一区别在于对$t$和$n$的限制。

对于长度均为$m$的二进制${}^{†}$模式$p$和二进制字符串$q$，如果对于每个$i$($1\le i\le m$)，都存在索引$l$和$r$满足下列要求，那么$q$称为$p-good$：

• $1\le l\le i\le r\le m$
• $p_i$是字符串$q_l,q_{l+1},\dots ,q_r$的模式${}^{‡}$。

对于模式$p$来说，$f(p)$是二进制字符串$p$（长度与模式相同）中$1$个数的最小值。

给你一个大小为$n$的二进制字符串$s$。求
$$\sum _{i=1}^n\sum _{j=i}^{n}f(s_i{s}_{i+1}\dots s_j)$$

即对$s$的所有$\frac{n(n+1)}{2}$子串中$f$的值求和。

${}^{†}$二进制模式是指仅由字符$0$和$1$组成的字符串。

${}^{‡}$如果$t$中$c$的出现次数至少为$\lceil \frac{m}{2}\rceil$，则字符$c$是长度为$m$的字符串$t$的模式。例如，$0$是$010$的模式，$1$ 不是$010$的模式，而$0$和$1$都是$011010$的模式。

分析：

题意较难理解。$D1$的数据量可以通过暴力计算每一个子区间的答案解决。枚举所有$[l,r]$。设$d{p}_i$代表$1-i$所有前缀的答案。发现$010$的结构可以把长度$3$的覆盖。长度$2$和长度$1$差不多。因此$d{p}_i$可以转移到$d{p}_{i-1}$、$d{p}_{i-2}$、$d{p}_{i-3}$。

$D2$枚举$r$。发现除$[r,r]$、$[r-1,r]$以外，其他的一定是$[r-2,r]$要在$dp$中是最佳转移。因此可以进行优化。

代码：

#include<bits/stdc++.h>

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

void solve() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    s = " " + s;
    LL ans = 0;
    vector<LL> dp(n + 1, 0);//坑点，使用数组初始化会超时
    for (int i = 1; i <= n; i++) {
        LL t = ans;
        if (s[i] == '1') {
            ans += s[i] - '0';
            if (i >= 2)
                ans += (s[i] - '0' + s[i - 1] - '0' + 1) / 2;
            if (i >= 3)
                ans += dp[i - 3] + (i - 2) * ((s[i] - '0' + s[i - 1] - '0' + s[i - 2] - '0' + 2) / 3);
        } else {
            ans += dp[i - 1];
        }
        dp[i] = ans - t;
    }
    cout << ans << endl;
}

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

E.2…3…4… Wonderful! Wonderful!（数学）

题意：

史塔克有一个长度为$n$的数组$a$，其中对于所有$i$($1\le i\le n$)，$a_i=i$。他将选择一个正整数$k$($1\le k\le \lfloor \frac{n-1}{2}\rfloor$) 并对$a$进行任意次数（可能是$0$次）的以下运算。

• ${}^{†}$从$a$中选择长度为$2\cdot k+1$的子序列$s$。他会从$a$中删除$s$的前$k$个元素。为了保持完全平衡，他还将从$a$中删除$s$的最后$k$个元素。

史塔克想知道对于每个$k$（$1\le k\le \lfloor \frac{n-1}{2}\rfloor$），最后能有多少个数组$a$。由于史塔克不擅长计算问题，他需要你的帮助。

由于数组的数目可能太大，答案对$998244353$取模。

${}^{†}$如果$x$可以通过删除几个（可能是零个或全部）元素从$y$得到，那么序列$x$就是序列$y$的子序列。例如，$[1,3]$、$[1,2,3]$和$[2,3]$是$[1,2,3]$的子序列。$[3,1]$和$[2,1,3]$不是$[1,2,3]$的子序列。

分析：

需要找出可能的$b$个数。可以求出长度为$n$的二进制字符串$s$的个数，如果$i$出现在$b$中，则$s_i=1$，否则$s_i=0$。

对于给定的$n$和$k$，如果存在可以从$a$得到$b$，我们称$s$为好字符串。

对于本题，与其计算好的字符串$s$，不如计算不坏的字符串的数量。

为了方便起见，只考虑$0$的个数能被$2k$整除的字符串$s$ 。

当且仅当在$s$中从左边开始的$k$个$0$和从右边开始的$k$个$0$之间不存在任何$1$时，$s$是坏的。

把左边的第$k$个$0$和右边的第$k$个$0$之间的所有$0$压缩成一个$0$，并称这个新字符串为$t$。需要注意的是，$t$中将包含$2k-1$个$0$。$0$'s。我们还可以观察到，对于每一个$t$，都存在一个唯一的$s$。因为$n$和$k$已经被固定。因此，恰好有 $x$个$1$的坏字符串$s$的数量是$\left(\genfrac{}{}{0ex}{}{x+2k-1}{2k-1}\right)$ ，因为恰好有$\left(\genfrac{}{}{0ex}{}{x+2k-1}{2k-1}\right)$个二进制字符串$t$含有$2k-1$个$0$以及$x$个$1$。

最后，恰好有$\left(\genfrac{}{}{0ex}{}{n}{x}\right)-\left(\genfrac{}{}{0ex}{}{x+2k-1}{2k-1}\right)$个好的二进制字符串$s$具有$x$个$1$个和$n-x$个$0$。不需要为从$1$到$n$的每个$x$找出这个值，因为$s$中$0$的个数（$n-x$）应该是$2k$的倍数。$x$中只有$O(\frac{n}{2k})$是有用的候选数。复杂度$O(n\log (n))$。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;
const LL N = 1e6 + 10;

LL fac[N], inv[N];

LL pw(LL x, LL y) {
    LL res = 1;
    while (y) {
        if (y & 1) {
            res = res * x % mod;
        }
        x = x * x % mod;
        y >>= 1;
    }
    return res;
}

LL Inv(LL x) {
    return pw(x, mod - 2);
}

void init() {
    fac[0] = inv[0] = 1;
    for (int i = 1; i < N; i++) {
        fac[i] = fac[i - 1] * i % mod;
        inv[i] = Inv(fac[i]);
    }
}

LL C(LL x, LL y) {
    if (x < 0 || y < 0 || x < y)return 0;
    return fac[x] * inv[y] % mod * inv[x - y] % mod;
}

int main() {
    init();
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int k = 1; k * 2 < n; k++) {
            LL ans = 1;
            for (int t = 1; 2 * k * t < n; t++) {
                ans = (ans + C(n, 2 * k * t) - C(n - 2 * k * (t - 1) - 1, 2 * k - 1) + mod) % mod;
            }
            cout << ans << " ";
        }
        cout << endl;
    }
    return 0;
}

赛后交流

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

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