Educational Codeforces Round 168 (Div. 2) A~E

AC-Panda

于 2024-08-13 15:43:39 发布

阅读量167

点赞数 3

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

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

版权

codeforces题解专栏收录该内容

96 篇文章 7 订阅

订阅专栏

A.Strong Password（贪心）

题意：

给定一个字符串 $a$ ，你需要在中间（可以是开头或结尾）插入一个字符，使得满足 $a_i≠a_{i+1}$ 的 $i$ 最多。

分析：

我们很容易贪心地想到在连续两个相同的字符中间插入一个字符贡献最大。否则在字符串结尾插入一个不同于结尾的字符。再特判一下一个字符和没有连续两个相同字符的情况即可。

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        string s;
        cin >> s;
        cout << s[0];
        int flag = 0;
        for (int i = 1; s[i]; i++) {
            if (s[i] == s[i - 1] && !flag) {
                flag = 1;
                cout << char((s[i] - 'a' + 1) % 26 + 'a');
            }
            cout << s[i];
        }
        if (!flag) {
            cout << char((s[s.size() - 1] - 'a' + 1) % 26 + 'a');
        }
        cout << endl;
    }
    return 0;
}

B.Make Three Regions （思维）

题意：

有一个 $\times n$ 的网格，上面有些格子是障碍物，有些是空地。保证空地四连通。询问有多少个空地满足把它变成障碍物后，剩余的空地被分为三个四连通块。

分析：

只有这两种情况是符合题意的，我们进行特判即可。
x.x ...
... x.x

代码：

#include <bits/stdc++.h>

using namespace std;
int n;
string s[2];

int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        cin >> s[0];
        cin >> s[1];
        int ans = 0;
        for (int i = 1; i < n - 1; i++)
            if (s[0][i - 1] == 'x' && s[0][i + 1] == 'x' && s[0][i] == '.' && s[1][i + 1] == '.' && s[1][i - 1] == '.')
                ans++;
        for (int i = 1; i < n - 1; i++)
            if (s[1][i - 1] == 'x' && s[1][i + 1] == 'x' && s[1][i] == '.' && s[0][i + 1] == '.' && s[0][i - 1] == '.')
                ans++;
        cout << ans << endl;
    }
    return 0;
}

C.Even Positions (贪心)

题意：

一个合法括号序列的权值定义为匹配括号的距离和。给出一个长度为 $n$ 的合法括号序列，但所有的奇数位置的括号都遗失了。你需要找出所有可能的原序列中，权值最小的为多少。

分析：

我们考虑到如果答案要求最小，那么就希望右括号能尽早配对。我们用栈维护前面所有的左括号，如果栈里还有左括号，那能配对就直接配对。剩下的部分一定是有解的。
在这样的操作下，每一步填完之后要么剩下两个左括号，要么什么也不剩下。因为最后一个字符一定是右括号，所以无论何时都是一定有解的。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        string s;
        cin >> n >> s;
        vector<int> tmp;
        LL ans = 0;
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) {
                if (tmp.empty()) {
                    tmp.push_back(i);
                } else {
                    ans += i - tmp.back();
                    tmp.pop_back();
                }
            } else {
                if (s[i] == '(')
                    tmp.push_back(i);
                else {
                    ans += i - tmp.back();
                    tmp.pop_back();
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}

D. Maximize the Root (贪心)

题意：

给定一个有根树，由 $n$ 个顶点组成。树中的顶点编号从 $1$ 到 $n$ ，根是顶点 $1$ 。值 $a_i$ 写在第 $i$ 个顶点处。
你可以执行以下任意次操作（可能是零次）：选择一个顶点 $v$ 至少有一个子节点，将 $a_v$ 增加 $1$ ，并将所有位于 $v$ 子树中的顶点 $u$ （除了 $v$ 本身）的 $a_u$ 减少 $1$ 。但是，在每次操作之后，所有顶点上的值都应为非负值。
你的任务是使用上述操作计算在根上写入的最大可能值。

分析：

我们考虑贪心，先把所有子树能给出的颜色的最小值记录下来，记为 $ma xv a l$ 。如果当前根结点的值比 $ma xv a l$ 大，那么取 $ma xv a l$ （因为根节点无法影响叶子结点），否则的话，根节点和 $m x$ 取平均，通过子树把当前根的贡献增大。

代码：

#include <bits/stdc++.h>

const int maxn = 3e5 + 10;
using namespace std;
int n, a[maxn], tmp[maxn];
vector<int> e[maxn];

void dfs(int u, int fa) {
    int maxval = 0, flag = -1;
    for (auto to: e[u])
        if (to != fa) {
            dfs(to, u);
            if (flag == -1) {
                flag = 1;
                maxval = tmp[to];
            } else {
                maxval = min(tmp[to], maxval);
            }
        }
    if (flag == -1) {
        tmp[u] = a[u];
        return;
    }
    if (u == 1) {
        tmp[u] = a[1] + maxval;
        return;
    }
    if (a[u] >= maxval)
        tmp[u] = maxval;
    else
        tmp[u] = (a[u] + maxval) / 2;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i], e[i].clear();
        for (int i = 2; i <= n; i++) {
            int x;
            cin >> x;
            e[i].push_back(x);
            e[x].push_back(i);
        }
        dfs(1, 0);
        cout << tmp[1] << endl;
    }
    return 0;
}

