第十二届蓝桥杯大赛软件赛省赛（C++研究生组）

第十二届蓝桥杯大赛软件赛省赛（C++研究生组）

A: 卡片

同 大学B组 试题 B .

B: 直线

同 大学B组 试题 C .

C: 货物摆放

同 大学B组 试题 D .

D: 路径

同 大学B组 试题 E .

E: 回路计数

动态规划或者记忆化搜索.

$f_{s,i}$ 代表在已经访问过集合 $s$ 中顶点的前提下目前处于顶点 $i$ 的方案数.

递归终止条件可设为 f { i } , i = 1 f_{\{i\},i}=1 f{i},i​=1 .

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int n = 21;
long long f[1 << n][n];  // f[s][i] 代表在状态 s 下到达点 i 的方案数
bool mp[n][n];
long long dfs(int s, int u) {
    if (!(s & s - 1)) return s >> u;
    if (f[s][u] != -1) return f[s][u];
    f[s][u] = 0;
    for (int v = 0; v < n; ++v) {
        if (!(s >> v & 1) || !mp[v][u]) continue;
        f[s][u] += dfs(s ^ (1 << u), v);
    }
    return f[s][u];
}

int main()
{
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if (__gcd(i + 1, j + 1) == 1) mp[i][j] = mp[j][i] = true;
        }
    }
    memset(f, -1, sizeof(f));
    cout << dfs((1 << n) - 1, 0) << endl;  // 881012367360
    return 0;
}

F: 时间显示

同 大学B组 试题 F .

G: 砝码称重

同 大学B组 试题 G .

H: 异或数列

令 $c=\underset{i=1}{\overset{n}{⨁}}{X}_i$ .

游戏结束之后，一定有 $a\oplus b=c$ . 平局当且仅当 $a\oplus b=0$ ，当且仅当 $c=0$ .

下面讨论 $c\ne 0$ 的情况.

记 $a=a_{19}{a}_{18}\cdots a_0$， $b=b_{19}{b}_{18}\cdots b_0$ ， $c=a_{19}{a}_{18}\cdots a_0$.

考虑 $a,b,c$ 的第 $i$ 位：

• 若 $c_i=0$ ，则 $a_i=b_i$ .
• 若 $c_i\ne 0$ ，则 $a_i\ne b_i$ .

因此 ∃ k ∈ { 19 , 18 , ⋯   , 0 } , \exists k\in \{19,18,\cdots,0\}, ∃k∈{19,18,⋯,0}, 使得 $\forall i>k(c_i=0),c_k=1$ . 容易证明 $a>b\iff a_k>b_k$ ，$a<b\iff a_k<b_k$ .

第 $k$ 位为 $1$ 的 $X$ 一定有奇数个，于是

• 若 $n$ 为奇数，$Alice$ 先手取一个 $k$ 位为 $1$ 的数给自己，此时剩下的 $k$ 位为 $1$ 和为 $0$ 的数均为偶数个，之后无论 $Bob$ 取哪一类数给谁， $Alice$ 都可以跟着做. 此时 $Alice$ 必胜.
• 若 $n$ 为偶数，$Alice$ 先手必须取 $k$ 位为 $1$ 的数给自己（否则将转化为 $n$ 为奇数先手必胜的情况，使得 $Bob$ 必胜）. 此时若只剩下 $k$ 位为 $0$ 的数，则 $Alice$ 必胜；否则 $Bob$ 取出一个 $k$ 位为 $0$ 的数，剩下的 $k$ 位为 $1$ 和为 $0$ 的数均为偶数个，之后 $Alice$ 取 $0$ 则 $Bob$ 取 $0$ ， $Alice$ 取 $1$ 则 $Bob$ 取 $1$ ，因为 $Alice$ 取 $1$ 总会导致 $a,b$ 的 $k$ 位相同，而 $Bob$ 取 $1$ 总会导致 $a,b$ 的 $k$ 位不同，所以 $Bob$ 取 $1$ 时总可以做出对自己有利决策，此时 $Bob$ 必胜.

时间复杂度 $O(n)$ .

#include <iostream>
#include <vector>
#include <functional>

using namespace std;
int main()
{
    int T;
    scanf("%d", &T);
    while (T--) {
        int n;
        scanf("%d", &n);
        vector<int> a(n);
        for (auto &p : a) scanf("%d", &p);
        int t = 0;
        for (auto x : a) t ^= x;
        if (t == 0) {
            puts("0");
            continue;
        }
        if (n & 1) {
            puts("1");
            continue;
        }
        while (t & (t - 1)) t = t & (t - 1);
        int cnt = 0;
        for (auto x : a) if (x & t) ++cnt;
        puts(cnt == 1 ? "1" : "-1");
    }
    return 0;
}

