AtCoder Beginner Contest 299
A - Treasure Chest (abc299 a)
题目大意
给定一个包含 |*.的字符串，其中|两个，*一个，问*是否在两个|之间。
解题思路
找到两个|的下标\(l, r\)以及 *的下标\(mid\)，看看是否满足 \(l < mid < r\)即可。
神奇的代码
#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;
string s;
cin >> n >> s;
int l = s.find('|'), r = s.find('|', l + 1), m = s.find('*');
if (m > l && m < r)
cout << "in" << '\n';
else
cout << "out" << '\n';
return 0;
}
B - Trick Taking (abc299 b)
题目大意
给定\(n\)个人的卡片，颜色为 \(c_i\)，数字为 \(r_i\)。
如果其中有颜色为 \(T\)的牌，则该颜色中数字最大的卡片对应的人赢。如果没有，则颜色为第一个人的卡牌颜色（即\(c_0\)）中数字最大的卡片对应的人赢。
问谁赢。
解题思路
按照题意的两种情况，分别判断即可。
神奇的代码
#include <bits/stdc++.h>
#include <vector>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int n, t;
cin >> n >> t;
int maxx = 0;
int win = 0;
bool ok = false;
vector<int> c(n);
for(int i = 0; i < n; ++ i){
cin >> c[i];
ok |= (c[i] == t);
}
if (!ok)
t = c[0];
for(int i = 0; i < n; ++ i){
int r;
cin >> r;
if (c[i] == t){
if (maxx < r){
maxx = r;
win = i;
}
}
}
cout << win + 1 << '\n';
return 0;
}
C - Dango (abc299 c)
题目大意
定义一种字符串\(s\)的等级\(X\)（是一个正整数）， 满足仅包含 -o，且头或尾仅一处为-，其余都为o。其等级\(X\)为 o的数量。
给定一个字符串\(T\)，问其子串的最大等级。
解题思路
依次遍历字符串\(T\)，遇到两个 -时期间就有一个等级。
然后再考虑从头到第一个-的子串，从最后一个-到尾的子串的等级。
注意单纯的一个-并不是合法的（\(0\)不是正整数）
神奇的代码
#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;
string s;
cin >> n >> s;
int la = 0;
int ans = 0;
for(int i = 0; i < n; ++ i){
if (s[i] == '-'){
ans = max(ans, i - la);
la = i;
}
}
if (int pos = s.find('-'); pos != string::npos){
ans = max(ans, n - la);
ans = max(ans, pos + 1);
}
if (ans == 1)
ans = 0;
cout << ans - 1 << '\n';
return 0;
}
D - Find by Query (abc299 d)
题目大意
交互题。
这里有个长度为\(n\)的\(01\)字符串 \(s\) ，其中\(s_1 = 0, s_n = 1\) 。
你可以询问\(s_i\)的值。
输出一个位置 \(p\)满足 \(s_p \neq s_{p + 1}\)。
给定字符串长度\(n\)，你最多问20次。 \(n \leq 2 \times 10^5\)。
解题思路
感觉好像和某次 \(cf\)的交互题很像。
注意题意保证了\(s_1 = 0, s_n = 1\)。
首先询问中间位置\(mid = \frac{n}{2}\)，如果\(s_{mid} = 1\)，由于\(s_n = 1\)，最坏情况很有可能这后半部份都是 \(1\)，显然我们不该去问。但因为 \(s_1 = 0, s_{mid} = 1\)，所以前半部份必定有一处\(s_p = 0, s_{p + 1} = 1\)。 反之\(s_{mid} = 0\)的情况同理。
这样，通过一次询问，我们可以把答案保证存在的区间砍半了。那最多砍 \(\log n\)次就找到结果了。由于 \(n \leq 2 \times 10^5\)，所以不会超过\(20\)次。
神奇的代码
#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;
int l = 1, r = n;
while(l + 1 < r){
int mid = (l + r) >> 1;
cout << "? " << mid << endl;
int ok;
cin >> ok;
if (ok)
r = mid;
else
l = mid;
}
cout << "! " << l << endl;
return 0;
}
E - Nearest Black Vertex (abc299 e)
题目大意
给定一张图，要求给点涂黑白色，要求至少有一个黑点，且满足\(k\)个要求。
每个 要求 \((p_i, d_i)\)表示点 \(p_i\)距离黑点的最近距离恰好为 \(d_i\)。
点数、边数 \(\leq 2000\)
解题思路
注意边数只有\(2000\)。
我们可以对每个要求的 \(p_i\)进行 \(BFS\)，把距离其小于 \(d\)的点都标记为白色。
然后再对每个要求的 \(p_i\)进行 \(BFS\)，把距离其为\(d\)的且未被标记为白色的点标记为黑色。
如果有个要求没有找到可以被涂黑色的点，就无解了。
神奇的代码
#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<vector<int>> edge(n);
for(int i = 0; i < m; ++ i){
int u, v;
cin >> u >> v;
-- u, -- v;
edge[u].push_back(v);
edge[v].push_back(u);
}
int k;
cin >> k;
vector<int> forbid(n);
vector<int> col(n);
vector<array<int, 2>> rule(k);
auto BFS = [&](int s, int d){
if (d == 0)
return;
vector<int> dis(n, -1);
queue<int> team;
dis[s] = 0;
team.push(s);
while(!team.empty()){
int u = team.front();
forbid[u] = 1;
team.pop();
for(auto &v : edge[u]){
if (dis[v] != -1)
continue;
dis[v] = dis[u] + 1;
if (dis[v] < d)
team.push(v);
}
}
};
for(auto &[p, d] : rule){
cin >> p >> d;
-- p;
BFS(p, d);
}
bool ok = true;
auto paint = [&](int s, int d){
vector<int> dis(n, -1);
queue<int> team;
dis[s] = 0;
team.push(s);
while(!team.empty()){
int u = team.front();
team.pop();
if (!forbid[u] && dis[u] == d){
col[u] = 1;
return true;
}
for(auto &v : edge[u]){
if (dis[v] != -1)
continue;
dis[v] = dis[u] + 1;
if (dis[v] <= d)
team.push(v);
}
}
return false;
};
for(auto &[p, d] : rule){
ok &= paint(p, d);
}
if (!ok)
cout << "No" << '\n';
else{
cout << "Yes" << '\n';
if (k == 0)
col[0] = 1;
for(auto &i : col)
cout << i;
cout << '\n';
}
return 0;
}
F - Square Subsequence (abc299 f)
题目大意
给定一个字符串\(s\)，问有多少个串 \(t\)，满足 \(tt\)是 \(s\)的一个子序列。
解题思路
首先不考虑拼接，即问字符串\(s\)中本质不同的子序列数量。这个难点在于如何不算重。一个方法就是规定一种子序列映射到字符串的方式。
容易想到的就是最近匹配，就是判断字符串\(t\)是不是字符串 \(s\)的子序列时，对依次对每个 \(t_i\)进行最近的匹配，能匹配\(s_j\)就匹配上 。我们就按照这个方式去计算，每个本质不同的子序列就只算到一次。
即设 \(dp[i]\)表示以 \(i\)结尾的本质不同的子序列数量，设 \(pos\)表示最大的 \(j\)满足 \(j < i\)且 \(s_{pos} == s_i\)，那么 \(dp[i] = \sum_{j = pos}^{i} dp[j]\)
同样，我们可以按照此方式解决算重问题。从上述问题转到这个问题，一个自然的想法是设\(dp[i][j]\)表示串 \(tt\)中，前一个 \(t\)的末尾在 \(i\)，后一个 \(t\)的末尾在 \(j\)（显然有 \(s_i == s_j\)）的子串数量。
为方便叙述，设 \(tt\)为 \(t_1 t_2\) ，即\(T_{10}T_{11}..T_{1n}T_{20}T_{21}...T_{2n}\)，\(nxt(i, j)\)表示 \(s_i\)后第一个 字符是 \(j\)的位置。
考虑初始状态，如果我们枚举第一个字母是\(k\)的话，那么 \(i = nxt(0, k)\)，而 \(j\)的话感觉难以确定，它可以在任意的 \(a_j = k\)处，区别可能是串 \(t\)的长度不同。因此我们得枚举\(j\)的位置。
确定了初始状态 \(dp[i][j] = 1\)后，然后就枚举下一个字母 \(k\)，由于采取的是最近匹配的原则，那么下一个匹配位置就分别是 \(nxt(i, k)\)和 \(nxt(j, k)\)，即 \(dp[nxt(i, k)][nxt(j,k)] += dp[i][j]\)，转移式子即为此。
最后累计答案时，因为采取最近匹配的原则，我们只对满足 \(nxt(x, s_{i}) = j\)的 \(dp[x][y]\)（ \(y \geq j\)即可）进行累加。
总的来说，就是设\(dp[i][j][k]\)表示 \(t_2\)开头在 \(s_i\)， \(t_1\)末尾在\(s_j\)， \(t_2\) 末尾在\(s_k\)的方案数。
转移式子 \(dp[i][nxt(j, c)][nxt(k, c)] += dp[i][j][k]\)，
答案\(ans = \sum_{i = 1}^{n} \sum_{nxt(j, s_i) == i} \sum_{k = i}^{n} dp[i][j][k]\)
总的时间复杂度是 \(O(n^3)\)
神奇的代码
#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);
string s;
cin >> s;
int n = s.size();
vector<array<int, 26>> nxt(n);
array<int, 26> pos;
pos.fill(-1);
for(int i = n - 1; i >= 0; -- i){
nxt[i] = pos;
pos[s[i] - 'a'] = i;
}
int ans = 0;
for(int st = 1; st < n; ++ st){
vector<vector<int>> dp(n, vector<int>(n, 0));
int first = s[st] - 'a';
int l = pos[first], r = st;
dp[l][r] = 1;
for(int i = l; i < r; ++ i)
for(int j = r; j < n; ++ j){
for(int k = 0; k < 26; ++ k){
int nl = nxt[i][k], nr = nxt[j][k];
if (nl == -1 || nr == -1 || nl >= r)
continue;
dp[nl][nr] += dp[i][j];
if (dp[nl][nr] >= mo)
dp[nl][nr] -= mo;
}
}
for(int i = l; i < r; ++ i)
for(int j = r; j < n; ++ j){
if (nxt[i][first] == r){
ans += dp[i][j];
if (ans >= mo)
ans -= mo;
}
}
}
cout << ans << '\n';
return 0;
}
G - Minimum Permutation (abc299 g)
题目大意
给定一个长度为\(n\)，仅包含数字 \(1 \sim m\)的数组\(a\)，问其字典序最小的一个子序列，是一个排序。
解题思路
从左到右依次考虑数组\(a\)，对于当前的数字\(a_i\)，一个朴素的想法是，选不选它，如果不选它，剩下的序列还能不能组成一个排列，如果不能，则一定要选它，那问题就剩下如何判断能不能组成，以及如果不一定选择，该怎么办。
能不能组成一个排列，就是看剩下序列的数字包不包含还没选择的数，设还没选择的数为\(left\)。
然后对于不是一定要选的数，我们可以先存起来，这样就有一个由满足要求的\(a_i\)组成的候选集合。
继续往右遍历，会遇到第一个不满足要求的位置\(a_r\)，此时可以从候选集合里选数字最小的数，放到答案里，此时\(left\)就少了一个数。
因为\(left\)是判断某个数是不是一定要选的条件，当\(left\)少一时，说明这个条件变得更容易满足，因此\(a_r\)可能会满足，因此可以继续往右边遍历，往候选集合里添加新的数。而之前满足要求的还是满足。
由此就循环就可以得到最终答案了。
神奇的代码
#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> a(n);
vector<int> cnt(m + 1);
int ok = 0;
auto add = [&](int x, int val){
if (cnt[x] == 0)
ok ++;
cnt[x] += val;
};
auto sub = [&](int x, int val){
cnt[x] -= val;
if (cnt[x] == 0)
ok --;
};
for(auto &i : a){
cin >> i;
add(i, 1);
}
vector<int> ans;
vector<int> used(m + 1, 0);
priority_queue<array<int, 2>> candidate;
int target = m;
int l = -1;
for(int i = 0; i < n; ++ i){
if (used[a[i]])
continue;
if (ok != target){
while(-candidate.top()[1] < l || used[-candidate.top()[0]])
candidate.pop();
int val = -candidate.top()[0];
int pos = -candidate.top()[1];
ans.push_back(val);
used[val] = 1;
l = pos;
if (cnt[val])
sub(val, cnt[val]);
candidate.pop();
-- i;
-- target;
continue;
}
sub(a[i], 1);
candidate.push({-a[i], -i});
}
while(ans.size() < m){
int val = -candidate.top()[0];
int pos = -candidate.top()[1];
candidate.pop();
if (pos < l || used[val])
continue;
ans.push_back(val);
used[val] = 1;
l = pos;
}
for(int i = 0; i < m; ++ i){
cout << ans[i] << ' ';
}
cout << '\n';
return 0;
}
赛后发现是道原题，去年的时候做过。
当时的思路更朴素，首先把第一个数\(a_0\)放入答案末尾，然后依次考虑之后的每个数\(a_i\)和答案的末尾的数 \(ans_{back}\)比较，如果 \(a_i < ans_{back}\)，且之后还有一个 \(a_j(j > i) == ans_{back}\)的话，那么当前的 \(ans_{back}\)可以扔掉（仍能保证后续能构造出一个排列），一直扔掉直到\(a_i > ans_{back}\)或者不存在 \(a_j(j > i) == ans_{back}\)，此时把 \(a_i\)放到答案末尾。
然后依次考虑就可以了。时间复杂度是\(O(n)\)的。
简短的代码
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6 + 8;
int a[N], cnt[N];
bool used[N];
int ans[N], cur;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> m >> n;
for(int i = 1; i <= m; ++ i){
cin >> a[i];
cnt[a[i]] ++;
}
cur = 0;
for(int i = 1; i <= m; ++ i){
cnt[a[i]] --;
if (used[a[i]])
continue;
while (cur > 0 && cnt[ans[cur]] && ans[cur] >= a[i]){
used[ans[cur]] = false;
-- cur;
}
++ cur;
ans[cur] = a[i];
used[a[i]] = true;
}
for(int i = 1; i <= n; ++ i)
cout << ans[i] << " \n"[i == n];
return 0;
}
Ex - Dice Sum Infinity (abc299 h)
题目大意
<++>
解题思路
<++>
神奇的代码