E. Level Up (数据结构)

题意：

$M o n oc a r p$ 正在玩电脑游戏。他以 $1$ 的等级开始游戏。他即将与 $n$ 个怪物战斗，顺序从 $1$ 到 $n$ 。第 $i$ 个怪物的等级为 $a_i$ 。

对于给定顺序中的每个怪物， $M o n oc a r p$ 的遭遇如下：

如果 $M o n oc a r p$ 的等级严格高于怪物的等级，则怪物逃跑；
否则， $M o n oc a r p$ 与怪物战斗。

每与一个怪物进行 $k$ 次战斗后（逃跑的怪物不计算在内）， $M o n oc a r p$ 的等级就会增加 $1$ 。因此，在与 $k$ 个怪物战斗后，他的等级变为 $2$ ，在与 $2 k$ 个怪物战斗后，他的等级变为 $3$ ，在与 $3 k$ 个怪物战斗后，他的等级变为 $4$ ，依此类推。

现在需要处理以下形式的 $q$ 个查询：

$i x$ ：如果参数 $k$ 等于 $x$ ， $M o n oc a r p$ 会与第 $i$ 个怪物战斗（或者这个怪物会逃跑）吗？

分析：

考虑到修改操作，所以我们想到预处理。对于每个 $i$ ，满足条件的 $k$ 是一个范围，即大于等于一个阈值 $b_i$ 。那么我们需要做的，就是快速求出每个 $i$ 的阈值。
我们可以用二分来查找。再考虑开一颗权值线段树，记录当前的每个 $k$ 值对应的满足条件的下标数。每次计算出一个 $b_i$ ，将线段树上 $bi - n$ 的部分整体加 $1$ 。查询时单点查询即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
#define lson rt << 1
#define rson rt << 1 | 1
const LL N = 1e6 + 10;
LL n, q;
LL a[N], b[N], tr[N];

void build(LL rt, LL l, LL r) {
    if (l == r) {
        tr[rt] = 0;
        return;
    }
    LL mid = (l + r) >> 1;
    build(lson, l, mid);
    build(rson, mid + 1, r);
}

void pushdown(LL rt, LL l, LL r) {
    if (tr[rt]) {
        tr[lson] += tr[rt];
        tr[rson] += tr[rt];
        tr[rt] = 0;
    }
}

void change(LL rt, LL l, LL r, LL x, LL y, LL z) {
    if (x <= l && r <= y) {
        tr[rt] += z;
        return;
    }
    pushdown(rt, l, r);
    LL mid = (l + r) >> 1;
    if (x <= mid)
        change(lson, l, mid, x, y, z);
    if (y > mid)
        change(rson, mid + 1, r, x, y, z);
}

LL query(LL rt, LL l, LL r, LL x) {
    if (l == r)
        return tr[rt];
    pushdown(rt, l, r);
    LL mid = (l + r) >> 1;
    if (x <= mid)
        return query(lson, l, mid, x);
    else
        return query(rson, mid + 1, r, x);
}

int main() {
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        b[i] = 0;
    }
    build(1, 1, n);
    change(1, 1, n, 1, n, 1);
    for (int i = 2; i <= n; i++) {
        LL l = 1, r = n, res = 0;
        while (l <= r) {
            LL mid = (l + r) >> 1;
            if (query(1, 1, n, mid) / mid + 1 > a[i])
                l = mid + 1;
            else
                res = mid, r = mid - 1;
        }
        b[i] = res;
        change(1, 1, n, res, n, 1);
    }
    while (q--) {
        LL x, y;
        cin >> x >> y;
        if (b[x] <= y)
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }
    return 0;
}