AtCoder Beginner Contest 350
A - Past ABCs (abc350 A)
题目大意
给定一个形如 ABCXXX
的字符串。
问XXX
是否是\(001 \to 349\)之间,且不能是 \(316\)。
解题思路
将后三位转换成数字后判断即可。
神奇的代码
a = int(input().strip()[3:])
if a >= 1 and a <= 349 and a != 316:
print("Yes")
else:
print("No")
B - Dentist Aoki (abc350 B)
题目大意
给定\(n\)个 \(01\)序列。
进行\(q\)次操作,每次操作反转某一位上的 \(01\)。
问最后 \(1\)的个数。
解题思路
反转操作的复杂度是\(O(1)\),因此直接模拟反转即可,最后求和得到答案。
神奇的代码
#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, q;
cin >> n >> q;
vector<int> a(n, 1);
while (q--) {
int x;
cin >> x;
--x;
a[x] ^= 1;
}
int ans = accumulate(a.begin(), a.end(), 0);
cout << ans << '\n';
return 0;
}
C - Sort (abc350 C)
题目大意
给定一个\(1 \to n\)的排序,通过最多\(n-1\)次操作以下操作将其变得有序。
操作为,交换任意两个数。
输出任意可行的操作次数及其对应的操作步骤。
解题思路
从\(i = 1 \to n\),依次考虑将 \(i\)交换到第 \(i\)位。经过 \(n-1\)次操作后则必定有序。
因此需要记录 \(pos[i]\)表示数字 \(i\)所在的位置,每次交换第\(i, pos[i]\) 位,就将\(i\)交换到第 \(i\)位,重复执行\(n-1\)次即可。
神奇的代码
#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> pos(n);
vector<int> a(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
--x;
pos[x] = i;
a[i] = x;
}
vector<array<int, 2>> ans;
for (int i = 0; i < n; i++) {
if (a[i] == i)
continue;
ans.push_back({i, pos[i]});
swap(a[i], a[pos[i]]);
swap(pos[a[i]], pos[a[pos[i]]]);
}
cout << ans.size() << '\n';
for (auto& p : ans) {
cout << p[0] + 1 << ' ' << p[1] + 1 << '\n';
}
return 0;
}
D - New Friends (abc350 D)
题目大意
给定一张无向图,若三点\(x,y,z\),存在:
- \(x,y\)有连边
- \(y,z\)有连边
- \(x,z\)无连边
则连边\(x,z\)。
问最多能连多少次边。
解题思路
考虑最简单的一条链的情况\(1 \to 2 \to 3 \to 4\),容易发现可以连的边有
- \(1 \to 2, 2 \to 3\) => \(1 \to 3\)
- \(1 \to 3, 3 \to 4\) => \(1 \to 4\)
- \(2 \to 3, 3 \to 4\) => \(2 \to 4\)
观察\(1\)的新增边的情况,会发现它可以和所有能到达的点连边,即最终情况下,一个连通块内的任意两点都会连边,即变成一张完全图。
因此\(BFS\)得到每个连通块的点数 \(cp\)和边数 \(ce\),最终情况下该连通块会有 \(\frac{cp * (cp - 1)}{2}\) 条边,而已经有\(ce\)条(无向)边,因此可以连 \(\frac{cp * (cp - 1)}{2} - ce\)条边。
所有连通块的连边次数相加即为答案。
神奇的代码
#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);
}
LL ans = 0;
vector<int> vis(n, 0);
for (int i = 0; i < n; ++i) {
if (vis[i])
continue;
queue<int> team;
team.push(i);
vis[i] = 1;
int cp = 1, ce = 0;
while (!team.empty()) {
int u = team.front();
team.pop();
for (auto v : edge[u]) {
++ce;
if (vis[v])
continue;
vis[v] = 1;
team.push(v);
cp++;
}
}
ans += 1ll * cp * (cp - 1) - ce;
}
ans /= 2;
cout << ans << '\n';
return 0;
}
E - Toward 0 (abc350 E)
题目大意
给定一个数字\(n\),\(x,y,a\)。通过两类操作,使得\(n\)变为 \(0\)。
- 操作一,花费代价\(x\),使得 \(n = \lfloor \frac{n}{a} \rfloor\)
- 操作二,花费代价\(y\),掷骰子,等概率掷出\(1 \to 6\)中的一个\(b\),使得 \(n = \lfloor \frac{n}{b} \rfloor\)
问最优情况下,最小期望花费。
解题思路
期望题,根据定义,当前的期望值是所有后继情况的期望值的概率加权。
设\(dp[i]\)表示当前数字为 \(x\),将其变为 \(0\)的最小期望花费。
边界条件很明显就是 \(dp[0] = 0\)。
虽然是期望,但它问的是最优情况下的最小花费,那就是一个决策最优问题,考虑我的决策是什么。
很显然,决策就是操作一还是操作二,如果我决定执行操作一,会有一个期望值,执行操作二,会有另一个期望值,这两个期望值取最小,就是我做出的最优决策。因此需要分别求出操作一和操作二的期望花费。
根据定义,当前的期望值是所有后继情况的期望值的概率加权。
当我执行操作一后,后继情况只有一个,那就是\(dp[ \lfloor \frac{n}{a} \rfloor ]\),达到这个情况的概率是 \(1\)。因此操作一的期望花费\(cost1 = dp[ \lfloor \frac{n}{a} \rfloor ] + x\)。
当我执行操作二后,后继情况有\(6\)个:
- \(dp[ \lfloor \frac{n}{1} \rfloor ]\)
- \(dp[ \lfloor \frac{n}{2} \rfloor ]\)
- \(dp[ \lfloor \frac{n}{3} \rfloor ]\)
- \(dp[ \lfloor \frac{n}{4} \rfloor ]\)
- \(dp[ \lfloor \frac{n}{5} \rfloor ]\)
- \(dp[ \lfloor \frac{n}{6} \rfloor ]\)
到达每一个后继情况的概率都是\(\frac{1}{6}\)。
根据期望定义,可以得到操作二的期望花费 \(dp[n] = \frac{\sum_{i=1}^{6} dp[ \lfloor \frac{n}{i} \rfloor ]}{6} + y\)
但注意到\(i=1\)那一项是 \(dp[n]\),与左式是一样的,这会造成循环求值,这里我们将右边的 \(dp[n]\) 移到左边,合并同类项,就可以得到真正的\(cost2 = \frac{\sum_{i=2}^{6} dp[ \lfloor \frac{n}{i} \rfloor ]}{5} + \frac{6}{5}y\)
得到两个操作的期望花费\(cost1,cost2\)后,接下来就是做决策——取花费最小的,作为 \(dp[n]\)的值。这样是转移了。
虽然 \(n\)有 \(O(10^{18})\),但由于每次都至少\(/2\),最多除以 \(\log\)次就变成 \(0\),总的状态数其实很少,只有\(O(\log_2 * \log_3 * \log_4 * \log_5 * \log_6)\),大概就\(4e7\)的数量级。
从上面的分析可以看出,期望\(dp\)和\(dp\)之间的区别仅仅是计算转移代价时需要用到期望定义来算,最终还是根据不同操作之间的代价取最优,还是个决策问题。
神奇的代码
#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);
LL n;
int a, x, y;
cin >> n >> a >> x >> y;
map<LL, double> dp;
auto dfs = [&](auto dfs, LL u) -> double {
if (u == 0)
return 0.;
if (dp.find(u) != dp.end())
return dp[u];
double cost1 = dfs(dfs, u / a) + x;
double cost2 = 0;
for (int i = 2; i <= 6; i++) {
cost2 += dfs(dfs, u / i);
}
cost2 = cost2 / 5 + y * 6. / 5;
return dp[u] = min(cost1, cost2);
};
dfs(dfs, n);
cout << fixed << setprecision(10) << dp[n] << '\n';
return 0;
}
F - Transpose (abc350 F)
题目大意
给定一个括号序列\(s\),长度为\(n\),其中也包括大小写字母。
依次处理每个匹配的括号里的字符,将其左右颠倒,并将大小写字母变换。
问最终的字符串。
解题思路
考虑朴素的做法,进行括号匹配,然后处理括号内的字符串,容易发现最坏情况下复杂度是\(O(n^2)\),比如((((((((((asjigjiogjwifjwefckfj))))))))))
。
注意到同一个字符块执行两次上述变换后相当于没变换,从上述的最坏情况下可以启示我们,我们不需要实际进行变换,仅仅将这一块字符串看作整体,然后打个标记。就跟线段树的懒标记差不多。
比如(((as)(sf))(ef))
,我们先将每一块字符串看作整体,从 \(0\)开始标号,则变为(((0)(1))(2))
,然后处理每对匹配的括号,比如变成了((34)(2))
,然后处理 (34)
,这里我们就不给34
重复打标记,因为那样的复杂度可能会变回原来的\(O(n^2)\),而是将 \(34\)看成一个整体 \(5\),在\(5\)上打标记,最后输出时再传递给 \(34\)。变成 (5(2))
,然后是(56)
,然后是7
。
就跟线段树的思想一样,我们会发现\(34 \to 5, 2 \to 6, 56 \to 7\),它们的关系形成了一棵树的关系(但可能不是二叉树),然后打标记都是在父亲节点打标记,最后输出时,从根节点开始遍历,不断下放标记,下放到叶子时,再根据标记决定是否倒序输出即可。
神奇的代码
#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;
s = "(" + s + ")";
vector<string> info;
info.push_back("(");
info.push_back(")");
string t;
vector<int> tr;
for (auto& i : s) {
if (i == '(' || i == ')') {
if (!t.empty()) {
tr.push_back(info.size());
info.push_back(t);
}
t.clear();
if (i == '(')
tr.push_back(0);
else
tr.push_back(1);
} else
t += i;
}
vector<vector<int>> edge(info.size());
stack<int> st;
for (auto i : tr) {
if (i == 0) { // (
st.push(0);
} else if (i == 1) { // )
int fa = info.size();
info.push_back("");
edge.push_back(vector<int>());
while (!st.empty() && st.top() != 0) {
edge[fa].push_back(st.top());
st.pop();
}
st.pop();
st.push(fa);
} else {
st.push(i);
}
}
auto inverse = [](string& s) {
reverse(s.begin(), s.end());
for (auto& i : s) {
if (islower(i))
i = toupper(i);
else
i = tolower(i);
}
};
auto dfs = [&](auto dfs, int u, int d) -> void {
if (edge[u].empty()) { // leaf
if (d)
inverse(info[u]);
cout << info[u];
return;
}
if (d)
reverse(edge[u].begin(), edge[u].end());
for (auto v : edge[u]) {
dfs(dfs, v, d ^ 1);
}
};
dfs(dfs, info.size() - 1, 1);
return 0;
}
G - Mediator (abc350 G)
题目大意
给定\(n\)个点,执行下列 \(q\)次操作,分两种,强制在线。
1 u v
,连无向边\(u \to v\),连边之前保证\(u,v\)不连通。2 u v
,询问是否有一个点\(x\),使得\(u \to x \to v\)。
解题思路
<++>
神奇的代码