AtCoder Beginner Contest 409 题解

void solve() {
    int n;
    std::string s, t;
    std::cin >> n >> s >> t;

    int ans = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == t[i] && s[i] == 'o') {
            std::cout << "Yes\n";
            return;
        }
    }

    std::cout << "No\n";
}

题目B:

B - Citation

题目大意:

现在给你一个数组a,你需要找出满足下面条件的最大的整数x:

x满足，在数组a中，大于或等于x的元素在数组中至少出现x次。

解题思路:

我们先从最小的开始看，从特殊到一般：

大于等于0的元素在数组中至少出现0次。

大于等于1的元素在数组中至少出现1次。

大于等于2的元素在数组中出现至少2次。

...

我们很明显可以注意到一点：

随着x的值增加，就表明我们需要在数组中找到更多的数字来满足大于x。

每增加1就需要多找一个数字满足a[i] > x。

那么总会有一个临界点的x，使得数组中无法再找出x个数字来满足大于它了。

那么思路就可以来了，我们直接从数组元素中最大的开始，可以先对数组排序，将x的初始值设置为0，从数组中最大的开始，如果能找到这样一个x，就让x++即可。

代码(C++):

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }

    std::sort(a.begin(), a.end(), std::greater<>());

    int x = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] >= x + 1 && i >= x) {
            x++;
        }
    }

    std::cout << x << "\n";
}

题目C:

C - Equilateral Triangle

题目大意:

给你一个周长为L的圆，现在圆上有n个点。

给你n - 1个数字di, 其中di表示第i + 1个点位于第i个点沿着圆周顺时针di的位置。

其中L和di都为整数。

现在你需要找出在圆上不同的三个点，使得这三个点组成的三角形为等边三角形。

解题思路:

首先得明白关键点：

周长L和每一个点的距离d都是都是整数，那么我们要找到这样一个等边三角形的话，三个点一定是将圆平分成三等分的（这个可以通过连接点和圆心，进行简单的证明）。

既然能三等分周长，那么周长必须是3的倍数。

距离d都是整数，周长为L，我们可以把圆划分成L段，然后计算出每个整数位置的点的个数。

我们可以第0个点的位置设置成0，然后根据题目中给的d计算出每一个位置中点的个数。

假设构成等边三角形的其中一个点的位置为i，那么根据上面的分析，剩下的两个点的位置为i + L / 3, i + 2 * L / 3，也就是分别加上L / 3。

最后满足这样的三角形的三个不同点的个数，可以用乘法原理做，最后除以三即可。

具体看代码实现。

代码(C++):

void solve() {
    int n, l;
    std::cin >> n >> l;

    std::vector<int> cnt(l);
    cnt[0] = 1;
    int pos = 0;
    for (int i = 0; i < n - 1; i++) {
        int d;
        std::cin >> d;
        pos = (pos + d) % l;
        cnt[pos]++;
    }
    
    if (l % 3 != 0) {
        std::cout << "0\n";
        return;
    }

    i64 ans = 0;
    for (int i = 0; i < l; i++) {
        ans += 1LL * cnt[i] * cnt[(i + l / 3) % l] * cnt[(i + l * 2 / 3) % l];
    }
    std::cout << ans / 3 << "\n";
}

题目D:

D - String Rotation

题目大意:

给你一个长度为n的字符串s，现在你可以进行以下操作一次：

选择一个下标i，将s[i]插入到字符串的任意位置，并且删除s[i]。

你需要进行一次操作，使得字符串字典序最小，找出字典序最小的这个字符串。

解题思路:

两个字符串的字典序有一个很常规的比较方法：

从最左边的字符开始比较，逐一比较，当遇到两个不同的字符的时候，比较这两个字符的字典序即可，字符小的那个字符串，即为字典序小的字符串。

题目的意思其实就是把字符中的一个字符进行移动，然后使得字典序尽可能小。

也就是说，字符串的字符构成是不变的。

根据上述分析我们可以得出：

1.在所有的字符字符从小到大排列（也就是升序排列）的时候，此时字符串的字典序最小。

2.我们从前往后对比，当遇到字符不是按升序排列的那个字符的时候，把这个字符往后面放，使得字符串前部分按照升序排列即可。

代码参考官方题解

代码(C++):

void solve() {
    int n;
    std::string s;
    std::cin >> n >> s;

    int l = -1;
    for (int i = 0; i < n - 1; i++) {
        if (s[i] > s[i + 1]) {
            l = i;
            break;
        }
    }

    if (l == -1) {
        std::cout << s << "\n";
        return;
    }

    int r = n;
    for (int i = l + 1; i < n; i++) {
        if (s[l] < s[i]) {
            r = i;
            break;
        }
    }

    std::string ans = s.substr(0, l) + s.substr(l + 1, r - l - 1) + s[l] + s.substr(r);
    std::cout << ans << "\n";
}

题目E:

E - Pair Annihilation

题目大意:

现在有一颗包含n个节点的树，并且给出你边的连接关系和边的权重:

节点ui和vi之间有一条权重为wi的边。

现在这个树的每一个节点上都有xi个正电子或者xi个电子。

你把一个正电子或者电子从节点ui移动到节点vi需要消耗wi个单位的能量，一个正电子和一个电子相遇会湮灭消失。

保证树上的正电子的数目和电子数目相等。

现在你需要通过移动其中的正电子或者电子，是得所有的电子消失，输出需要消耗的最小能量。

解题思路:

题目的关键点是，保证正电子数量和电子数量相等。

既然是一个树，那么显而易见的适合的移动方案：

把叶子节点的电子或者正电子，往根节点移动，全部移到根节点。

代码参考官方题解

代码(C++):

void solve() {
    int n;
    std::cin >> n;

    std::vector<i64> X(n);
    for (int i = 0; i < n; i++) {
        std::cin >> X[i];
    }
    std::vector<std::vector<std::pair<int, i64>>> Trees(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        i64 w;
        std::cin >> u >> v >> w;
        u--;
        v--;
        Trees[u].push_back({v, w});
        Trees[v].push_back({u, w});
    }

    i64 ans = 0;

    std::function<void(int, int)> dfs;

    dfs = [&](int v, int fa) -> void {
        for (auto& [c, w] : Trees[v]) {
            if (c == fa) {
                continue;
            }
            //往下搜子节点
            dfs(c, v);
            //加上此时下面所有的子节点移动到此时这个根节点所需要的能量
            ans += w * abs(X[c]);
            //移动,并且进行消耗(正负抵消)
            X[v] += X[c];
        }
    };

    dfs(0, -1);
    std::cout << ans << "\n";
}