Codeforces EPIC August 2024(Div.1+Div.2) A~E

最新推荐文章于 2024-10-07 02:56:25 发布

AC-Panda

最新推荐文章于 2024-10-07 02:56:25 发布

阅读量393

点赞数 5

分类专栏： codeforces题解文章标签：算法图论深度优先 ACM-ICPC OI c++ codeforces

本文链接：https://blog.csdn.net/code_shark/article/details/141391631

版权

codeforces题解专栏收录该内容

101 篇文章 8 订阅

订阅专栏

A. Distanced Coloring （思维）

题意：

给出一个 $n\times m$ 网格和一个正整数 $k$ 。

现在要用用一些颜色为网格着色，并满足以下条件：

如果 $x_1,y_1)$ 、 $x_2,y_2)$ 是两个具有相同颜色的不同单元格，则 $\max(|x_1-x_2|,|y_1-y_2|)\ge k$ 。

请找出为网格着色所需的最少颜色数量。

分析：

可以发现答案为 $\times min(m,k)$ 。

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, m, k;
        cin >> n >> m >> k;
        n = min(n, k), m = min(m, k);
        cout << n * m << endl;
    }
    return 0;
}

B. Removals Game （博弈论）

题意：

$A l i ce$ 得到了 $[1,2,\ldots,n]$ 的一个排列 $a_1, a_2, \ldots, a_n$ ，而 Bob 得到了 $[1,2,\ldots,n]$ 的另一个排列 $b_1, b_2, \ldots, b_n$ 。他们将用这些数组玩游戏。

在每个回合中，以下事件按顺序发生：

$A l i ce$ 选择她数组的第一个或最后一个元素并将其从数组中删除；
$B o b$ 选择他数组的第一个或最后一个元素并将其从数组中删除。

游戏继续 $n - 1$ 个回合，之后两个数组都只剩下一个元素：数组 $a$ 中的 $x$ 和数组 $b$ 中的 $y$ 。

如果是 $x = y$ ， $B o b$ 获胜；否则， $A l i ce$ 获胜。如果两个玩家都发挥最佳水平，找出哪个玩家会获胜。

分析：

通过归纳可以证明，对于 $B o b$ 来说，要获胜，要么是 $A = B$ ，要么是 $A=\textrm{rev}(B)$ 。 ${rev}(B)$ 表示将 $B$ 翻转。

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        vector<int> a(n), b(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        for (int i = 0; i < n; i++) {
            cin >> b[i];
        }
        vector<int> tmp(n);
        for (int i = 0; i < n; i++) {
            tmp[i] = b[n - i - 1];
        }
        if (a == b or a == tmp) {
            cout << "Bob" << endl;
        } else {
            cout << "Alice" << endl;
        }
    }
    return 0;
}

C.Black Circles （数学）

题意：

二维平面上有 $n$ 个圆。第 $i$ 个圆以 $x_i,y_i)$ 为圆心。最初，所有圆的半径均为 $0$ 。

圆的半径以每秒 $1$ 个单位的速度增加。

你目前位于 $x_s,y_s)$ ，你的目标是在不触碰任何圆的圆周的情况下到达 $x_t,y_t)$ （包括到达 $x_t,y_t)$ 的那一刻）。你可以朝任何方向移动。但是，你的速度限制为每秒 $1$ 个单位。

请确定这是否可行。

分析：

我们只需要判断到达终点的时候是否有一个圆已经将终点覆盖。也就是判断圆心和终点的距离，如果严格大于起点到终点的距离，就一定追不上，可以获胜。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 3e5 + 10;
int x[N], y[N];

LL cal(LL a, LL b, LL c, LL d) {
    return (c - a) * (c - a) + (d - b) * (d - b);
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; ++i)
            cin >> x[i] >> y[i];
        LL xs, ys, xt, yt;
        cin >> xs >> ys >> xt >> yt;
        int flag = 1;
        LL len = cal(xs, ys, xt, yt);
        for (int i = 1; i <= n; ++i) {
            LL len1 = cal(x[i], y[i], xt, yt);
            if (len1 <= len) {
                flag = 0;
                break;
            }
        }
        if (flag)
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }
    return 0;
}

D2.DFS Checker (Hard Version) （图论）

题意：

你将获得一棵由 $n$ 个顶点组成的根树。顶点编号从 $1$ 到 $n$ ，根是顶点 $1$ 。你还获得了 $[1,2,\ldots,n]$ 的排列 $p_1, p_2, \ldots, p_n$ 。

你需要回答 $q$ 个查询。对于每个查询，你将获得两个整数 $x$ 、 $y$ ；你需要交换 $p_x$ 和 $p_y$ ，并确定 $p_1, p_2, \ldots, p_n$ 是否是给定树的有效 $D FS$ 顺序。

请注意，交换在查询过程中是持久的，并且 $D FS$ 顺序不是唯一的。

分析：

