AtCoder Beginner Contest 355 A~F

编程竞赛题目解析：逻辑推理、数组操作与图论算法

最新推荐文章于 2025-11-24 15:27:16 发布

原创最新推荐文章于 2025-11-24 15:27:16 发布 · 1.2k 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #数据结构 #ACM-ICPC #OI #atcoder

AtCoder 专栏收录该内容

62 篇文章

订阅专栏

A.Who Ate the Cake?(思维)

题意

已知有三个嫌疑人，有两个证人，每个证人可以指出其中一个嫌疑人不是罪犯，如果可以排除两个嫌疑人来确定犯人，输出犯人的身份，如果无法确定，输出"-1"。

分析

如果输入两个人的编号相同，则无法确定犯人，如果不同，则 $6 - A - B$ 为犯人的编号。

代码

#include <bits/stdc++.h>
using namespace std;

void solve() {
    int a, b;
    cin >> a >> b;
    if (a == b) cout << -1 << endl;
    else cout << 6 - a - b << endl;
}
int main () {
    solve();
    return 0;
}

B.Piano 2(桶数组)

题意

给出一个包含 $n$ 个数字的数组 $A$ 以及一个包含 $m$ 个数字的数组 $B$ ，将 $A$ 数组和 $B$ 数组中的数字放入数组 $C$ 中，并对放入的数字进行排序。

问：数组 $C$ 中是否存在相邻两项，这两项均属于数组 $A$ （保证数组 $A$ 和数组 $B$ 中所有数字均是独立的，即不会出现相同的数字）。

分析

使用标记数组对出现在 $A$ 数组中的数字进行标记，然后将数组 $A$ 和数组 $B$ 中元素放入vector中并排序。

然后依次检查vector中相邻两项是否均被标记，如果均被标记，输出Yes，如果结束循环还是没找到，输出No。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3e5 + 5e2;

int n, m,a[N], b[N], vis[N];
vector<int> C;

void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        C.emplace_back(a[i]);
        vis[a[i]] = 1;
    }
    for (int i = 1; i <= m; i++) {
        cin >> b[i];
        C.emplace_back(b[i]);
    }
    sort(C.begin(), C.end());
    for (int i = 1; i < n + m; i++) {
        if (vis[C[i - 1]] == 1 && vis[C[i]] == 1) {
            cout << "Yes" << endl;
            return;
        }
    }
    cout << "No" << endl;
}
int main () {
    solve();
    return 0;
}

C.Bingo 2(模拟)

题意

给出一个 $\times N$ 的网格，将对这个网格执行 $T$ 个回合操作，每个回合会选择网格上的一个点（使用一个数字代表坐标）进行标记。

当满足以下几种条件之一，即获得了胜利：

存在某一行上所有的格子均被标记
存在某一列上所有的格子均被标记
两条对角线上所有的格子均被标记

问：最早执行多少个回合后，就赢下了这场比赛，如果结束所有操作后还未获胜，输出-1.

分析

为了便于处理，将输入的数字 $A_i$ 先减去 $1$ ，然后通过 $A_i / n, A_i$ % $n$ 的方式即可得到行号和列号（此时的行号和列号从 $0$ 开始）。

然后考虑三个条件怎么进行判断：

行和列：使用数组记录每行每列被标记的节点数量
主对角线：主对角线元素行号和列号均相等，判断当前网格的行号和列号，如果相同即进行标记
副对角线：副对角线的行列号之和为 $n - 1$ ，判断当前网格的行列号之和是否为 $n - 1$ ，如果是就进行标记

每轮标记完成后，判断是否满足以上三个条件，如果满足则输出当前轮次，并结束程序。

如果循环正常结束，输出-1。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5e2;

int n, k, r[N], c[N], d[5], a[N];

void solve() {
    cin >> n >> k;
    for (int i = 1; i <= k; i++) {
        cin >> a[i];
        a[i]--;
        int row = a[i] / n, colum = a[i] % n;
        r[row]++;
        c[colum]++;
        if (row == colum) d[0]++;
        if (row + colum == n - 1) d[1]++;
        if (r[row] == n || c[colum] == n || d[0] == n || d[1] == n) {
            cout << i << endl;
            return;
        }
    }
    cout << -1 << endl;
}
int main () {
    solve();
    return 0;
}

D.Intersecting Intervals(双指针)

题意

给出 $N$ 个区间 $l_i, r_i]$ ，问存在多少对区间相交。

分析

考虑相交比较困难，但考虑不相交就很容易了。

不难想到，只要是右边界小于当前区间的左边界的所有区间，那么必然不会与当前区间相交，此时不在乎这个区间的左边界到底是多少，因此，可以使用两个数字存储左右边界，并单独对两个数组排序。

然后从小往大遍历左边界数组，使用双指针在右边界数组中维护所有小于当前左边界的数量，这个数量就是不会与当前区间相交的区间数量。

使用区间总对数减去每个区间不会相交的区间数量即可。

hint： 本题 $n$ 较大，需要使用long long类型存储答案。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5e2;

int l[N], r[N]; 

void solve() {
    ll n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> l[i] >> r[i];
    }
    sort(l, l + n);
    sort(r, r + n);
    int j = 0;
    ll ans = (n - 1) * n / 2;
    for (int i = 0; i < n; i++) {
        while (r[j] < l[i]) {
            j++;
        }
        ans -= j;
    }
    cout << ans << endl;
}
int main () {
    solve();
    return 0;
}

