Codeforces Hello 2024 A~F1

AC-Panda

于 2024-01-11 10:07:48 发布

阅读量1k

点赞数 20

分类专栏： codeforces题解文章标签：算法 c++ codeforces OI icpc

本文链接：https://blog.csdn.net/Code_Shark/article/details/135520078

版权

codeforces题解专栏收录该内容

101 篇文章 7 订阅

订阅专栏

A.Wallet Exchange(思维)

题意：

Alice和Bob各自拥有 $a, b$ 枚硬币，他们决定以Alice为先手开始比赛，比赛中每人在每轮需按顺序执行操作1和操作2：

操作1：交换两人手上拥有的硬币数量，或什么都不做
操作2：丢掉手上的一枚硬币（如果此时手上没有硬币则输掉比赛）

问：假设两人都极为聪明，那么谁会赢下这场比赛？

分析：

实际上对于操作1，比赛两方均会选择硬币较多的一堆，因此，可以将硬币视为只有一堆，共 $n$ 枚，其中 $n = a + b$ ，Alice和Bob按顺序从这堆硬币中丢弃硬币。

此时若硬币数量 $n$ 为偶数时，必然是后手丢掉最后一枚硬币，即Bob获胜，反之，先手Alice获胜。

代码：

#include<bits/stdc++.h>

using namespace std;

