Codeforces Global Round 22 A-E

比赛链接

A

题解

知识点：贪心。

显然交错释放最好。

若两类数量不一样，那么较少的一组的一定都可以双倍，剩下的另一组就放进一个优先队列，从大到小和少的一组匹配可以双倍，剩下的直接加。

如果两类数量一样，那一定有一个不能被双倍。用上面的方法后，减去一个两组的最小值即可。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[100007], b[100007];

bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    for (int i = 1;i <= n;i++) cin >> b[i];

    int cnt1 = 0;
    for (int i = 1;i <= n;i++) if (a[i]) cnt1++;

    ll sum = 0;
    bool typ = cnt1 <= n - cnt1;
    int cnt = min(cnt1, n - cnt1);
    priority_queue<int> pq;
    for (int i = 1;i <= n;i++) {
        if (a[i] == typ) sum += 2 * b[i];
        else pq.push(b[i]);
    }
    for (int i = 1;i <= cnt;i++) {
        sum += pq.top() * 2;
        pq.pop();
    }
    while (pq.size()) {
        sum += pq.top();
        pq.pop();
    }

    if (n - cnt == cnt) sum -= *min_element(b + 1, b + n + 1);
    cout << sum << '\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;
}

B

题解

知识点：枚举，前缀和，贪心。

注意，给出的 \(k\) 个前缀和，能确定后 \(k-1\) 个数，其他数是可以自由分配的，那么现在只需要让倒数第 \(k\) 个数最小即可。

显然 \(a[n-k+1]\) 最小值为 \(\Bigg \lceil \dfrac{s[n-k+1]}{n-k+1} \Bigg \rceil\) ，即把 \(s[n-k+1]\) 的值平均分配给 \(n-k+1\) 个位置，就能保证 \(a[n-k+1]\) 最小。

接下来，通过这个最小的 \(a[n-k+1]\) 检验后面 \(k-1\) 项是否合法即可。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int s[100007];
bool solve() {
    int n, k;
    cin >> n >> k;
    for (int i = 1;i <= k;i++) cin >> s[i];
    int cur;
    if (s[1] <= 0) cur = s[1] / (n - k + 1);
    else cur = (s[1] + n - k) / (n - k + 1);
    for (int i = 2;i <= k;i++) {
        if (s[i] - s[i - 1] < cur) return false;
        cur = s[i] - s[i - 1];
    }
    cout << "YES" << '\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 << "NO" << '\n';
    }
    return 0;
}

C

题解

方法一

知识点：博弈论。

考虑奇数数量 \(cnt\) 模 \(4\) 的四种情况。

1. \(cnt \equiv 0 \pmod 4\) ，此时A总是能拿到偶数个奇数，必赢。
2. \(cnt \equiv 1 \pmod 4\) ，若 \(n\) 为偶数，那A可以不拿多出来的那个奇数，从而必赢；否则，一定会拿多一个奇数，必输。
3. \(cnt \equiv 2 \pmod 4\) ，此时A总是能拿到奇数个奇数，必输。
4. \(cnt \equiv 3 \pmod 4\) ，此时A总是能拿到偶数个奇数，必赢。

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

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

方法二

知识点：博弈论，线性dp，记忆化搜索。

设 \(dp[turn][st][cnt0][cnt1]\) 当前为A/B(0/1)的回合,A手里的奇偶性,偶数剩 \(cnt0\) ,奇数剩 \(cnt1\) 时当前回合人的输赢。终止局面：A的回合且A的和为偶数时为A赢，B的回合且A的和为奇数时为B赢，其他情况均为当前回合的人输。

这样每个回合，只要下一回合奇数偶数中有一种情况是下一个回合的人输，那自己一定是赢的，每次或转移即可。

还有种设法是只看 \(A\) 的输赢，但写起来不方便，因为上面这种写法可以同一或转移，这种写法A是或转移，B是且转移。因为B只要有一种能让A输就会走，应该是且，那就需要多一个判断回合。

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

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

代码

方法一

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    int n;
    cin >> n;
    int cnt = 0;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        if (x & 1) cnt++;
    }
    if (cnt % 4 == 0 || cnt % 4 == 3) cout << "Alice" << '\n';
    else if (cnt % 4 == 1) cout << (n & 1 ? "Bob" : "Alice") << '\n';
    else if (cnt % 4 == 2) cout << "Bob" << '\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;
}

方法二

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int dp[2][2][107][107];//A/B(0/1)的回合,A手里的奇偶性,偶数剩多少,奇数剩多少

bool dfs(bool turn, bool st, int cnt0, int cnt1) {
    if (~dp[turn][st][cnt0][cnt1]) return dp[turn][st][cnt0][cnt1];
    if (!cnt0 && !cnt1) return !st ^ turn;
    bool ans = 0;
    if (cnt0) ans |= !dfs(!turn, st, cnt0 - 1, cnt1);
    if (cnt1) ans |= !dfs(!turn, st ^ !turn, cnt0, cnt1 - 1);
    return dp[turn][st][cnt0][cnt1] = ans;
}