I: 双向排序

同 大学B组 试题 I .

J: 分果果

参考：

• https://blog.csdn.net/AC__dream/article/details/129431299
• https://www.acwing.com/file_system/file/content/whole/index/content/8208403/

动态规划.

小朋友是无序的，不过为了探讨方便，不妨人为规定一个顺序：第 $i-1$ 个小朋友被分到的最后一包糖果的编号小于等于第 $i$ 个小朋友被分到的最后一包糖果的编号. 容易证明，这样的规定对本题答案没有影响.

记 $lb$ 为 $m$ 个小朋友被分到糖果重量的下界，于是 $1\le lb\le \lfloor \frac{2s_n}{m}\rfloor$ . 其中 $s_i=\sum _{t=1}^i{w}_t$ .

对于每一个 $lb$ ，记 $f_{i,j,k}$ 代表在将前 $j$ 包糖果分给前 $i$ 个小朋友，且第 $i-1$ 个小朋友被分到的最后一包糖果编号不超过 $k$ 的条件下，前 $i$ 个小朋友被分到糖果重量的最大值（$lb$ 只是一个下界，不一定是最小值）. 其中 $j\ge \lceil \frac{i}{2}\rceil ,\lceil \frac{i-1}{2}\rceil \le k\le j$ .

初始化 $f_{i,j,k}=\infty ,f_{0,0,0}=lb$ ，则

$$f_{i,j,k}=\{\begin{array}{ll}\max (f_{i-1,0,0},s_j),& i\ge 1,j\ge \lceil \frac{i}{2}\rceil ,k=0\\ \min (f_{i,j,k-1},\underset{\begin{array}{c}t\le k\\ s_j-s_t\ge lb\end{array}}{\min }\max (f_{i-1,k,t},s_j-s_t)),& i\ge 1,j\ge \lceil \frac{i}{2}\rceil ,1\le k\le j.\end{array}$$

由于随着 $t$ 值的增大， $f_{i-1,k,t}$ 与 $s_j-s_t$ 都不会增大，所以 $\underset{\begin{array}{c}t\le k\\ s_j-s_t\ge lb\end{array}}{\min }\max (f_{i-1,k,t},s_j-s_t)=\max (f_{i-1,k,p},s_j-s_p)$ ，其中 $p$ 是满足条件的最大的 $t$ .

又由于 $i,j$ 不变时，随着 $k$ 值的增大， $p$ 值不会减小，因此求 $p$ 的均摊时间复杂度为 $O(1)$ .

于是求 $f$ 的时间复杂度为 $O(n^{2}m)$ .

$\underset{lb}{\min }(f_{m,n,n}-lb)$ 即为结果.

总的时间复杂度为 $O(\frac{2s_n}{m}\cdot n^{2}m)=O(s_n\cdot n^2)$ .

编程计算 $f$ 时不用特别注意 $j,k$ 的范围，因为不合法状态已被记为 $\infty$ ，从不合法的状态转移一定不会使结果更优.

如果使用 vector ，在 AcWing 上提交容易超时.

#include <iostream>
#include <functional>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 101, M = 51;
int w[N], s[N];
int f[M][N][N]; // 在 mi 的限制下，f[i][j][k] 代表前 i 个人分配前 j 包糖果，且第 i - 1 个人的最后一包糖果不超过 k 的方案的最大值的最小值
bool vis[N * N];
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &w[i]);
        s[i] = s[i - 1] + w[i];
        for (int j = 0; j < i; ++j) {
            vis[s[i] - s[j]] = true;
        }
    }
    int ans = s[n];
    for (int lb = 1; lb <= s[n] * 2 / m; ++lb) {
        if (!vis[lb]) continue;
        memset(f, 0x3f, sizeof f);
        f[0][0][0] = lb;
        for (int i = 1; i <= m; ++i) {
            for (int j = (i + 1 >> 1); j <= n; ++j) {
                if (s[j] < lb) continue;
                f[i][j][0] = max(f[i - 1][0][0], s[j]);
                int p = 0;
                for (int k = max(1, i >> 1); k <= j; ++k) {
                    while (p <= k && s[j] - s[p] >= lb) ++p;
                    --p;
                    f[i][j][k] = min(f[i][j][k - 1], max(f[i - 1][k][p], s[j] - s[p]));
                }
            }
        }
        ans = min(ans, f[m][n][n] - lb);
    }
    printf("%d", ans);
}

值得一提的是，当 $n\times 2<m$ 时，此题无解.