Codeforces CodeTON Round 8(Div.1 + Div.2) A~E

关注

原创最新推荐文章于 2026-11-09 09:29:43 发布 930 阅读 AI 写同款· GEO 优化 ›

5个4000比特大状态置换算法的设计与分析下面是 5 个概念性、实验性的 4000 位可逆置换设计。它们都保证是双射，但未经过密码分析，不可直接用于生产系统。风格分别覆盖：三维 SPN、Feistel、可逆元胞自动机、ARX、宽轨迹/Keccak 式结构。这 5 个设计分别代表了 SPN、Feistel、元胞自动机、ARX、宽轨迹 Keccak 五种不同风格，覆盖了主流大状态置换的构造思路。再次强调：它们只是实验性概念，若要用于实际协议，必须经过严格安全性分析。阅读详情

A. Farmer John’s Challenge (模拟)

题意：

构造一个长度为 $n$ 的数组，将这些数组围成一个圈（顺时针）从任意一个位置打开，有且仅有 $k$ 个非降序排列的数组。

分析：

$k = 1$ 时，升序输出 $1 - n$ ， $n = k$ 时，全 $1$ 即可。其他情况都是 $- 1$ 。

代码：

#include <bits/stdc++.h>

using namespace std;
const int mod = 1e9 + 7;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        if (k == 1) {
            for (int i = 1; i <= n; i++)
                cout << i << " ";
            cout << endl;
        } else if (n == k) {
            for (int i = 1; i <= n; i++)
                cout << 1 << " ";
            cout << endl;
        } else
            cout << -1 << endl;
    }
    return 0;
}

B.Bessie and MEX （思维）

题意：

给出一个长度为 $n$ 的数组 $a$ ，根据 $a$ 构造出一个排列 $p$ 。数组 $a$ 的构造使得 $a_i$ = $MEX(p1,p2,…,pi)−pi\texttt{MEX}(p_1, p_2, \ldots, p_i) - p_i$ ，其中数组的 $MEX\texttt{MEX}$ 是该数组中没有出现的最小非负整数。

分析：

$a_i>0$ ，填入当前的最小值，同时更新最小值， $a_i<0$ 时， $m e x$ 没有更新，加上绝对值即可。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int a[N], p[N];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        int minval = 0;
        for (int i = 1; i <= n; i++) {
            if (a[i] > 0) {
                p[i] = minval;
                minval = a[i] + minval;
            } else {
                p[i] = minval - a[i];
            }
        }
        for (int i = 1; i <= n; i++)
            cout << p[i] << " ";
        cout << endl;
    }
    return 0;
}

C1. Bessie’s Birthday Cake (Easy Version) (数学)

题意：

贝西从她最好的朋友埃尔西那里收到了一个生日蛋糕，它是一个边长为 $n$ 的正多边形。蛋糕的顶点按顺时针方向从 $1$ 排列到 $n$ 。你和贝西将选择其中的一些顶点在蛋糕上切出不相交的对角线。换句话说，对角线的端点必须是所选顶点的一部分。
为了保持一致性，贝西只想分发三角形的蛋糕。蛋糕块的大小并不重要，整个蛋糕也不一定要分成三角形（蛋糕中可以有其他形状，但不计算在内）。
贝西已经选择了 $x$ 个顶点，可以用来组成对角线。她希望你选择的其他顶点不超过 $y$ ，这样她能分出的三角形蛋糕的数量就能达到最大。
贝西最多能分出多少块三角形蛋糕？
此题保证 $y = 0$

分析：

假设对答案有贡献的点叫有效点,可以发现如果两个点之间正好只有一个点,那么这个点也是有效的,答案是总的有效点数减 $2$ .

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int a[N];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, x, y, cnt;
        cin >> n >> x >> y;
        cnt = x - 2;
        for (int i = 1; i <= x; i++)
            cin >> a[i];
        sort(a + 1, a + x + 1);
        for (int i = 1; i < x; i++) {
            if (a[i] + 1 == a[i + 1] - 1) {
                cnt++;
            }
        }
        if (a[x] == n - 1 && a[1] == 1)
            cnt++;
        else if (a[x] == n && a[1] == 2)
            cnt++;
        cout << cnt << endl;
    }
    return 0;
}

C2.Bessie’s Birthday Cake (Hard Version) (数学)

题意：

分析：