bool solve() {
    memset(dp, -1, sizeof(dp));
    int n;
    cin >> n;
    int cnt0 = 0, cnt1 = 0;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        if (x & 1) cnt1++;
        else cnt0++;
    }
    cout << (dfs(0, 0, cnt0, cnt1) ? "Alice" : "Bob") << '\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;
}

D

题解

知识点：构造。

首先解决 \(k\) 。注意到，\(i<b[i]\) 的情况只出现在 \(a[i] \leq k,a[j]>k(1\leq j<i)\) 的情况。而 \(a\) 是个排列，即每个数字出现且仅出现一次，因此 \(i<b[i]\) 的个数，说明 \(\leq k\) 的数有多少个，即 \(k\) 的大小。

随后处理排列顺序。观察题意可以得到， \((i,b[i]) = (a[x],a[y]),(1\leq y<x)\) 可以得到 \(b[i]\) 一定是 \(i\) 的前驱。

若多个数字的前驱相同，那么这些同前驱的数字只有其中一个可以作为其他数字的前驱，且在原排列 \(a\) 中一定出现在同前驱数字的最后，否则会互相干扰，因此不存在这样的 \(b\) 。

如果 \(b[i] = 0 \text{ 或 } n+1\) 时，代表 \(i\) 前面没有别的数字，不难发现 \(0\) 和 \(n+1\) 只会有且只有一种出现在 \(b\) 中。

因此，可以先用一个桶把 \(b[i]\) 相同的 \(i\) 存在一起，表示这些 \(i\) 的前驱相同。然后从 \(b[i] = 0 \text{ 或 } n+1\) 出发，先找到一个桶里有后继的数，把这个数放在桶的最后，再从头依次输出即可，接下来到最后一个数字，即有后继的数字，桶中重复上述操作即可。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int b[100007];
vector<int> v[100007];

bool solve() {
    int n;
    cin >> n;
    v[0].clear();
    v[n + 1].clear();
    for (int i = 1;i <= n;i++) cin >> b[i], v[i].clear();
    int k = 0;
    for (int i = 1;i <= n;i++) if (i < b[i]) k++;
    for (int i = 1;i <= n;i++) v[b[i]].push_back(i);
    cout << k << '\n';

    int cur = 0;
    if (v[n + 1].size()) cur = n + 1;

    int cnt = 0;
    while (cnt < n) {
        for (auto &i : v[cur]) {
            if (v[i].size()) {
                swap(i, v[cur].back());
                break;
            }
        }
        for (auto i : v[cur]) cout << i << ' ';
        cnt += v[cur].size();
        cur = v[cur].back();
    }
    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;
}

E

题解

知识点：排列组合，双指针。

可以放置隔板划分连续区间，考虑区间 \((i,j)\) 的三种情况：

1. 全是 \(0\) ，形如 00000000，那么任意放置隔板都能产生回文，所以生成 \(2^{j-i}\) 种方案。
2. 两侧都有 \(0\) 但中间两侧有数字挡着，形如 000数字..任意..数字0000 ，那么考虑处理出两侧隔板方案。设左右侧分别有 \(x,y\) 个 \(0\) ，且两侧需要放相同数量的隔板，因此方案数为 \(C_x^k \cdot C_y^k,k \in [0,\min{(x,y)}]\) 。
3. 两侧至少有一侧没有 \(0\) ，形如 00数字..任意..数字 ，这时候没有 \(0\) 可以直接处理，那就要处理出从两侧出发和相同的一段。假设和相同时，左段右端点是 \(l\) ，右段左端点是 \(r\) ，若 \(l\geq r\) ，说明两端重合了不能形成回文；否则，可以把这一段整体等效 \(0\) ，参与下一次区间的处理。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

const int mod = 998244353;
int fact[100007], invf[100007];
int a[100007];

int qpow(int a, int k) {
    int ans = 1;
    while (k) {
        if (k & 1) ans = 1LL * ans * a % mod;
        k >>= 1;
        a = 1LL * a * a % mod;
    }
    return ans;
}

void init(int n) {
    fact[0] = 1;
    for (int i = 1;i <= n;i++) fact[i] = 1LL * fact[i - 1] * i % mod;
    invf[n] = qpow(fact[n], mod - 2);
    for (int i = n;i >= 1;i--) invf[i - 1] = 1LL * invf[i] * i % mod;
}

int C(int n, int m) {
    return 1LL * fact[n] * invf[m] % mod * invf[n - m] % mod;
}

int f(int i, int j) {
    int l = i, r = j;
    while (l <= j && !a[l]) l++;
    while (r >= i && !a[r]) r--;
    if (l == j + 1) return qpow(2, j - i);
    if (l != i && r != j) {
        int ans = 0, x = l - i, y = j - r;
        for (int i = 0;i <= min(x, y);i++)
            ans = (ans + 1LL * C(x, i) * C(y, i)) % mod;
        return 1LL * ans * f(l, r) % mod;
    }

    ll ls = a[l], rs = a[r];
    while (l < r && ls != rs) {
        if (ls < rs) ls += a[++l];
        else rs += a[--r];
    }
    if (l >= r) return 1;
    a[l] = a[r] = 0;
    return f(l, r);
}

bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    cout << f(1, n) << '\n';
    return true;
}

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