2023牛客暑期多校训练营2 DEFGHIK

比赛链接

D

题解

知识点：贪心。

首先，因为第一个人喜欢吃的可能会被后面的人选中，因此直接选最喜欢吃的可能会浪费机会。所以，我们考虑先看后面的人怎么选，就是倒着贪心，我们考虑证明。

假设当前剩下的菜集合为 \(A\) ，还剩下 \(k\) 个人没选，这 \(k\) 个人通过我们的策略选的菜的集合是 \(S_{A,k}\) ，分类讨论：

1. 若 \(k=1\) ，最优结果与 \(S_{A,1}\) 一致。

2. 假设 \(k = k'\) 时的最优结果与 \(S_{A,k'}\) 一致。

   当 \(k = k'+1\) 时，设 \(A\) 中除了 \(S_{A,k'}\) 之外倒数第 \(k'+1\) 个人最喜欢的菜是 \(x\) ，对他的选择分类讨论：

   1. 若选择 \(x\) ，则结果与 \(S_{A,k'+1}\) 一致。
   2. 若选择 \(A\) 中除了 \(S_{A,k'}\) 和 \(x\) 之外的菜，则后 \(k'\) 个人结果不变，倒数第 \(k'+1\) 个人亏。
   3. 若选择 \(S_{A,k'}\) 中的菜，那么后 \(k'\) 个人有一个人的选择会改变：
      1. 若改变的那个人选择了 \(x\) ，则结果与 \(S_{A,k'+1}\) 一致。
      2. 若改变的那个人没选择 \(x\) ，则倒数第 \(k'+1\) 个人亏。

   因此 \(k = k'+1\) 时的最优解与 \(S_{A,k'+1}\) 一致，因此贪心策略是对的。

时间复杂度 \(O((n+k)m)\)

空间复杂度 \(O(nm + k)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int a[2007][2007];
int ans[2007];
bool solve() {
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 1;i <= n;i++)
        for (int j = 1;j <= m;j++)
            cin >> a[i][j];

    vector<char> vis(m + 1);
    for (int i = k;i >= 1;i--) {
        int p = i % n;
        if (!p) p = n;

        int res = 0;
        for (int j = 1;j <= m;j++) if (!vis[j] && a[p][res] < a[p][j]) res = j;
        ans[i] = res;
        vis[res] = 1;
    }

    sort(ans + 1, ans + k + 1);
    for (int i = 1;i <= k;i++) cout << ans[i] << " \n"[i == k];
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

E

题解

知识点：数学。

显然 \(y^2 \in [x \cdot 10^k,(x+1) \cdot 10^k),k \in[0,18]\) 。注意 \(y^2 \leq 10^{18}\) ，因此我们先保证 \(x \cdot 10^k \leq 10^{18}\) 。

我们枚举 \(k\) ，得到 \(y\) 可能范围的左端点 \(l =\left\lceil \sqrt{x \cdot 10^k} \right\rceil\) ，若 \(l^2 \leq \min(10^{18},(x+1) \cdot 10^k)\) ，那么 \(y = l\) 。

否则，无解。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

ll sqrt_fix(ll x, bool mode = false) {
    ll v = sqrt(x);
    while (v * v < x) ++v;
    while (v * v > x) --v;
    if (mode && v * v < x) v++;
    return v;
}

bool solve() {
    ll x;
    cin >> x;
    for (__int128_t i = x, j = x + 1;i <= (ll)1e18;i *= 10, j *= 10) {
        ll l = sqrt_fix(i, 1);
        if (l * l <= min(j - 1, (__int128_t)1e18)) {
            cout << l << '\n';
            return true;
        }
    }
    return false;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

F

题解

知识点：博弈论，二分图。

一个至关重要的模型，二分图博弈：

给出一张二分图和起点，轮流进行操作，每次操作只能选择与上一个被选的点相邻的点，且不能选择已经选择过的点，无法选点的人输掉。

关于上面的模型，结论是：若起始点一定在最大匹配上，那么先手赢，否则后手赢。

那和这道题有什么关系呢？

这道题我们把三元组 \((r,g,b)\) 抽象成三维坐标的一个点，那么所有状态构成一个 \(n^3\) 正方体，每个点可以走到相邻的点，那么这道题就变成了一个二分图博弈了，不过图是在三维上建的。接下来分类讨论：

1. 当 \(n\) 为偶数时，显然每个点都可以匹配到，因此所有点一定在最大匹配上，所以先手必胜。

2. 当 \(n\) 为奇数时，显然会有一个点在点较多一部中且没被匹配到，我们将证明这个点可以是较多一部中的任意一个点。

   首先，若点 \((r_0,g_0,b_0)\) 在较多一部中，那么 \(r_0+b_0+g_0\) 是一个奇数。若 \(r_0+g_0+b_0\) 是偶数，那么一定可以走一步，就可以与它匹配。

   因此， \(r_0,g_0,b_0\) 中一定有至少一个奇数，我们不妨假设 \(r_0\) 是奇数，显然 \(r \neq r_0\) 时的点都可以匹配到，所以我们可以只考虑 \(r = r_0\) 这一层的情况。

   因为 \(g_0+b_0\) 一定是个偶数，我们发现，总能构造出一种方法使得 \((r_0,g_0,b_0)\) 不在其中。

   综上， \(r+b+g\) 为奇数时，后手必胜，否则先手必胜。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    int n, r, g, b;
    cin >> n >> r >> g >> b;
    if ((n & 1) && (r + g + b & 1)) cout << "Bob" << '\n';
    else cout << "Alice" << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

G

题解

知识点：manacher。

中心对称字符串和回文串可以理解为是同一个东西，不过匹配方式需要自定义。

这里需要用manacher算法，其中的细节是需要修改的。

接下来是关于本题的最关键的一个性质：若一个字符串能被分为若干个中心对称串，那么它一定能分为若干个任意前缀不是中心对称的中心对称串。

这个结论让我们在从左到右枚举对称中心的途中，对于一个好的前缀，可以往后截断一个最短的前缀中心对称串，而不影响答案。

若最后整个字符串能被截断完了，那么就是好的，否则不好。

证明：

假设一个中心对称串 \(S = AB\) ，其中 \(A\) 是最短的前缀对称串。

我们证明 \(|A| \leq |S|/2\) 。若 \(|A|> |S|/2\) ，那么 \(B\) 的对称串 \(B’\) ，有 \(A = B'C\) ，使得 \(S = B'CB\) 。 那么，其中 \(C\) 一定是中心对称串，而 \(C\) 在 \(A\) 内，因此 \(A\) 的前缀一定有 \(C\) 的对称串也是中心对称的，因此 \(A\) 就不是最短的。

现在对于一个中心对称串 \(S\) 一定可以表达为 \(S = ABA'\) ，其中 \(A,B,A'\) 都是中心对称串，即一个中心对称串若含有更短的前缀中心对称串，那么就可以继续分下去，直到不包含任意前缀中心对称串。

这个结论同样适用于任何具有回文性质的字符串划分，都可以依次截断最短的前缀回文。

时间复杂度 \(O(n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

char rev[256];

void init() {
    rev['o'] = 'o';
    rev['s'] = 's';
    rev['x'] = 'x';
    rev['z'] = 'z';
    rev['b'] = 'q';
    rev['q'] = 'b';
    rev['d'] = 'p';
    rev['p'] = 'd';
    rev['n'] = 'u';
    rev['u'] = 'n';
    rev['|'] = '|';
}

bool check(char a, char b) {
    return b == rev[a];
}

bool manachar(const string &_s) {
    string s = "$|";
    for (int i = 1;i < _s.size();i++) {
        s += _s[i];
        s += "|";
    }
    s += "&";
    int n = s.size() - 1;
    vector<int> d(n + 1);

    int start = 1;
    int p = 0, r = 0;
    for (int i = 1;i <= n - 1;i++) {
        if (i <= r) d[i] = min(r - i + 1, d[2 * p - i]);
        else d[i] = 0;
        while (check(s[i - d[i]], s[i + d[i]])) d[i]++;
        if (i + d[i] - 1 > r) {
            p = i;
            r = i + d[i] - 1;
        }
        if (i - d[i] + 1 <= start) {
            start = i + d[i];
            s[start - 1] = '$';
            i = start - 1;
        }
    }
    return start == n;
}
bool solve() {
    string s;
    cin >> s;
    s = "?" + s;
    cout << (manachar(s) ? "Yes" : "No") << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    init();
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

H

题解

知识点：位运算，前缀和。

考虑快速求出操作区间对初始数字 \(x\) 的影响。

这里一个重要的转换是，操作A对 \(x\) 取反等价于 \(-x-1\) ，因此考虑将答案表达为 \(kx+b,k\in\{-1,1\}\) 的形式。

显然，只有操作A能改变 \(k\) ，因此 \(k\) 即为操作区间 \([l,r]\) 中操作A的个数。

因为操作A能改变 \(b\) 的正负，所以任何操作对 \(b\) 的影响，与之后经历操作A的次数有关，我们分类讨论：

1. 对于操作B，若其后有偶数个操作A，那么贡献为 \(1\) ，否则为 \(-1\) 。
2. 对于操作A，若其后有偶数个操作A，那么贡献为 \(-1\) ，否则为 \(1\) 。

我们发现这个过程是能用前缀和维护的。具体来说，我们分别记录 \(k,b\) 在前缀 \([1,i](i = 1,\cdots,n)\) 操作下的结果。

现在我们询问 \([l,r]\) 区间的结果。显然， \(k_{l;r} = k_{l-1} \cdot k_r\) 。对于 \(b\) 我们有 \(b_{l;r} = b_{r} - k_{l;r} \cdot b_{l-1}\) ，因为对于 \([1,r]\) 的操作中，我们需要消除 \([1,l-1]\) 对 \(b\) 的影响，因为这一段操作被之后 \([l,r]\) 的操作A影响过了，因此我们需要对 \(b_{l-1}\) 修正，即 \(b_{l-1} \cdot k_{l;r}\) 。

最终结果为 \(k_{l} \cdot k_{r} \cdot (x - b_{l-1}) + b_r\) 。

当然这个过程还能通过初等矩阵维护。

时间复杂度 \(O(n+q)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int k[200007];
int b[200007];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, q;
    cin >> n >> q;
    string s;
    cin >> s;
    s = "?" + s;
    k[0] = 1;
    for (int i = 1;i <= n;i++) {
        if (s[i] == 'A') {
            k[i] = -k[i - 1];
            b[i] = -b[i - 1] - 1;
        }
        else {
            k[i] = k[i - 1];
            b[i] = b[i - 1] + 1;
        }
    }

    ll ans = 0;
    while (q--) {
        int l, r;
        cin >> l >> r;
        l = (ans ^ l) % n + 1;
        r = (ans ^ r) % n + 1;
        if (l > r) swap(l, r);

        string t;
        cin >> t;
        ll x = 0, P = 1LL << t.size();
        for (auto ch : t) (x <<= 1) |= ch == '1';

        x -= b[l - 1];
        x *= k[l - 1];
        x *= k[r];
        x += b[r];
        ((x %= P) += P) %= P;

        ans = x;
        for (int i = t.size() - 1;i >= 0;i--) cout << ((x >> i) & 1);
        cout << '\n';
    }
    return 0;
}

I

题解

知识点：构造。

构造形如下方，注意字符顺序要严格：

xoxoxo
oxoxox
oxoxox
xoxoxo
......

当且仅当 \(n = 4k-1,k \in \N^+\) 且 \(m\) 是奇数时，这种构造需要将 ox 反转，变为：

oxoxo
xoxox
xoxox

这是为了保证数量的严格。

可以证明 \(n,m\) 有一个为偶数时，这种构造一定是合法的。

当满足 \(n = 4k-1,k \in \N^+\) 且 \(m\) 是奇数时，发现原来的构造会导致 o 比 x 多一个。

时间复杂度 \(O(nm)\)

空间复杂度 \(O(nm)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    int n, m;
    cin >> n >> m;
    bool f = (n / 2 & 1) && (n & 1) && (m & 1);
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            if (j & 1) cout << ((i / 2 & 1) ^ f ? "o" : "x");
            else cout << ((i / 2 & 1) ^ f ? "x" : "o");
        }
        cout << '\n';
    }
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

K

题解

知识点：线性dp。

若没有向右移动，这道dp只需要多记录上一个位置有没有盖子即可。

但这道题可以向右移动，因此再多记录一维上一个位置若原来有盖子，有没有向右移动。

还有其他的状态方案，具体可以看代码。

我用的是方法一，上面讲的是方法二的，我觉得方法二更通用。

时间复杂度 \(O(n)\)

空间复杂度 \(O(n)\)

代码

方法一

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int a[1000007];
bool b[1000007];
ll f[1000007][4]; // 第i个位置，没有/前面/自己/后面拿盖子
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    for (int i = 1;i <= n;i++) cin >> b[i];

    for (int i = 1;i <= n;i++) {
        f[i][0] = max({ f[i - 1][0],f[i - 1][1],f[i - 1][2],f[i - 1][3] });
        if (b[i - 1]) {
            f[i][1] = max({ f[i - 1][1], f[i - 2][0],f[i - 2][1],f[i - 2][2] }) + a[i];
        }
        if (b[i]) {
            f[i][2] = max({ f[i - 1][0],f[i - 1][1],f[i - 1][2] }) + a[i];
        }
        if (b[i + 1]) {
            f[i][3] = max({ f[i - 1][0],f[i - 1][1],f[i - 1][2],f[i - 1][3] }) + a[i];
        }
    }
    cout << max({ f[n][0],f[n][1],f[n][2] }) << '\n';
    return 0;
}

方法二

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int inf = 1e9;
int a[1000007];
bool b[1000007];
ll f[1000007][2][2]; // 前i个位置，有无盖子，有无右移（btw：只有左移操作那只需要有无盖子）
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    for (int i = 1;i <= n;i++) cin >> b[i];

    f[0][0][0] = 0;
    f[0][0][1] = -inf;
    f[0][1][0] = -inf;
    f[0][1][1] = -inf;
    for (int i = 1;i <= n;i++) {
        if (b[i]) {
            f[i][0][0] = f[i - 1][0][0] + a[i - 1];
            f[i][0][1] = max(f[i - 1][0][0], f[i - 1][1][0]);
            f[i][1][0] = max(f[i - 1][0][0], f[i - 1][1][0]) + a[i];
            f[i][1][1] = max(f[i - 1][0][1], f[i - 1][1][1]) + a[i];
        }
        else {
            f[i][0][0] = max({ f[i - 1][0][0],f[i - 1][1][0] });
            f[i][0][1] = -inf;
            f[i][1][0] = max({ f[i - 1][0][1],f[i - 1][1][1] }) + a[i];
            f[i][1][1] = -inf;
        }
    }
    cout << max({ f[n][0][0],f[n][1][0] }) << '\n';
    return 0;
}

方法三

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int a[1000007];
bool b[1000007];
ll f[1000007][3]; // 第i个位置，有给前面，没有不管/有自己用，没有从前面拿/一定有且给后面
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    for (int i = 1;i <= n;i++) cin >> b[i];

    for (int i = 1;i <= n;i++) {
        if (b[i]) {
            f[i][0] = f[i - 1][0] + a[i - 1];
            f[i][1] = max(f[i - 1][0], f[i - 1][1]) + a[i];
            f[i][2] = max({ f[i - 1][0], f[i - 1][1], f[i - 1][2] }) + a[i + 1];
        }
        else {
            f[i][0] = max(f[i - 1][0], f[i - 1][1]);
            f[i][1] = f[i - 1][2];
        }
    }
    cout << max(f[n][0], f[n][1]) << '\n';
    return 0;
}