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;
}