AtCoder Beginner Contest 291

A - camel Case (abc291 a)

题目大意

给定一个字符串，找到其是大写字母的位置。

解题思路

逐位判断即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    string s;
    cin >> s;
    int pos = find_if(s.begin(), s.end(), [](char c){
            return isupper(c);
            }) - s.begin();
    cout << pos + 1 << '\n';
 
    return 0;
}
 

---

B - Trimmed Mean (abc291 b)

题目大意

给定$5n$个分数，去掉最高的 $n$ 个和最低的$n$个，然后算剩下数的平均分。

解题思路

排序后选中间$3n$个数的平均值即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    vector<int> s(n * 5);
    for(auto &i : s)
        cin >> i;
    sort(s.begin(), s.end());
    int sum = accumulate(s.begin() + n, s.end() - n, 0);
    cout << fixed << setprecision(10) << 1.0 * sum / (3 * n) << '\n';
 
    return 0;
}
 

---

C - LRUD Instructions 2 (abc291 c)

题目大意

当前位置为$(0,0)$，给定一个 LRUD操作序列，问在执行该序列时，所访问的点坐标是否重复。

解题思路

拿$set$记录下访问过的下标，加速查询，模拟即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int x = 0, y = 0;
    int n;
    string s;
    cin >> n >> s;
    auto check = [&](){
        set<pair<int, int>> visit;
        visit.insert({x, y});
        for(auto &i : s){
            if (i == 'L')
                -- x;
            else if (i == 'R')
                ++ x;
            else if (i == 'D')
                -- y;
            else if (i == 'U')
                ++ y;
            else 
                assert(0);
            if (visit.find({x, y}) != visit.end())
                return true;
            visit.insert({x, y});
        }
        return false;
    };
    cout << (check() ? "Yes" : "No") << '\n';
 
    return 0;
}
 

---

D - Flip Cards (abc291 d)

题目大意

给定$n$张卡，每张卡正反两面都写了个数。

现在可以将一些卡面正反颠倒，问有多少种策略，使得前一张的反面和后一张卡的正面的数都不同。

解题思路

从搜索状态考虑，为了策略的合法性（前后两张卡反正面数不同）需要的状态为前一张卡是否翻转，其余信息都可以不需要。

因此设$dp[i][0/1]$表示前 $i$张卡，第 $i$张卡是没翻转/翻转，且前面卡面都符合题意要求的方案数。

转移就枚举第 $i-1$位的翻转情况，根据是否符合题意要求。

因为每次仅涉及 $i-1$的状态，第一维可以滚动数组优化。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int mo = 998244353;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    vector<pair<int, int>> card(n);
    for(auto &i : card)
        cin >> i.first >> i.second;
    vector<int> dp(2, 1);
    for(int i = 1; i < n; ++ i){
        vector<int> tmp(2, 0);
        tmp[0] = dp[0] * (card[i].first != card[i - 1].first) + dp[1] * (card[i].first != card[i - 1].second);
        if (tmp[0] >= mo)
            tmp[0] -= mo;
        tmp[1] = dp[0] * (card[i].second != card[i - 1].first) + dp[1] * (card[i].second != card[i - 1].second);
        if (tmp[1] >= mo)
            tmp[1] -= mo;
        dp.swap(tmp);
    }
    cout << (dp[0] + dp[1]) % mo << '\n';
 
    return 0;
}
 

---

E - Find Permutation (abc291 e)

题目大意

现在有一个$1 \sim n$排列。已知 $m$个大小关系，即第 $a_i$个数小于第 $b_i$个数。

问能否从这些关系中确定唯一的排列，可以则输出排列，不可以则输出 No。

解题思路

初看该题时没啥思路，然后想着看看一些特别情况，比如如何确定$1$的位置。

一个位置是 $1$，那就是说该位置小于其他所有位置。而小于关系是有传递性的，于是考虑如果把这个传递性体现出来，来求得一个位置小于所有位置。

这就可以考虑一张由小于关系构成的有向图，$a < b$则第 $a$号点连一条边到第 $b$号点。

如果我能一个入度为 $0$的点出发，能到达 $n-1$个点 ，那就意味着这个点小于其他所有点，此点就是$1$。当然如果入度为 $0$的点有多个，那么此时 这些点都可能是$1$，那就不行了。

而 $1$考虑完后，就去掉其影响，考虑 $2$，发现还是原来的子问题。

然后就发现就是一个拓扑排序，在这过程中，队列里（此时度数为 $0$的点）只能有一个（不然有多个点都可以取该值）， 依次确定出$1,2,3$的位置。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> du(n);
    vector<vector<int>> edge(n);
    for(int i = 0; i < m; ++ i){
        int u, v;
        cin >> u >> v;
        -- u, -- v;
        edge[u].push_back(v);
        ++ du[v];
    }
    vector<int> ans(n);
    auto check = [&](){
        queue<int> team;
        for(int i = 0; i < n; ++ i){
            if (du[i] == 0)
                team.push(i);
        }
        int cur = 0;
        while(!team.empty()){
            if (team.size() != 1)
                return false;
            int u = team.front();
            ++ cur;
            ans[u] = cur;
            team.pop();
            for(auto &v : edge[u]){
                du[v] --;
                if (du[v] == 0)
                    team.push(v);
            }
        }
        return (cur == n);
    };
    if (check()){
        cout << "Yes" << '\n';
        for(auto &i : ans)
            cout << i << ' ';
    }else {
        cout << "No" << '\n';
    }
 
    return 0;
}
 

---