首先我们检查 $p_1=1$ 。再考虑其他情况，对于每对相邻元素 $p_i,p_{i+1}$ ， $fa(p_{i+1})$ 必须是 $p_i$ 的祖先，其中 $f a (u)$ 表示节点 $u$ 的父亲。我们可以通过查找违反此条件的 $u$ 的数量来维护此检查，并通过检查 $p_i$ 是否位于 $fa(p_{i+1})$ 的子树中来检查每个 $i$ 。

证明：对于任何子树 $u$ ，我们取任何 $p_i,p_{i+1}$ ，使得 $p_i$ 不属于子树 $u$ ，但 $p_{i+1}$ 属于子树。因此得出 $p_{i+1}=u$ ，因为只有 $f a (u)$ 的子树具有不属于子树 $u$ 的节点。由此，我们可以得出每个子树最多会被输入一次（并形成一个连续间隔），并且第一个访问的节点将是 $u$ ，这足以说明 $p$ 是一个 $df s$ 顺序。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 3e5 + 10;
const int mod = 998244353;
vector<int> g[N];
int tin[N];
int tout[N];
int par[N];
int tot = 0;

void dfs(int u, int p) {
    tin[u] = tout[u] = tot++;
    for (auto v: g[u])
        if (v != p) {
            dfs(v, u);
            par[v] = u;
            tout[u] = tout[v];
        }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, q;
        cin >> n >> q;
        vector<int> p(n + 1);
        for (int i = 0; i <= n; i++)
            g[i].clear();
        tot = 0;
        for (int i = 2; i <= n; i++) {
            int x;
            cin >> x;
            g[x].push_back(i);
        }
        for (int i = 1; i <= n; i++) {
            cin >> p[i];
        }
        dfs(1, 1);
        int cnt = 0;
        auto ok = [&](int i) {
            if (p[i] == 1) {
                if (i == 1)
                    return 1;
                return 0;
            }
            int ant = p[i - 1];
            if (par[p[i]] == ant)
                return 1;
            if (tin[ant] != tout[ant])
                return 0;
            int pa = par[p[i]];
            if (tin[ant] < tin[pa] || tin[ant] > tout[pa])
                return 0;
            return 1;
        };
        for (int i = 1; i <= n; i++) {
            cnt += ok(i);
        }
        for (int qw = 0; qw < q; qw++) {
            int x, y;
            cin >> x >> y;
            set<int> in;
            in.insert(x);
            in.insert(y);
            if (x - 1 >= 1)
                in.insert(x - 1);
            if (x + 1 <= n)
                in.insert(x + 1);
            if (y - 1 >= 1)
                in.insert(y - 1);
            if (y + 1 <= n)
                in.insert(y + 1);
            for (auto v: in) {
                cnt -= ok(v);
            }
            swap(p[x], p[y]);
            for (auto v: in) {
                cnt += ok(v);
            }
            cout << (cnt == n ? "YES" : "NO") << endl;
        }
    }
    return 0;
}

E.Cosmic Rays （单调栈）

题意：

给定一个整数数组 $s_1, s_2, \ldots, s_l$ ，每一秒，宇宙射线都会使所有 $s_i$ 的 $i = 1$ 或 $s_i\neq s_{i-1}$ 被同时删除，其余部分将连接在一起以形成新数组 $s_1, s_2, \ldots, s_{l'}$ 。

将数组的强度定义为变为空所需的秒数。

给出一个整数数组，该数组以 $n$ 对的形式压缩，从左到右描述数组。每对 $a_i,b_i)$ 代表 $a_i$ 个 $b_i$ 副本，即 $\underbrace{b_i,b_i,\cdots,b_i}_{a_i\textrm{ times}}$ 。

对于每个 $i=1,2,\dots,n$ ，请找到前 $i$ 对描述的序列的强度。

分析：

我们可以发现对于两个相邻的位置 $i$ 和 $i + 1$ 所对应的连续二元组，若两个连续二元组所对应的值不同，并且第一个二元组的元素个数小于等于第二个二元组的元素个数。那么第一个二元组的元素一定会被第二个二元组全部消除。所以我们用第二个二元组的元素数量减去第一个二元组的元素数量。这个处理过程类似单调栈。我们用单调栈维护当前的递减二元组个数即可。当前所需要花费的最长时间即为栈底元素最多的二元组的元素个数。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int maxn = 5e5 + 10;
LL a[maxn], b[maxn];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; ++i)
            cin >> a[i] >> b[i];
        deque<LL> tmp;
        LL remain = 0;
        for (int i = 1; i <= n; ++i) {
            while (tmp.size()) {
                if (b[i] != b[tmp.back()]) {
                    if (a[i] > a[tmp.back()])
                        remain = a[tmp.back()], tmp.pop_back();
                    else
                        break;
                } else {
                    a[i] += a[tmp.back()] - remain;
                    tmp.pop_back();
                    remain = 0;
                }
            }
            tmp.push_back(i);
            cout << a[tmp.front()] << " ";
        }
        cout << endl;
    }
    return 0;
}