E.Guess the Sum(BFS)

题意

本题是一个交互题

给出一个数字 $N$ 和区间 $l, r$ ，题目隐藏了一个数组 $(A_0, A_1, \ldots, A_{2^{n} - 1}$ ，你的目标是知道 $(Al+Al+1+…+Ar)(A_l + A_{l + 1} + \ldots + A_{r})$ % $100$ 的结果。

你可以按以下要求进行询问：

选择两个非负整数 $i, j$ ，需要保证 $2i(j+1)≤2N2^{i}(j + 1) \le 2^{N}$ ，然后取 $L = 2^{i}j, R = 2^{i}(j + 1) - 1$ ，将 $i, j$ 告诉题目后，题目会返回 $(AL+AL+1+…+AR)(A_L + A_{L + 1} + \ldots + A_{R})$ % $100$ 的结果

你需要在保证询问次数最小的情况下，找到要求的答案。

分析

由于可以通过查询大区间减去小区间的方式获得结果，因此直接通过倍增的方式进行查找不能保证操作次数最少。

例：当要查询的区间为 $2k∼2k+1−22^{k} \sim 2^{k + 1} - 2$ 时，通过查询区间 $2k∼2k+1−12^{k} \sim 2^{k + 1} - 1$ 减去区间 $2k+1−1∼2k+1−12^{k + 1} - 1 \sim 2^{k + 1} - 1$ 的方式只需要两次询问，而直接使用倍增进行询问所需的次数无法保证两次询问即查询完整个区间数字总和。

因此，可以将本题中所有可能的询问包含的两个点之间建双向边，那么问题就被转化为了 $\sim R + 1$ 之间的最短路(这里为什么取 $R + 1$ 呢？因为当移动到 $R + 1$ 时，才能保证第 $R$ 个元素也被计算到了)，使用 $BFS$ 搜索最短路，然后通过记录的移动步数反推出最短路径，将最短路径上经过的所有路径上的连接的点作为询问，即可获得最后的答案。

hint: 注意最优走法并不一定都是从左往右走的，可能通过先向右走一大步再回头的方式完成，对于往回走的询问，需要从结果中减去。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5e2;
int ask(int i, int j) {
    int sign = 1;
    if (i > j) {
        swap(i, j);
        sign *= -1;
    }
    int l = log2(j - i), r = i >> l;
    cout << "? " << l << ' ' << r << endl;
    cout.flush();
    int ans;
    cin >> ans;
    return sign * ans;
}
int n, l, r, dist[N];
vector<int> G[N];

queue<int> Q;
void bfs(int start) {
    Q.push(start);
    dist[start] = 1;
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        for (auto v : G[u]) {
            if (dist[v] == 0) {
                dist[v] = dist[u] + 1;
                Q.push(v);
            }
        }
    }
}

void solve() {
    cin >> n >> l >> r;
    r++;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j < (1 << n); j += (1 << i)) {
            G[j].push_back(j + (1 << i));
            G[j + (1 << i)].push_back(j);
        }
    }
    bfs(l);
    int ans = 0;
    while (r != l) {
        for (auto v : G[r]) {
            if (dist[r] == dist[v] + 1) {
                ans = (ans + ask(v, r) + 100) % 100;
                r = v;
                break;
            }
        }
    }
    cout << "! " << ans << endl;
}

int main () {
    solve();
    return 0;
}

F.MST Query(并查集)

题意

给出一个包含 $N$ 个点和 $N - 1$ 条边的带权无向连通图，你将对这个图进行 $Q$ 次操作，每次的操作如下：

给出三个数字 $u_i, v_i, w_i$ ，在点 $u_i$ 和 $v_i$ 之间连一条边权为 $w_i$ 的边。
计算当前图上的最小生成树权值

分析

由于图上边权的范围很小 $(wi≤10)(w_i \le 10)$ ，因此，可以维护权值为 $\sim 10$ 的 $10$ 张图，每张图上边权相等。

将每次加边操作视为往对应边权(以及更高的边权)的图上建边，如果建边之前该图上这两个点不属于同一个集合，那么当前边建立后，最小生成树的权值就会减少，减少多少呢？就得看最低多少权值，对应的图上这两个点才属于同一个集合。

从当前权值开始遍历到 $10$ ，执行到第一个连通的权值对应的图后，即可从维护的权值中减去这个遍历到的权值，然后加上当前建边的权值，即得到了最新的最小生成树权值。

hint: 每次建边时，需要在所有权值大于等于当前边权的图中建边。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5e2;

int n, q, f[15][N];

int find(int w, int x) {
    return f[w][x] == x ? x : f[w][x] = find(w, f[w][x]);
}

int merge(int u, int v, int w) {
    int fu = find(w, u),
        fv = find(w, v);
    if (fu == fv) return 1;
    f[w][fu] = fv;
    return 0;
}

void solve() {
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= 10; j++) {
            f[j][i] = i;
        }
    }
    int sum = 0;
    for (int i = 1; i < n; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        for (int j = w; j <= 10; j++) {
            merge(u, v, j);
        }
        sum += w;
    }
    while (q--) {
        int u, v, w;
        cin >> u >> v >> w;
        sum += w;
        for (int j = w; j <= 10; j++) {
            if (merge(u, v, j)) {
                sum -= j;
                break;
            }
        }
        cout << sum << endl;
    }
}

int main () {
    solve();
    return 0;
}