【解题报告】Codeforces Round #379 (Div. 2)

题目链接

---

A. Anton and Danik（Codeforces 734A）

思路

将字符串读取后，扫描字符串，统计 $A$ 和 $D$ 的数量并存在变量中。最后就可以比较变量的大小，根据情况输出答案。

代码

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

const int maxn = 1e5 + 10;
char s[maxn];
int A, D, n;

int main() {
    scanf("%d%s", &n, s);
    // 统计A和D的数量
    for(int i = 0; i < n; i++) {
        if(s[i] == 'A') {
            A++;
        }
        else {
            D++;
        }
    }
    // 根据情况输出
    if(A > D) {
        puts("Anton");
    }
    else if(A == D) {
        puts("Friendship");
    }
    else {
        puts("Danik");
    }
    return 0;
}

---

B. Anton and Digits（Codeforces 734B）

思路

本题中 $2$ 可以被用来生成 $32$ 也可以被用来生成 $256$ 。但是能生成 $256$ 肯定优先生成 $256$ 。因为对 $2$ 而言，这样生成回报比较高，而且不会影响数字 $3$ 的数量。

代码

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

typedef long long ll;
int k2, k3, k5, k6;
ll cnt, sum;

int main() {
    scanf("%d%d%d%d", &k2, &k3, &k5, &k6);
    // 计算能生成多少个“256”
    cnt = min(k2, min(k5, k6));
    // 生成“256”
    k2 -= cnt;
    sum += cnt * 256;
    // 计算能生成多少个“32”
    cnt = min(k2, k3);
    // 生成“32”
    sum += cnt * 32;
    printf("%I64d\n", sum);
    return 0;
}

---

C. Anton and Making Potions（Codeforces 734C）

思路

从策略的角度分析。一共有三种策略：

• 只使用第一种魔法。枚举第一种魔法，用代价在能承受的范围内的魔法的效果来更新答案。
• 只使用第二种魔法。枚举第二种魔法，用代价在能承受的范围内的魔法的效果来更新答案。
• 两种魔法都使用。不能枚举两种魔法，这样时间复杂度太高。但是因为第二种魔法的给出顺序是有序的，于是先枚举第一种魔法，用资源减第一种魔法的代价得到剩余资源。然后用二分查找在第二种魔法中找能够承受的最大代价的魔法（也就是代价在能承受的范围内的效果最好的魔法），用两种魔法的效果来更新答案。

代码

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

typedef unsigned long long ull;
const int maxm = 2e5 + 10;
ull n, m, k, x, s, a[maxm], b[maxm], c[maxm], d[maxm], tmp, ans, zero = 0;

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m >> k >> x >> s;
    for(ull i = 0; i < m; i++) {
        cin >> a[i];
    }
    for(ull i = 0; i < m; i++) {
        cin >> b[i];
    }
    for(ull i = 0; i < k; i++) {
        cin >> c[i];
    }
    for(ull i = 0; i < k; i++) {
        cin >> d[i];
    }
    ans = n * x;
    // 第一种策略
    for(ull i = 0; i < m; i++) {
        if(b[i] <= s) {
            tmp = n * a[i];
            ans = min(ans, tmp);
        }
    }
    // 第二种策略
    for(ull i = 0; i < k; i++) {
        if(d[i] <= s) {
            tmp = max(zero, n - c[i]) * x;
            ans = min(ans, tmp);
        }
    }
    // 第三种策略
    for(ull i = 0; i < m; i++) {
        if(b[i] < s) {
            ull j, idx = upper_bound(d, d + k, s - b[i]) - d;
            if((j = idx - 1) < 0) {
                continue;
            }
            tmp = (n - c[j]) * a[i];
            ans = min(ans, tmp);
        }
    }
    cout << ans << endl;
    return 0;
}

---

D. Anton and Chess（Codeforces 734D）

思路

检查王的八个方向，看看有没有被将军。每个方向都只考虑里王最近的点。这里用的方法是，按照方向将所有棋子保存起来，然后枚举方向，将该方向里离王最近的棋子的类型记录，然后看看这八个（有可能不足八个）棋子的类型是否能对王构成威胁。

代码

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

// 保存棋子信息的结构体
struct piece {
    char c;
    ll x, y;
    piece() {}
    piece(char c, ll x, ll y): c(c), x(x), y(y) {}
};

const ll INF = (1LL << 60);
bool flag = false;
char s[10], ans[10];
int n;
ll x0, y0, x, y, Min;
vector <piece> vec[10];