void solve() {
    int a, b;
    cin >> a >> b;
    if ((a + b) % 2 == 0) {
        cout << "Bob" << endl;
    } else {
        cout << "Alice" << endl;
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.Plus-Minus Split(贪心)

题意：

给出一个包含 $n$ 个字符的字符串 $s$ ，字符串中仅包含字符-或+，其中-代表 $- 1$ ，+代表 $1$ 。

你可以进行以下步骤来计算罚分：

将字符串 $s$ 分为若干子子串 $b_1, b_2, ..., b_k$ 。
对于字符串 $c$ 产生的罚分为 $|c_1 + c_2 + ... + c_m| \cdot m$
产生的总罚分为 $p(s) = p(b_1) + p(b_2) + ... + p(b_k)$ 。

问：最小可能的罚分是多少？

分析：

为了最小化罚分，需要尽可能多的将正负号进行匹配，即若干子拆出的子串中正负号出现次数相同，但字符串中正负号数量并不一定相同，那么剩下的正号或负号依然会产生罚分，此时为了最小化罚分，必然选择这些正负号自身为一个子串，假设存在 $a$ 个 $+$ 号， $b$ 个 $-$ 号，那么最小罚分为 $\times min(a, b)$ 。

代码：

#include<bits/stdc++.h>

using namespace std;

void solve() {
    int n;
    string s;
    cin >> n >> s;
    int add = 0, sub = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '-') sub++;
        else add++;
    }
    cout << n - 2 * min(add, sub) << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Grouping Increases(贪心)

题意：

给出一个包含 $n$ 个数字的数组 $a$ ，你需要按以下要求计算罚分：

将数组 $a$ 分为两个子序列 $s, t$ （可能有个子序列为空）。
对于一个包含 $m$ 个数字的数组 $b$ ，产生的罚分 $\sum\limits_{i = 1}^{m - 1}f(i)$ ，其中 $f (i)$ 为满足 $b_i < b_{i + 1}$ 则为 $1$ ，不满足则为 $0$ 。
总罚分为 $p (s) + p (t)$

问：最小可能的罚分是多少？

分析：

由于对于子序列的罚分计算只考虑相邻的两个数字，那么只需要维护两个子序列最后的元素。

令 $b$ 为两个子序列中最后元素中的较小值， $c$ 为较大值，并按以下要求检查 $a_i$ 该加入哪个子序列：

如果 $a_i \le b$ ，那么 $a_i$ 将会加入最后元素较小的序列，即 $b = a_i$ 。
否则，再检查是否满足 $a_i \le c$ ，如果满足，则将 $a_i$ 加入最后元素较大的序列，即 $c = a_i$ 。
如果以上两种情况均不满足，那么此时必然产生一点罚分，并且为了使之后的罚分尽可能小，当前数字 $a_i$ 必然会加入尾部元素较小的序列，即 $b = a_i$

代码：

#include<bits/stdc++.h>

using namespace std;

int a[200005];

void solve() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    int b = 1e9, c = 1e9, ans = 0;
    for (int i = 0; i < n; i++) {
        if (b > c) {
            swap(b, c);
        }
        if (a[i] <= b) {
            b = a[i];
        } else if (a[i] <= c) {
            c = a[i];
        } else {
            b = a[i];
            ans++;
        }
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.01 Tree（思维）

题意：

有一棵包含 $n$ 个叶节点的树，保证每个非叶节点均包含两个子节点，同时，对于所有非叶节点，走向子节点的边中均包含权值，且其中一条权值为 $0$ ，另一条权值为 $1$ 。

你忘记了原本的树是什么样子的，只记得根节点到这 $n$ 个叶节点的权值之和，按dfs序给出这些叶节点的权值，问是否存在满足这些节点权值的树。

分析

由于每个非叶节点与子节点之间的边权分别为 $0, 1$ ，那么属于同一个父节点的两个节点的权值之差必然为 $1$ ，且权值较小的一个与父节点的权值一致，由此可知如果给出的叶节点合法，那么必然存在且仅存在一个叶节点的权值为 $0$ 。

同时，由于叶节点以dfs序给出，那么属于同一个父节点的两个叶节点在dfs序中也必然相邻，为了便于处理，使用静态双向链表将 $\sim n$ 这些节点按顺序连在一起。

由于非叶节点的权值与两个子节点的权值较小者相同，那么如果同时删除它的两个子节点（这两个子节点均为叶节点），该节点也会变成叶节点，为了便于处理，可以在操作时仅删除权值较大的节点，将另一个子节点视为删除后新产生的叶节点。

然后考虑从叶节点开始向上删除节点，按以下步骤执行：

删除的节点，它在dfs序中相邻的两个节点中，必然存在一个节点的权值比它小 $1$ （树上仅会存在一个权值为 $0$ 的节点，其他节点权值均大于 $0$ ），此时可以将节点视为待删除节点，放入大根堆中等待删除
当从大根堆取出节点后，就需要对该节点进行删除操作了，由于该节点存储在静态双向链表上，那么需要同时修改前后节点的指针。
然后检查当前节点删除后，左右两边相邻的节点能否进入待删除状态，如果能，就将节点也加入堆中。

删除完成后，如果仅剩下一个权值为 $0$ 的节点未被删除，那么就表示存在满足要求的树，否则，找不到满足要求的树。

代码：

#include<bits/stdc++.h>

using namespace std;

int n, a[200005], pre[200005], nxt[200005], vis[200005];
struct Node{
    int id, val;
    bool operator < (const Node &o) const {
        if (val != o.val) return val < o.val;
        return id > o.id;
    }
};

priority_queue<Node> Q;

int check(int x) {
    return x >= 1 && x <= n && (a[pre[x]] == a[x] - 1 || a[nxt[x]] == a[x] - 1);
}

void solve() {
    cin >> n;
    int zero = 0;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        pre[i] = i - 1;
        nxt[i] = i + 1;
        vis[i] = 0;
        if (a[i] == 0) zero++;
    }
    /*a[0]和a[n + 1]取-1时可能会导致a[1]=0或a[n]=0的情况入队，因此取不影响答案的-2*/
    a[0] = a[n + 1] = -2;
    if (zero == 0) {
        cout << "NO" << endl;
        return;
    }
    for (int i = 1; i <= n; i++) {
    /*找开始时就能进入待删除状态的节点*/
        if (check(i)) {
            vis[i] = 1;
            Q.push(Node{i, a[i]});
        }
    }
    while (!Q.empty()) {
        Node u = Q.top();
        Q.pop();
        /*相当于双向链表中删点，需将前后连起来*/
        nxt[pre[u.id]] = nxt[u.id];
        pre[nxt[u.id]] = pre[u.id];
        /*检查左右的节点能否进入待删除状态*/
        if (vis[nxt[u.id]] == 0 && check(nxt[u.id])) {
            vis[nxt[u.id]] = 1;
            Q.push(Node{nxt[u.id], a[nxt[u.id]]});
        }
        if (vis[pre[u.id]] == 0 && check(pre[u.id])) {
            vis[pre[u.id]] = 1;
            Q.push(Node{pre[u.id], a[pre[u.id]]});
        }
    }
    /*由于权值为0的节点必然不会被删除，那么只需要判断剩余的节点数量.
    如果为1，那么剩下的节点权值必然为0*/
    int cnt = 0;
    for (int i = 1; i <= n; i++) {
        if (vis[i] == 0) {
            cnt++;
        }
    }
    if (cnt == 1) cout << "YES" << endl;
    else cout << "NO" << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

E.Counting Prefixes(组合数学，思维)

题意

有一个仅含有 $- 1$ 和 $1$ 的数组 $a$ ，以及它对应的的前缀和数组排序以后的结果 $p$ ，问你原本的 $a$ 数组有多少种可能性。答案需要对 $998244353$ 取模。

思路

有两种明显无解的情况是比较好想到的：

如果 $p$ 数组仅有一个不为 $- 1, 1$ 的值，那么一定无解。
如果 $p$ 数组中最小的元素都比 $1$ 大，或者最大的元素都比 $- 1$ 小，那也是不可能的。

对于其他情况，我们先 $p$ 将它恢复成未排序的状态，称这个未排序的前缀和数组为 $p re$ 。假设某一个元素对应位置的前缀和为 $s$ ，我们可以写作 $p re [i] = s$ ， $a$ 数组在它之后的元素要么是 $1$ ，要么是 $- 1$ ，即： $p re [i] = s + 1$ 或 $p re [i] = s - 1$ 。此时我们会发现：题目中的第 $3$ 个样例显然是无解的，因为 $- 1$ 与 $1, 2$ 都不可能相邻出现。

下面，我们开始对这个问题的常规情况进行分析。我们假设 $p_n\ge0$ ，若它小于 $0$ ，我们可以考虑这个 $p$ 数组元素全取相反数的结果，结论仍然是成立的（相当于所有的 $1$ 变成 $- 1$ ， $- 1$ 变成 $1$ ）。

这样以来我们可以想到：

先去构建一个先全为 $1$ 的序列，使得1的个数为 $p_n$ 个，此时前缀和数组中含有从 $1$ 到 $p_n$ 这些元素，每个元素出现一次。例如，若 $p_n=3$ ，则此时我们先构建1 1 1。
如果还需要其他的 $p_n$ ，可以视为任意一个前缀和刚好为 $p_n$ 的位置插入一组(-1,1)，此时会多出一个，例如1 1 1 -1 1，会有 $2$ 个位置对应的前缀和都为 $3$ 。下次插入时，我们可以把当前序列看做1 1 1 _ (-1 1) _ ，两个下划线对应的位置都可以进行插入、插入 $k$ 次以后，前缀和数组中有 $k + 1$ 个 $p_n$ ，若 $p_n-1>0$ ，则 $p_n-1$ 也有 $k + 1$ 个（最开始的全 $1$ 序列中自带一个），否则有 $k$ 个。
$p_n$ 插入完毕以后，我们可以看一下 $p_n-1$ 还差多少个。假如说，我们现在已经有 $x$ 个 $p_n-1$ 了，那说明目前我们的序列中有 $x$ 个 $- 1$ ，但我们需要的 $p_n-1$ 可能有 $y$ 个。其中若 $y < x$ ，则说明无解；否则我们可以在 $x$ 个 $- 1$ 的后面，再次加入(-1,1)。但要注意，每一次加入都会使得 $- 1$ 多一个，因此我们可以这样推导插入的方案数：

按照这样的顺序，我们依次去插入 $p_n-1,p_n-2$ ，一直控制到 $p_1$ 即可。这个过程中可以补一个起始（或终止位置）的 $0$ ，便于计算。

代码

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 5050;
ll c[N][N];
int p[N], x[N * 2], cnt[N * 2];
const ll mod = 998244353;

void get_c_matrix() {//返回值为int类型时会导致超时
    c[0][0] = 1;
    for (int i = 1; i <= 5000; ++i) {
        c[i][0] = 1;
        for (int j = 1; j <= i; ++j) {
            c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
        }
    }
}

ll get_c_value(int xx, int yy) {
    if (xx < 0 || yy < 0 || yy > xx)return 0;
    return c[xx][yy];
}

int main() {
    get_c_matrix();
    int T, n, flag;
    ll ans, res;
    cin >> T;
    while (T--) {
        cin >> n;
        //进行必要的清空
        memset(cnt, 0, sizeof(cnt));
        cnt[N] = 1; //在起始处补一个0
        ans = 0;
        flag = 1; //用于标记是否有类似于1 3这样跳着的、不相邻的情况
        for (int i = 1; i <= n; i++) {
            //统计每个元素出现的个数
            cin >> p[i];
            cnt[p[i] + N]++;
        }
        if (n == 1) {
            //如果只有一个元素，那么必然是1或者-1
            if (abs(p[1]) == 1) cout << 1 << endl;
            else cout << 0 << endl;
            continue;
        }
        if (p[1] > 1 || p[n] < -1) {
            //类似于 2 2 3 或者-3 -2 -2也是绝对不可能的
            cout << 0 << endl;
            continue;
        }
        int l = min(p[1] + N, N), r = max(p[n] + N, N), i;  //不要忘记你补了个0
        for (i = l; i <= r; i++) {
            //如果有跳着的、不连续的，比如2 2 4，也是不可能的
            if (!cnt[i]) {
                flag = 0;
                cout << 0 << endl;
                break;
            }
        }
        if (!flag)continue;
        for (i = r; i >= l; i--) {
            x[r - 1] = cnt[r];
            //注意全1序列已经会产生部分前缀和
            if (r > 0 + N)x[r - 1]++;
            if (r == i)x[r - 1]--;

            for (int j = r - 1; j >= l; j--) {
                //进行模拟
                x[j - 1] = cnt[j] - x[j];
                if (j - 1 >= i)x[j - 1]++;
                if (j - 1 >= 0 + N)x[j - 1]++;
            }
            if (x[l - 1] == 0) {
                res = 1;
                for (int j = r - 1; j >= l; j--) {
                    res = (res * get_c_value(cnt[j] - 1, cnt[j] - x[j])) % mod;
                }
                ans = (ans + res) % mod;
            }

        }
        cout << ans << endl;
    }
    return 0;
}

F1.Wine Factory (Easy Version)(后缀和，线段树)

题意：

有 $n$ 座水塔，其中第 $i$ 座包含 $a_i$ 升的水，且拥有一个能消除 $b_i$ 升水的法师，同时相邻两座水塔之间拥有一道阀门，第 $i$ 座高塔与第 $i + 1$ 座水塔之间的阀门允许通过 $c_i$ 升水。

对于第 $i (i = 1, 2, ..., n)$ 座塔，将会进行以下操作：

法师将水塔 $i$ 中最多 $b_i$ 升的水消除，并将消除的水转化为等量的红酒。
如果 $\ne n$ ，那么至多 $c_i$ 升水可以由阀门流到第 $i + 1$ 座水塔。

题目将给出 $q$ 次更新，每次给出四个数字 $p, x, y, z$ ，即将 $a_p = x, b_p = y, c_p = z$ ，并要求对于每次更新，输出最多能获得多少升红酒。

特殊条件：对于所有数据，有 $c_i = 10^{18}, z = 10^{18}$

分析：

对于特殊条件， $c_i, z$ 均为 $10^{18}$ ，由于 $\sum\limits_{i = 1}^{n}max(a_i) = 5 \times 10^{14} < 10^{18}$ ，那么如果水塔中的水没有被全部消除，则剩下的水均能流到下一座高塔，即可以不考虑 $c_i$ 这个限制因素。

先考虑每座水塔自身无法消除的水量： $v_i = a_i - b_i$ ，当 $v_i > 0$ 时，未被消除的水量必然需要由后面的法师来进行消除（如果可以的话），因此对于水塔 $k$ 而言，无法消除的水量实际为 $\sum\limits_{i = k}^{n}v_i$ 。那么对于所有水塔来说，无法消除的水量即为 $ma x (f (1), f (2), ..., f (n))$ 。

使用后缀和建一棵线段树，维护区间上的最大值，并使用变量 $s u m$ 记录水塔的总水量。

每次更新水塔 $p$ 时，由于线段树维护的是后缀和，那么对于所有 $\sim n$ 上的点，均不会收到影响，只需要对区间 $\sim p$ 进行更新，先减去原本的 $v_p$ ，再加上当前更新后的新 $v_p = x - y$ 。

那么最后的答案就是 $s u m - ma x (f (1), f (2), ..., f (n))$ ，其中 $ma x (f (1), f (2), ..., f (n))$ 为线段树树根中记录的信息。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 5e5 + 5e2;

LL n, q, a[N], b[N];
LL sum, T[N << 2], lazy[N << 2], c[N], v[N], sv[N];

void pushup(int x) {
    T[x] = max(T[x << 1], T[x << 1 | 1]);
}

void build(int l, int r, int x) {
    if (l == r) {
        T[x] = sv[l];
        return;
    }
    int mid = l + r >> 1;
    build(l, mid, x << 1);
    build(mid + 1, r, x << 1 | 1);
    pushup(x);
}

void pushdown(int x) {
    if (lazy[x]) {
        lazy[x << 1] += lazy[x];
        lazy[x << 1 | 1] += lazy[x];
        T[x << 1] += lazy[x];
        T[x << 1 | 1] += lazy[x];
        lazy[x] = 0;
    }
}

void update(int l, int r, int x, int ul, int ur, LL val) {
    if (l >= ul && r <= ur) {
        T[x] += val;
        lazy[x] += val;
        return;
    }
    pushdown(x);
    int mid = l + r >> 1;
    if (ul <= mid) update(l, mid, x << 1, ul, ur, val);
    if (ur > mid) update(mid + 1, r, x << 1 | 1, ul, ur, val);
    pushup(x);
}

void solve() {
    cin >> n >> q;
    sum = 0;
    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++)  cin >> c[i];
    for (int i = n; i >= 1; i--) {
        v[i] = a[i] - b[i];
        sv[i] = v[i] + sv[i + 1];
        sum += a[i];
    }
    build(1, n, 1);
    while (q--) {
        int p, x, y;
        LL z;
        cin >> p >> x >> y >> z;
        sum -= a[p];//减去原本的水量
        /*减掉原本的vp*/
        update(1, n, 1, 1, p, -v[p]);
        a[p] = x;
        b[p] = y;
        v[p] = x - y;//更新vp
        sum += a[p];//加上现在的水量
        /*加上现在的vp*/
        update(1, n, 1, 1, p, v[p]);
        /*出现负数说明所有水均能消除，此时需要减去的值为0，需取max*/
        cout << sum - max(0ll, T[1]) << endl;
    }
}

int main() {
    ios::sync_with_stdio(false);
    int Case = 1;
    while (Case--) {
        solve();
    }
    return 0;
}