通过简单版本发现，每次操作可以让有效点数加 $2$ ，但是如果一段只剩下 $3$ 个点,那么可以一次性操作让有效点数加 $3$ 。同时发现奇数间隔可以获得的贡献更大，所以优先操作间距短的奇数长度区间间隔，再操作偶数区间间隔。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, x, y;
        cin >> n >> x >> y;
        vector<int> a(x);
        for (int i = 0; i < x; i++)
            cin >> a[i];
        sort(a.begin(), a.end());
        int sum = x;
        vector<int> tmp[2];
        for (int i = 0; i < x; i++) {
            int len = a[(i + 1) % x] - a[i] - 1;
            if (len < 0)
                len += n;
            if (len == 1)
                sum += 1;
            if (len > 1) {
                tmp[len % 2].push_back(len);
            }
        }
        for (int i = 1; i >= 0; i--) {
            sort(tmp[i].begin(), tmp[i].end());
            for (auto u: tmp[i]) {
                if (u % 2 == 1) {
                    int num2 = (u - 3) / 2;
                    int t = min(y, num2);
                    y -= t;
                    sum += t * 2;
                    int num3 = 1;
                    t = min(y, num3);
                    y -= t;
                    sum += t * 3;
                } else {
                    int num2 = u / 2;
                    int t = min(y, num2);
                    y -= t;
                    sum += t * 2;
                }
            }
        }
        cout << sum - 2 << endl;
    }
    return 0;
}

D.Learning to Paint (dp)

题意：

艾尔西正在学习如何绘画。她的画布上有 $n$ 个单元格，编号从 $1$ 到 $n$ ，她可以画任何（可能是空）单元格子集。
艾尔西有一个二维数组 $a$ ，她将用这个数组来评估绘画作品。假设一幅画中绘画单元格的最大连续间隔为 $[l1,r1],[l2,r2],…,[lx,rx][l_1,r_1],[l_2,r_2],\ldots,[l_x,r_x]$ 。这幅画的美丽值是所有 $\le i \le x$ 中 $a_{l_i,r_i}$ 的总和。
有 $2^n$ 种方法可以绘制条形图。请帮助艾尔西找出在所有这些方法中，前 $k$ 大的美丽值。这 $k$ 种美丽值可以相同，但要保证至少有 $k$ 种画法。

分析：

$f$ 表示使用前 $i$ 个位置的前 $k$ 大和，但是位置 $i$ 不一定要涂色。 $g$ 表示使用前 $i$ 个位置且以 $i$ 开头的前 $k$ 大和，保证位置 $i$ 为涂色开头。即 $f [i] [j]$ 表示使用前 $i$ 个位置，第 $j$ 大的和。 $g [i] [j]$ 表示使用前 $i$ 个位置， $i$ 涂色且 $i - 1$ 不涂色第 $j$ 大的和。
维护 $f [i]$ ，可以用优先队列，从 $g [1... i]$ 转移，同时维护 $g [1... i]$ 最大的值，取前 $k$ 个用于更新 $f [i]$ 。在更新 $g [i + 1]$ 时，因为 $i$ 不涂色，以 $i - 1$ 及前面的位置结尾都可，因此就是 $g [i + 1] = f [i - 1];$

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
#define PII pair<LL, LL>
const int mod = 1e9 + 7;
const int INF = 1e9;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        vector<vector<int>> a(n + 1, vector<int>(n + 1));
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                cin >> a[i][j];
            }
        }
        vector<vector<int>> f(n + 1, vector<int>(k, -INF));
        vector<vector<int>> g(n + 2, vector<int>(k, -INF));
        g[1][0] = 0;
        f[0][0] = 0;
        vector<int> c(k);
        vector<int> p(n + 1);
        for (int i = 1; i <= n; i++) {
            priority_queue<PII > tmp;
            for (int j = 1; j <= i; j++) {
                tmp.push({g[j][0] + a[j][i], j});
                p[j] = 0;
            }
            for (int t = 0; t < k; t++) {
                auto [s, j] = tmp.top();
                tmp.pop();
                f[i][t] = s;
                p[j]++;
                tmp.push({g[j][p[j]] + a[j][i], j});
            }
            int l = 0, r = 0;
            for (int t = 0; t < k; t++) {
                c[t] = max(f[i - 1][l], f[i][r]);
                if (f[i - 1][l] > f[i][r])
                    l++;
                else
                    r++;
            }
            f[i] = c;
            g[i + 1] = f[i - 1];
        }

        for (int i = 0; i < k; i++) {
            cout << f[n][i] << " ";
        }
        cout << endl;
    }
    return 0;
}

E.Farm Game (组合数)

题意：