// 判断棋子是不是在王的j方向上
bool judge(int j) {
    // up
    if(j == 1) {
        return y == y0 && x < x0;
    }
    // down
    if(j == 2) {
        return y == y0 && x > x0;
    }
    // left
    if(j == 3) {
        return x == x0 && y < y0;
    }
    // right
    if(j == 4) {
        return x == x0 && y > y0;
    }
    // upLeft
    if(j == 5) {
        return x < x0 && y < y0 && (x0 - x == y0 - y);
    }
    // downRight
    if(j == 6) {
        return x > x0 && y > y0 && (x - x0 == y - y0);
    }
    // upRight
    if(j == 7) {
        return x < x0 && y > y0 && (x0 - x == y - y0);
    }
    // downLeft
    if(j == 8) {
        return x > x0 && y < y0 && (x - x0 == y0 - y);
    }
}

// 计算两个棋子之间的距离
ll distance(piece p) {
    return abs(p.x - x0) + abs(p.y - y0);
}

int main() {
    scanf("%d%I64d%I64d", &n, &x0, &y0);
    for(int i = 1; i <= n; i++) {
        scanf("%s%I64d%I64d", s, &x, &y);
        // 枚举方向，将棋子归类
        for(int j = 1; j <= 8; j++) {
            if(judge(j) == true) {
                vec[j].push_back(piece(s[0], x, y));
                break;
            }
        }
    }
    // 枚举方向，选出与王位置最近的棋子
    for(int i = 1; i <= 8; i++) {
        Min = INF;
        for(int j = 0; j < vec[i].size(); j++) {
            if(distance(vec[i][j]) < Min) {
                Min = distance(vec[i][j]);
                ans[i] = vec[i][j].c;
            }
        }
    }
    // 检查上下左右四个方向是否有城堡或皇后
    for(int i = 1; i <= 4; i++) {
        if(ans[i] == 'R' || ans[i] == 'Q') {
            flag = true;
            break;
        }
    }
    // 检查四个斜向上是否有象或皇后
    for(int i = 5; i <= 8; i++) {
        if(ans[i] == 'B' || ans[i] == 'Q') {
            flag = true;
            break;
        }
    }
    puts(flag ? "YES" : "NO");
    return 0;
}

---

E. Anton and Tree（Codeforces 734E）

思路

开始的时候看到“连通分量”这个信息，错误地往并查集方面想了。当然，这是没有什么结果的。正解应该是将每个颜色的连通块儿压缩成一个点。然后原来的树就会变成较小的黑白相间的树。如果能找到一个“中心位置”，就能在通过“半径”次操作将黑白相间的树变成单一颜色（类似于一层一层扩散的感觉）。问题就转化成了找“半径”。恰好有“树的直径”这个名词。于是求树的直径即可。（实现方法有“两次 $BFS$ ”和“一次 $DFS$ ”（有人说是树形 $DP$ ）两种）

代码

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

const int maxn = 2e5 + 10;
bool vis[maxn];
int n, cnt, ans, u[maxn], v[maxn], c[maxn], idx[maxn];
vector <int> g[maxn], G[maxn];

// 将分量“压缩”
void dfs(int u) {
    vis[u] = true;
    for(int v : G[u]) {
        if(!vis[v] && c[u] == c[v]) {
            idx[v] = cnt;
            dfs(v);
        }
    }
}

// 求树的直径
// 返回的是节点的深度
// 答案存在ans中
int dp(int u, int p) {
    int d = 0;
    for(int v : g[u]) {
        if(v == p) {
            continue;
        }
        int tmp = dp(v, u);
        ans = max(ans, d + tmp);
        d = max(d, tmp);
    }
    return d + 1;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &c[i]);
    }
    // 建图
    for(int i = 1; i < n; i++) {
        scanf("%d%d", &u[i], &v[i]);
        G[u[i]].push_back(v[i]);
        G[v[i]].push_back(u[i]);
    }
    // 缩点
    for(int i = 1; i <= n; i++) {
        if(vis[i] == false) {
            idx[i] = ++cnt;
            dfs(i);
        }
    }
    // 建图
    for(int i = 1; i < n; i++) {
        if(idx[u[i]] != idx[v[i]]) {
            g[idx[u[i]]].push_back(idx[v[i]]);
            g[idx[v[i]]].push_back(idx[u[i]]);
        }
    }
    // 求直径
    dp(1, -1);
    printf("%d\n", (ans + 1) / 2);
    return 0;
}

---

（其它题目略）