CSP-J2025 题解

拼数

思路

先考虑怎么把数字提取出来，可以拿一个字符串变量存储整个输入，然后遍历这个字符串，如果当前字符是 '0' 到 '9' 就可以通过将它减去 '0' 的方式放到一个整形数组中。

接下来考虑拼出最大的数，显然让这个数组从大到小排序就好了。

代码

void solve(void) {
    std::string s;
    std::cin >> s;
    std::vector<int> num;
    for(auto i : s) {
        if(i >= '0' && i <= '9') num.push_back(i - '0');
    }
    std::sort(num.begin(), num.end(), std::greater<int>());
    for(auto i : num) std::cout << i;
}

座位

思路

首先要找到排序后小R是第几个。注意到每个人的分数都是不同的，所以可以先记录一下小R的分数，然后对所有人排序，之后遍历排序后的数组，找到小R的分数就相当于找到了他的排名。

接下来考虑这个排名所在的位置，由于是按列坐的，每列又有 \(n\) 个人，所以第 \(i\) 个人应该在第 \(\lceil i / n \rceil\) 列上。接下来考虑在第几行，注意到奇数列上从上往下排，偶数列是从下往上排。先全部看作从上往下，那么第 \(i\) 个人应该在这一列的第 \(i \bmod n\) 上，需要注意的是如果 \(i \bmod n = 0\) 说明他在这一列的第 \(n\) 个位置。接下来考虑偶数列是从下往上排，只需要将它的位置倒过来就好了，即 \(row = n - row + 1\) 。

代码

void solve(void) {
    int n, m;
    std::cin >> n >> m;
    std::vector<int> a(n * m + 1);
    int goal = 0, idx = 0;
    for(int i = 1; i <= n * m; i++) {
        std::cin >> a[i];
        if(i == 1) goal = a[i];
    }
    std::sort(a.begin() + 1, a.end(), std::greater<int>());
    for(int i = 1; i <= n * m; i++) {
        if(a[i] == goal) {
            idx = i;
            break;
        }
    }
    //std::cout << idx << '\n';
    int col = (idx + n - 1) / n;
    int row = idx % n;
    if(row == 0) row = n;
    if(col % 2 == 0) {
        row = n - row + 1;
    }
    std::cout << col << ' ' << row;
}

异或和

思路

首先需要知道的是，区间异或和是可以用前缀和的方式维护的。所以先维护一个前缀异或和，接下来考虑 DP。

设 \(f_i\) 是前 \(i\) 个元素中异或和为 \(k\) 的最大不相交区间数量，有边界 \(f_0 = 0\) ，所求答案为 \(f_n\) 。

考虑怎么转移，有两种情况：

1. 选了下一个位置后不发生改变，即 \(f_i = f_{i - 1}\) ；
2. 选了下一个位置后发生了改变，这就说明当前位置与之前某个区间的异或和为 \(k\) ，设当前区间的异或和为 \(x_i\) ，则要求的某个区间的异或和为 \(x_i \oplus k\) ，如果存在这个结果，就可以从它转移过来。

每次在两种情况中取最大值，因此状态转移方程为：

\[f_i = \left\{\begin{matrix} f_i - 1 \\ \max(f_{i - 1}, f_{x_i \oplus k} + 1) & \text{存在异或和为 $x_i \oplus k$ 的区间} \end{matrix}\right.\]

维护是否存在指定的异或和及其的状态值，可以使用 STL::map 。

代码

void solve(void) {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n + 1);
    for(int i = 1; i <= n; i++) std::cin >> a[i];
    std::vector<int> x(n + 1);
    for(int i = 1; i <= n; i++) {
        x[i] = x[i - 1] ^ a[i];
    }
    std::vector<int> f(n + 1);
    std::map<int, int> best;
    best[0] = 0;    //千万注意在map中要初始化边界
    for(int i = 1; i <= n; i++) {
        f[i] = f[i - 1];
        int Xor = x[i] ^ k;
        auto it = best.find(Xor);
        if(it != best.end()) {
            f[i] = std::max(f[i], it->second + 1);
        }
        best[x[i]] = std::max(best[x[i]], f[i]);
    }
    std::cout << f[n];
}

多边形

思路

一共有 \(n\) 根木棍，那么所有可能的集合数量就为 \(2^n\) ，在这些集合中，我们只需要大小至少为 \(3\) 的集合，数量就为 \(2^n - \binom{n}{0} - \binom{n}{1} - \binom{n}{2}\)

。

将存边的数组 \(a\) 从小到大排序。对于每一个集合 ，当它的最大边是 \(a_i\) 时，剩余的边一定是由 \(a_1 \cdots a_{i - 1}\) 构成的，设这些边的集合为 \(T\) ，如果当前的集合大小至少为 \(3\) 且不合法，有以下条件：

\[|T| + 1 \geq 3 \Rightarrow |T| \geq 2 \]

\[\sum_{j \in T} a_j + a_i \leq 2 \times a_i \Rightarrow \sum_{j \in T} \leq a_i \]

设 \(f_i\) 是以 \(i\) 为最大边的不合法子集数量，总的不合法子集数量之和就为 \(\sum_{i = 1}^{n} f_i\)

显然最后的答案就是总集合的数量减去这些不合法集合的数量，考虑用 01背包维护不合法的子集数量。

设 \(dp_s\) 为当前前缀中和为 \(s\) 的子集数量，有边界 \(dp_0 = 1\) 。接下来考虑转移，对于所有的 \(i \in \{1 \cdots n\}\)，有 \(dp_{s} = (dp_{s} + dp_{s - a_i}) \bmod 998244353\) ，显然数组 \(dp\) 的大小应该为所有木棍的值域。

当处理到第 \(i\) 个时，\(\sum_{s = 0}^{a_i}dp_s\) 包含了所有和小于等于 \(a_i\) 的集合数量，我们要删去其中只有一个元素的集合和一个空集，所以\(f_i = (\sum_{s = 0}^{a_i}dp_s - 1 - (i - 1)) \bmod 998244353\) 。

那么最后的答案就是 \((2^n - \binom{n}{0} - \binom{n}{1} - \binom{n}{2} - \sum_{i = 1}^{n}f_i) \bmod 998244353\) 。

代码

using i64 = long long;
const int P = 998244353;
void solve(void) {
    int n; std::cin >> n;
    std::vector<int> a(n + 1);
    std::vector<int> p2(5001);
    p2[0] = 1;
    for(int i = 1; i <= 5000; i++) p2[i] = p2[i - 1] * 2 % P;
    for(int i = 1; i <= n; i++) std::cin >> a[i];
    std::sort(a.begin() + 1, a.end());
    int maxn = a[n];
    std::vector<i64> dp(maxn + 1);
    dp[0] = 1;
    std::vector<i64> f(n + 1);
    int ans = 0;
    for(int i = 1; i <= n; i++) {
        i64 sums = 0;
        for(int s = 0; s <= a[i]; s++) sums = (sums + dp[s]) % P;
        f[i] = (sums - 1 - (i - 1) + P) % P;
        for(int s = maxn; s >= a[i]; s--) dp[s] = (dp[s] + dp[s - a[i]]) % P;
    }
    i64 sum = 0;    //不合法子集数量之和
    for(int i = 1; i <= n; i++) {
        sum = (sum + f[i]) % P;
    }
    i64 T = (p2[n] - 1 - n - n * (n - 1) / 2 + P) % P;    //大小大于等于三的集合总数
    std::cout << (T - sum + P) % P;
}