农夫 $N h o j$ 带着他的奶牛来到农夫 $J o hn$ 的农场玩游戏！农夫约翰的农场可以用一条在 $0$ 和 $l + 1$ 点有墙的数线来模拟。农场里有 $2 n$ 头奶牛，其中 $n$ 头属于 $F J$ ，另外 $n$ 头属于 $FN$ 。他们把每头牛都放在一个不同的点上， $F J$ 的牛和 $FN$ 的牛都不相邻。如果两头奶牛之间没有其他奶牛，它们就是相邻的。
在一次下棋中，农夫选择了 $k$ $\leq k \leq n)$ 和一个方向（左或右）。然后，农夫选择 $k$ 头奶牛，并将它们朝所选方向移动一个位置。农场主不能将自己的奶牛移动到墙上或其他农场主的奶牛上。如果一位农夫不能移动任何奶牛，那么他就输了。 $F J$ 先开始游戏，进行第一个回合。
给定 $l$ 和 $n$ ，求如果两个农夫都以最佳方式下棋，农夫约翰可能获胜的棋局配置数。对局可能无限期地进行下去，在这种情况下没有农民获胜。如果有任何 $i$ 与 $a_i$ 或 $b_i$ 不同，则该配置与另一种配置不同。输出答案，请将答案对 $998244353$ 取模。

分析：

首先发现 $a [i]$ 在 $b [i]$ 前面和 $a [i]$ 在 $b [i]$ 后面这两种情况实际是一样，只需要计算其中一种情况，最后答案乘 $2$ 即可。
如果 $b [i] - a [i] - 1$ 不全为偶数，那么就是 $F J$ 必胜。因为全为偶数是必败态，又由于 $k$ 至少为 $1$ ，如果全是偶数， $F J$ 转移一次后 $FN$ 获得的是必胜态。如果不全是偶数， $F J$ 可以转移一次全变成偶数， $FN$ 获得的就是必败态了。
我们逆向考虑，用总答案数减去全为偶数的情况。总答案数为 $C(l,2×n)C(l,2\times n)$ 。当 $(b [i] - a [i] - 1)$ 全为偶数时，考虑空地怎么插在牛之间， $(a, b)$ 内只能插偶数块空地，枚举插入 $(a, b)$ 内的空地对的个数为 $m$ 。 $(a, b)$ 一共有 $n$ 组，答案为 $C (n + m - 1, m - 1)$ 。
剩下的空地插在 $(b, a)$ 和 $(0, a [0])$ , $(b [n], l + 1)$ 内，一共 $n + 1$ 组，用同样的方法计算。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 5;
const int mod = 998244353;

template<const int T>
struct ModInt {
    const static int mod = T;
    int x;

    ModInt(int x = 0) : x(x % mod) {}

    ModInt(long long x) : x(int(x % mod)) {}

    int val() { return x; }

    ModInt operator+(const ModInt &a) const {
        int x0 = x + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    ModInt operator-(const ModInt &a) const {
        int x0 = x - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    ModInt operator*(const ModInt &a) const { return ModInt(1LL * x * a.x % mod); }

    ModInt operator/(const ModInt &a) const { return *this * a.inv(); }

    bool operator==(const ModInt &a) const { return x == a.x; };

    bool operator!=(const ModInt &a) const { return x != a.x; };

    void operator+=(const ModInt &a) {
        x += a.x;
        if (x >= mod)
            x -= mod;
    }

    void operator-=(const ModInt &a) {
        x -= a.x;
        if (x < 0)
            x += mod;
    }

    void operator*=(const ModInt &a) { x = 1LL * x * a.x % mod; }

    void operator/=(const ModInt &a) { *this = *this / a; }

    friend ModInt operator+(int y, const ModInt &a) {
        int x0 = y + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    friend ModInt operator-(int y, const ModInt &a) {
        int x0 = y - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    friend ModInt operator*(int y, const ModInt &a) { return ModInt(1LL * y * a.x % mod); }

    friend ModInt operator/(int y, const ModInt &a) { return ModInt(y) / a; }

    friend ostream &operator<<(ostream &os, const ModInt &a) { return os << a.x; }

    friend istream &operator>>(istream &is, ModInt &t) { return is >> t.x; }

    ModInt pow(int64_t n) const {
        ModInt res(1), mul(x);
        while (n) {
            if (n & 1)
                res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    ModInt inv() const {
        int a = x, b = mod, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        if (u < 0)
            u += mod;
        return u;
    }
};

using mint = ModInt<mod>;

mint fact[N], invfact[N];

void init() {
    fact[0] = invfact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i;
    invfact[N - 1] = fact[N - 1].inv();
    for (int i = N - 2; i; i--)
        invfact[i] = invfact[i + 1] * (i + 1);
}

inline mint C(int a, int b) {
    if (a < 0 || b < 0 || a < b)
        return 0;
    return fact[a] * invfact[b] * invfact[a - b];
}

int main() {
    init();
    int t;
    cin >> t;
    while (t--) {
        int l, n;
        cin >> l >> n;
        mint ans = C(l, 2 * n);
        int k = l - 2 * n;
        for (int m = 0; 2 * m <= k; m++) {
            mint res = C(n + m - 1, n - 1);
            res *= C((n + 1) + (k - 2 * m) - 1, (n + 1) - 1);
            ans -= res;
        }
        ans *= 2;
        cout << ans << endl;
    }
    return 0;
}