AtCoder Beginner Contest 293
上周因为GDKOI咕咕咕了
A - Swap Odd and Even (abc293 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;
for(int i = 0; i < s.size(); i += 2)
swap(s[i], s[i + 1]);
cout << s << '\n';
return 0;
}
B - Call the ID Number (abc293 b)
题目大意
每人有一个标号和一个叫号，第\(i\)个人标号为 \(i\)，叫号为 \(a_i\)。
依次对每个人，如果此人的标号没被叫到，则此人会叫其叫号，否则直接到下一个人。
问最终有多少人不会叫。
解题思路
按照题意模拟即可。
其实题意都没看懂，看了样例才明白。
神奇的代码
#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> call(n, 0);
for(int i = 0; i < n; ++ i){
int x;
cin >> x;
-- x;
if (call[i] == 0)
call[x] = 1;
}
int ans = count(call.begin(), call.end(), 0);
cout << ans << '\n';
for(int i = 0; i < n; ++ i){
if (call[i] == 0)
cout << i + 1 << ' ';
}
cout << '\n';
return 0;
}
C - Make Takahashi Happy (abc293 c)
题目大意
二维网格，左上走到右下，一次往右或往下走一格。格子上有数字。
问有多少种路径，其走过的数据互不相同。
解题思路
网格只有\(10 \times 10\)，暴力复杂度是 \(O(2^{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 h, w;
cin >> h >> w;
vector<vector<int>> g(h, vector<int>(w, 0));
for(auto &i : g)
for(auto &j : i)
cin >> j;
int ans = 0;
set<int> qwq;
function<void(int, int)> dfs = [&](int x, int y){
if (x == h - 1 && y == w - 1){
++ ans;
return;
}
if (x != h - 1 && qwq.count(g[x + 1][y]) == 0){
qwq.insert(g[x + 1][y]);
dfs(x + 1, y);
qwq.erase(g[x + 1][y]);
}
if (y != w - 1 && qwq.count(g[x][y + 1]) == 0){
qwq.insert(g[x][y + 1]);
dfs(x, y + 1);
qwq.erase(g[x][y + 1]);
}
};
qwq.insert(g[0][0]);
dfs(0, 0);
cout << ans << '\n';
return 0;
}
D - Tying Rope (abc293 d)
题目大意
\(n\)条绳子， \(m\)个捆绑操作。
每个操作将两个绳子的一端绑起来。一端最多只能被捆绑一次。
问最终得到了多少个环形绳子和非环形绳子。
解题思路
将每个绳子看成一个点，绑起来相当于连一条边。
绳子只有两端意味着每个点至多只有两条边与其相连。
因此每条边，要么是环上的边，要么是链上的边，不会是环里横跨环的边。
即最终的图只有两种：\(x\)个点 \(x\)条边的环，以及 \(x\)个点 \(x-1\)条边的链。
因此我们就统计一下最终图的连通块的数量，做做容斥就出来了。（考虑一条边减少一个连通块）
而统计连通块的数量则用并查集。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
class dsu {
public:
vector<int> p;
vector<int> sz;
int n;
dsu(int _n) : n(_n) {
p.resize(n);
sz.resize(n);
iota(p.begin(), p.end(), 0);
fill(sz.begin(), sz.end(), 1);
}
inline int get(int x) {
return (x == p[x] ? x : (p[x] = get(p[x])));
}
inline bool unite(int x, int y) {
x = get(x);
y = get(y);
if (x != y) {
p[x] = y;
sz[y] += sz[x];
return true;
}
return false;
}
};
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int n, m;
cin >> n >> m;
dsu d(n);
for(int i = 0; i < m; ++ i){
int x, y;
string s;
cin >> x >> s >> y >> s;
-- x;
-- y;
d.unite(x, y);
}
int cnt = 0;
for(int i = 0; i < n; ++ i)
cnt += (d.get(i) == i);
int ans1 = m - (n - cnt), ans2 = cnt - ans1;
cout << ans1 << ' ' << ans2 << '\n';
return 0;
}
E - Geometric Progression (abc293 e)
题目大意
给定\(a,x,m\)，求 \(\sum_{i=0}^{x-1}a^i \mod m\)
解题思路
因为递推式和求和式都是线性的，因此可以用矩阵来求。
\[\left[
\begin{matrix}
a^i \\
s_{i-1}
\end{matrix}
\right]
=
\left[
\begin{matrix}
a & 0 \\
1 & 1
\end{matrix}
\right]
\left[
\begin{matrix}
a^{i-1} \\
s_{i-2}
\end{matrix}
\right]
\]
因此就中间那个矩阵的\(x\)次幂 \(\times\)初始矩阵状态就能得到其和 \(s_n\)了。
初始矩阵就是
\[\left[
\begin{matrix}
1 \\
0 \\
\end{matrix}
\right]
\]
而\(x\)次幂则用快速幂的形式求即可。
如果用等比数列的话需要求\(a-1\)在 \(m\)下的逆元，而这必须得保证 \(a-1\)与 \(m\)互质，题意没保证，故无法求。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (decay<decltype(x)>::type i = (x), _##i = (y); i > _##i; --i)
LL MOD;
struct Mat {
static const LL M = 2;
LL v[M][M];
Mat() { memset(v, 0, sizeof v); }
void eye() { FOR (i, 0, M) v[i][i] = 1; }
LL* operator [] (LL x) { return v[x]; }
const LL* operator [] (LL x) const { return v[x]; }
Mat operator * (const Mat& B) {
const Mat& A = *this;
Mat ret;
FOR (k, 0, M)
FOR (i, 0, M) if (A[i][k])
FOR (j, 0, M)
ret[i][j] = (ret[i][j] + A[i][k] * B[k][j]) % MOD;
return ret;
}
Mat pow(LL n) const {
Mat A = *this, ret; ret.eye();
for (; n; n >>= 1, A = A * A)
if (n & 1) ret = ret * A;
return ret;
}
Mat operator + (const Mat& B) {
const Mat& A = *this;
Mat ret;
FOR (i, 0, M)
FOR (j, 0, M)
ret[i][j] = (A[i][j] + B[i][j]) % MOD;
return ret;
}
void prt() const {
FOR (i, 0, M)
FOR (j, 0, M)
printf("%lld%c", (*this)[i][j], j == M - 1 ? '\n' : ' ');
}
};
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
LL a, x, m;
cin >> a >> x >> m;
MOD = m;
Mat qwq;
qwq[0][0] = a;
qwq[1][0] = qwq[1][1] = 1;
Mat ans = qwq.pow(x);
LL res = ans[1][0];
cout << res << '\n';
return 0;
}
F - Zero or One (abc293 f)
题目大意
给定一个数字\(x\)，问多少个 \(b\)，使得 \(x\)在 \(b\)进制下，每个数位要么是 \(0\)要么是 \(1\)。
多组询问。
解题思路
随着\(b\)增大， \(x\)在 \(b\)进制下的数位的数量是越来越小的。
我们可以暴力判断小的进制是否符合要求，对于大的进制，因为位数很少，可以花 \(2^n\)枚举每个数位的状态（是\(0\)还是\(1\)），再二分一下进制\(b\)，看看是否存在一个进制满足上述要求。
神奇的代码
#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 t;
cin >> t;
while(t--){
LL x;
cin >> x;
int up = min(5000ll, x);
int ans = 1;
auto check1 = [&](int base){
LL tmp = x;
while(tmp){
if ((tmp % base) > 1)
return false;
tmp /= base;
}
return true;
};
for(int i = 3; i <= up; ++ i){
ans += check1(i);
}
int up2 = log(x) / log(up) + 1;
auto check2 = [&](int s){
__int128 l = up + 1, r = x + 1;
auto solve = [&](__int128 val){
__int128 tmp = 1, sum = 0;
int tmps = s;
for(int i = 0; i < up2; ++ i){
sum += tmp * (tmps & 1);
tmp *= val;
tmps >>= 1;
}
return sum;
};
while(l + 1 < r){
__int128 mid = (l + r) >> 1;
__int128 sum = solve(mid);
if (sum >= 0 && sum <= x) // sum < 0 => overflow => sum > x
l = mid;
else
r = mid;
}
return solve(l) == x;
};
for(int i = 0; i < (1 << up2); ++ i){
ans += check2(i);
}
cout << ans << '\n';
}
return 0;
}
G - Triple Index (abc293 g)
题目大意
给定一个\(n\)个数字的数组\(a\)，和 \(q\)组询问，每组询问给定 \(l,r\)，问有多少个 \(l \leq i < j < k \leq r\)，满足 \(a_i = a_j = a_k\)
解题思路
考虑一个询问，其答案就是\(\sum \binom{cnt[i]}{3}\)，其中 \(cnt[i]\)表示这个该询问区间中数字 \(i\)的数量。
注意到当询问区间发生变化时， \(cnt\)数组非常容易维护，且每次移位只有一个 \(cnt\)值发生变化。因此离线莫队即可。
神奇的代码
#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);
for(auto &i : a)
cin >> i;
vector<LL> cnt(200001, 0);
vector<array<int, 2>> query(q);
for(auto &i : query){
cin >> i[0] >> i[1];
i[0] --;
}
vector<int> id(q, 0);
int blk_num = sqrt(q), blk_size = q / blk_num;
vector<int> belong(n);
for(int i = 0; i < blk_num; ++ i){
for(int j = i * blk_size; j < (i + 1) * blk_size && j < n; ++ j)
belong[j] = i;
}
iota(id.begin(), id.end(), 0);
sort(id.begin(), id.end(), [&](int a, int b){
if (belong[query[a][0]] != belong[query[b][0]]){
return belong[query[a][0]] < belong[query[b][0]];
}else {
return bool((query[a][1] < query[b][1]) ^ (belong[query[a][0]] & 1));
}
});
int l = 0, r = 0;
vector<LL> ans(q);
LL cur = 0;
auto mv = [&](int pos, int val){
int num = a[pos];
if (cnt[num] >= 3)
cur -= cnt[num] * (cnt[num] - 1) * (cnt[num] - 2) / 6;
cnt[num] += val;
if (cnt[num] >= 3)
cur += cnt[num] * (cnt[num] - 1) * (cnt[num] - 2) / 6;
};
for(auto &i : id){
int L = query[i][0], R = query[i][1];
debug(L, R);
while(l > L)
mv(-- l, 1);
while(r < R)
mv(r ++, 1);
while(l < L)
mv(l ++, -1);
while(r > R)
mv(-- r, -1);
ans[i] = cur;
}
for(auto &i : ans)
cout << i << '\n';
return 0;
}
Ex - Optimal Path Decomposition (abc293 h)
题目大意
给定一棵树，要求对每个节点涂色，最小化数字\(k\)，使得：
- 每个颜色的节点构成一个连通块
- 任意一条简单路径上，节点的颜色种类不超过\(k\)
求该 \(k\)。
解题思路
<++>
神奇的代码