F - Teleporter and Closed off (abc291 f)

题目大意

给定$n$号点，依次排列，每个点都有一个数组 $s$，第 $i$个点的 $s_{i,j}$表示从$i$号点能否到达 $i+j$号点。

对于每个$k=2,3,4,...,n-1$，问从 $1$号点出发，再不经过 $k$号点的情况下，到达第 $n$号点的最小距离。

解题思路

注意这题的$s$的长度$m$只有 $10$。

如果不考虑$k$的话，就设 $dp[i]$表示到达 $i$号点的最小距离，因为只能往标号大的点走，因此转移就枚举下一个到达的点，取最小值即可。

但有$k$的话， $dp[n]$就不一定合法了，因为在转移的时候我们没有限制不能走第 $k$号点，所以不知最终的 $dp[n]$是否经过第 $k$号点。

但因为关键决策就是第 $k$号点，因此我们揪出转移会涉及到 $k$号点的点，只有$m - 1$个，即第 $k - m + 1, k - m + 2,...,k - 1$号点，对于这些点 $l$，我们枚举它们下一个到达的，且大于$k$的点 $r$，此时从$1$号点到 $n$号点分成了三段：

• $1 \to l$
• $l \to r$
• $r \to n$

那此时从 $1$号点到 $l$号点， $r$号点到 $n$号点都是没有限制的，而这个可以事先预处理$dis1[l]$表示 $1$号点到 $l$号点的最短距离，以及 $dis2[r]$表示从 $r$号点到 $n$号点的最短距离。而$l$号点到 $r$号点的距离是 $1$，且保证了不经过 $k$号点，因此总的距离是 $dis1[l] + dis2[r] + 1$。

预处理 $dis1[i],dis2[i]$的时间复杂度是 $O(nm)$，对于每个 $k$的时间复杂度是$O(m^2)$（有 $m$个枚举点，每个点枚举下一个目的地有 $m$个），因此总的时间复杂度是 $O(nm^2)$

这其实跟一张图，必定经过某条边的最短路是一样的想法。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<string> s(n);
    for(auto &i : s)
        cin >> i;
    vector<int> dis1(n, n + 5), dis2(n, n + 5);
    dis1[0] = 0;
    for(int i = 0; i < n - 1; ++ i){
        for(int j = 0; j < m && i + j + 1 < n; ++ j){
            if (s[i][j] == '1')
                dis1[i + j + 1] = min(dis1[i + j + 1], dis1[i] + 1);
        }
    }
    dis2[n - 1] = 0;
    for(int i = n - 2; i >= 0; -- i){
        for(int j = 0;j < m && i + j + 1 < n; ++ j){
            if (s[i][j] == '1')
                dis2[i] = min(dis2[i], dis2[i + j + 1] + 1);
        }
    }
    for(int i = 1; i < n - 1; ++ i){
        int ans = n + 5;
        for(int j = max(0, i - m + 1); j < i; ++ j){
            for(int k = i - j; k < m; ++ k){
                if (s[j][k] == '1')
                    ans = min(ans, dis1[j] + 1 + dis2[j + k + 1]);
            }
        }
        if (ans == n + 5)
            ans = -1;
        cout << ans << " \n"[i == n - 2];
    }
 
    return 0;
}
 

---

G - OR Sum (abc291 g)

题目大意

两个长度为$n$的数组 $A$和 $B$。

现在可以对 数组$A$进行左循环移位操作，即将 $A$的第一个元素放到最后。

问 $\sum_{i=0}^{n - 1} A_i | B_i$的最大值。

解题思路

朴素的方法复杂度是$O(n^2)$，即有 $O(n)$种操作情况，每种情况的答案计算复杂度为 $O(n)$。考虑优化计算。

因为位运算各个数位独立，我们依次考虑每个数位$1$的数量，再乘以该数位的基（就是$2^i$）就可以得到结果。

即$\sum_{i = 0}^{\log m}2^i \sum_{j=0}^{n - 1}A^{i}_{(j + k) \% n} | B^{i}_{j}$

其中$k$就是进行了 $k$次操作。$A^i_j$就是 $A_j$在二进制下的第 $i$位的值，$0$或者 $1$。

单看第二个求和式子感觉是个卷积式，只要把$B$颠倒一下，就是$\sum_{j=0}^{n - 1}A^{i}_{(j + k) \% n} | B^{i}_{n - j - 1}$

而因为 $A | B = A + B - A \& B$，因此$\sum_{j=0}^{n - 1}A^{i}_{(j + k) \% n} + B^{i}_{n - j - 1} - A^{i}_{(j + k) \% n} \& B^{i}_{n - j - 1}$

前两项是定值，而后一项，因为其取值只有$0$和 $1$， 与运算和乘法运算是一样的结果，因此其可以看成是个卷积。

设$a = (A_0, A_1, ... , A_{n-1}, A_0, A_1, ..., A_{n - 1}), b = (B_{n-1}, B_{n-2}, ..., B_{1}, B_{0}), c = a * b$
此时$c_{n + k - 1} = \sum_{i = 0}^{n - 1} b_{i} \times a_{n + k - 1 - i}$，和上面的$\&$卷积式是一样的。

因此通过一次卷积，就能得到每个数位的移动$k$次后的 或运算的结果，每种操作的每个数位累计求和，求个最大值即可。卷积复杂度是$O(n \log n)$，总的时间复杂度是 $O(n \log n \log m)$

神奇的代码

---

Ex - Balanced Tree (abc291 h)

题目大意

<++>

解题思路

<++>

神奇的代码

---