AtCoder Beginner Contest 327
2023.11.08 update: 更新了G
A - ab (abc327 A)
题目大意
给定一个字符串\(s\)，问是否包含 ab或ba。
解题思路
遍历判断即可。
神奇的代码
#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;
bool ok = false;
for (int i = 1; i < n; ++i) {
ok |= (s[i] == 'a' && s[i - 1] == 'b');
ok |= (s[i - 1] == 'a' && s[i] == 'b');
}
if (ok)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
return 0;
}
B - A^A (abc327 B)
题目大意
给定\(b\)，问是否存在 \(a\)使得 \(a^a = b\)。
解题思路
由于指数爆炸的缘故，\(a\)的范围不会很大，枚举\(a\)，看\(b \% a\)是否为 \(0\)，然后用\(b\)不断除以 \(a\) ，看最后除的次数是否等于\(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);
LL b;
cin >> b;
int ans = -1;
for (int i = 2; i <= 20; ++i) {
if (b % i != 0)
continue;
LL x = b;
int cnt = 0;
while (x > 1) {
x /= i;
++cnt;
}
if (cnt == i) {
ans = i;
break;
}
}
if (b == 1)
ans = 1;
cout << ans << '\n';
return 0;
}
C - Number Place (abc327 C)
题目大意
给定一个\(9 \times 9\)的网格，问是否符合数独局面。
数独局面，即每行 \(1-9\)，每列 \(1-9\)，每个 \(3 \times 3\)的格子有 \(1-9\)。
解题思路
按照条件，逐行、逐列、逐格子分别判断即可。
神奇的代码
#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);
array<array<int, 9>, 9> a;
for (auto& i : a)
for (auto& j : i)
cin >> j;
auto ok = [&]() {
for (auto& i : a) {
if (set<int>(i.begin(), i.end()).size() != 9)
return false;
}
for (int i = 0; i < 9; ++i) {
set<int> cnt;
for (int j = 0; j < 9; ++j) {
cnt.insert(a[j][i]);
}
if (cnt.size() != 9)
return false;
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
set<int> cnt;
for (int x = 0; x < 3; ++x)
for (int y = 0; y < 3; ++y) {
cnt.insert(a[i * 3 + x][j * 3 + y]);
}
if (cnt.size() != 9)
return false;
}
}
return true;
};
if (ok())
cout << "Yes" << '\n';
else
cout << "No" << '\n';
return 0;
}
D - Good Tuple Problem (abc327 D)
题目大意
给定两个数组长度为\(m\)，仅包含\(1-n\)的\(a,b\)，问它们是否是一对好数组。
若两个数组是一对好数组，则存在一个长度为\(n\)的\(01\)数组 \(x\)，使得 \(x_{a_i} \neq x_{b_i}, \forall i \in [1, m]\)。
解题思路
将条件抽象成图，相当于是点\(a_i\)和点\(b_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, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (auto& i : a) {
cin >> i;
--i;
}
for (auto& i : b) {
cin >> i;
--i;
}
vector<vector<int>> edge(n);
for (int i = 0; i < m; ++i) {
edge[a[i]].push_back(b[i]);
edge[b[i]].push_back(a[i]);
}
vector<int> col(n, -1);
bool ok = true;
auto BFS = [&](int st) {
queue<int> team;
team.push(st);
col[st] = 0;
while (!team.empty()) {
int u = team.front();
team.pop();
int target = (col[u] ^ 1);
for (auto& v : edge[u]) {
if (col[v] == -1) {
col[v] = target;
team.push(v);
} else if (col[v] != target) {
ok = false;
return;
}
}
}
};
for (int i = 0; i < n && ok; ++i) {
if (col[i] == -1)
BFS(i);
}
if (ok)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
return 0;
}
E - Maximize Rating (abc327 E)
题目大意
给定\(n\)场比赛的表现分\(p_i\)，现在选择一些场比赛，使得这些场比赛的 \(rating\)最大。
如果选择了 \(k\)场比赛 \((q_1, q_2, ..., q_k)\)，则 \(rating\)为
注意这里的\(q\)要按照原来的顺序排列。
解题思路
枚举\(k\)，有几项就变成常数，唯一的变数就是最大化\(\sum_{i=1}^{k}(0.9)^{k-i}q_i\)，这其实就是个经典的背包问题。
设\(dp[i][j]\)表示前 \(i\)场比赛，我选择了\(j\)场的\(\sum_{i=1}^{k}(0.9)^{k-i}q_i\)的最大值。
转移就是考虑当前比赛选或不选，则\(dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] * 0.9 + p_i)\)
初始条件就是\(dp[0][0] = 0\)。
答案就是\(\max(\frac{dp[n][k]}{\sum_{i=1}^{k}(0.9)^{k-i}} - \frac{1200}{\sqrt{k}})\)
时间复杂度是\(O(n^2)\)
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const double inf = numeric_limits<double>::max();
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<double> dp(n + 1, -inf);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
vector<double> dp2 = dp;
int p;
cin >> p;
for (int j = 1; j <= i + 1; ++j) {
dp2[j] = max(dp2[j], dp[j - 1] * 0.9 + p);
}
dp2.swap(dp);
}
double ans = -inf;
double bottom = 1;
for (int i = 1; i <= n; ++i) {
ans = max(ans, dp[i] / bottom - 1200 / sqrt(i));
bottom = bottom * 0.9 + 1;
}
cout << fixed << setprecision(10) << ans << '\n';
return 0;
}
F - Apples (abc327 F)
题目大意
二维平面，给定若干个点，问一个长宽为\(d \times w\)的矩形所能覆盖的点的数量的最大值。
解题思路
枚举一个维度\(i\)（时间），问题就是在\([i, i + d)\)的范围内的另一维度（地点）的宽度为\(w\)的点数的最大值。
设数组\(a[i]\)表示 \(sum[i, i + w)\)，即当前时间范围内的一个区间的点数，随着时间的流逝，会有新的点加入，会有旧的点删去。其影响的都是一个长度为 \(w\)的\(a\)区间，用线段树维护这个数组 \(a\)即可。
时间复杂度为\(O(n\log n)\)
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e5 + 8;
class segtree {
#define lson (root << 1)
#define rson (root << 1 | 1)
int max[N << 2], lazy[N << 2];
inline void pushdown(int root) {
if (lazy[root]) {
lazy[lson] += lazy[root];
max[lson] += lazy[root];
lazy[rson] += lazy[root];
max[rson] += lazy[root];
lazy[root] = 0;
}
}
void update(int root, int l, int r, int L, int R, LL val) {
if (L <= l && r <= R) {
lazy[root] += val;
max[root] += val;
return;
}
pushdown(root);
int mid = (l + r) >> 1;
if (L <= mid)
update(lson, l, mid, L, R, val);
if (R > mid)
update(rson, mid + 1, r, L, R, val);
max[root] = std::max(max[lson], max[rson]);
}
int query(int root, int l, int r) { return max[root]; }
public:
int n;
void update(int L, int R, LL val) { update(1, 1, n, L, R, val); }
int query() { return query(1, 1, n); }
};
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, d, w;
cin >> n >> d >> w;
vector<array<int, 2>> apple(n);
for (auto& i : apple)
cin >> i[0] >> i[1];
vector<int> id(n);
iota(id.begin(), id.end(), 0);
ranges::sort(id, [&](int a, int b) { return apple[a][0] < apple[b][0]; });
segtree seg;
seg.n = N - 8;
auto it = id.begin();
int ans = 0;
for (auto& i : id) {
while (it != id.end() && apple[*it][0] + d <= apple[i][0]) {
seg.update(max(1, apple[*it][1] - w + 1), apple[*it][1], -1);
it = next(it);
}
seg.update(max(1, apple[i][1] - w + 1), apple[i][1], 1);
ans = max(ans, seg.query());
}
cout << ans << '\n';
return 0;
}
G - Many Good Tuple Problems (abc327 G)
题目大意
若两个数组是一对好数组，则存在一个长度为\(n\)的\(01\)数组 \(x\)，使得 \(x_{a_i} \neq x_{b_i}, \forall i \in [1, m]\)。
问所有的长度为\(m\)，仅包含 \(1-n\)的共 \(n^{2m}\)对数组中，好数组的数量。
解题思路
注意到一对数组是好数组，我们将每一位的数字连一条边，这意味着它们所形成的图是一张二分图。
考虑对这个二分图计数。
首先这个二分图会有重边，我们将重边都看成一条边，即设\(f[i][j]\)表示 \(i\)个点 \(j\)条边的简单二分图的方案数。
它跟答案之间差了个常数\(x_{m,j}\)——将\(m\)条相互区分的边分配到这 \(j\)个相互区分的边集合，且每个集合不为空的方案数。
注意到第二类斯特林数\(s(i,j)\)表示将 \(i\)个相互区分的球放到 \(j\)个互不区分的盒子的方案数， 则有\(x_{i,j} = s(i,j) \times j!\)。不过其实它可以通过二项式反演得到：设\(y_{m,i}\)意义类似\(x_{m,i}\)，但集合可以为空，有\(y_{m,i} = i^m = \sum_{j=0}^{i}\binom{i}{j}x_{m,j}\)，根据二项式反演即得
这样我们可以在\(O(n^4\log m)\)求出 \(x_{m,i}\)。
注意到一条边\((u,v)\)，我们可以让 \(s_i = u, t_i = v\)，也可以 \(s_i = v, t_i = u\)，因此有两种构造数组的方式，所有还有个 \(2^m\)的系数。
由此 \(ans = \sum_{i=1}^{maxL}2^m f[n][i] \times x(m, i)\)，其中\(maxL\)表示可能的最大的边数，显然是左右点数均分，为\(\lfloor \frac{n}{2} \rfloor \times \lceil \frac{n}{2} \rceil\)
以下考虑如何求\(f[i][j]\)。
注意到二分图是可以将点分成左右两部分，由此可以枚举左边部分点（白色点）的数量\(k\)，注意到点标号不影响结果，因此方案数有 \(i \choose k\)。
然后考虑连边情况，每一条边都是从左边\(k\)个点选一个点，右边 \(i-k\)个点选一个点，然后连边，因此方案数是\(k(n-k) \choose j\)。
但思考会发现上述结果并不是\(f[i][j]\)，注意到一个比较显然的情况，连边并不保证二分图联通，可能会有单独的一个点。在上述方案计算中，我们会分别考虑该点处于左边（染成了白色）和右边的情况，而在 \(f[i][j]\)表示的情况中，应当只考虑一次。进一步的，对于一个有\(k\)个连通块的合法二分图，它对于 \(f[i][j]\)的贡献是 \(1\)，但上述结果计算得来的贡献是 \(2^k\)，因为每个二分图的染色方案有两种。
我们记上述的结果为 \(h[i][j]\)，即 \(i\)个点\(j\)条边的二分图的染色的方案数。注意到上述算重的因素是连通块个数，但从\(h[i][j]\)中难以知晓连通块个数的信息，难以从 \(h[i][j]\)中得到 \(f[i][j]\)。
怎么办呢，注意到关键还是连通块个数的问题，转换需要一个桥梁。我们设\(g[i][j]\)表示 \(i\)个点 \(j\)条边的连通的二分图的染色的方案数。即连通块数为\(1\)的方案数。
\(h\)和 \(g\)的区别仅仅是连通块个数的问题，可以通过容斥得到\(g[i][j]\)。
考虑从\(h[i][j]\)减去不合法的情况，即 \(1\)号点（其实是标号最小的点，\(1\)号点方便理解）的连通块个数不是 \(i\)的情况，通过枚举其点数和边数以及点的标号情况，有\(g[i][j] = h[i][j] - \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i - 1 \choose k - 1\)\(g[k][l] h[i-k][j-l]\)
\(g[i][j]\)是一个连通块的染色方案数，那二分图的方案数就是 \(\frac{g[i][j]}{2}\)。即设 \(a[i][j] = \frac{g[i][j]}{2}\)表示 \(i\)个点 \(j\)条边的连通的二分图的方案数。
\(a\)和 \(f\)的区别仅仅是连通块个数的问题，同 \(h\)和 \(g\)的关系，可以通过容斥得到 \(f[i][j]\)。
同样考虑枚举\(1\)号点所在连通块的点数、边数和点的标号的情况，有\(f[i][j] = \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i-1 \choose k-1\)\(a[k][l] f[i-k][j-l]\)
由此得到\(f[i][j]\)，就能得到答案了。
综上，我们设
- \(f\)表示二分图的方案数
- \(a\)表示连通二分图的方案数
- \(h\)表示二分图染色的方案数
- \(g\)表示连通二分图染色的方案数
然后\(h\)通过枚举染白色的点数量很轻易地求出，由于染色和二分图之间存在关于连通块个数的关系， 需要一个连通（连通块个数为\(1\)）作为桥梁，通过 \(h \to g \to a \to f\)。
- \(h[i][j] = \sum_{k=0}^{i}\binom{i}{k}\binom{k(i-k)}{j}\)
- \(g[i][j] = h[i][j] - \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i - 1 \choose k - 1\)\(g[k][l] h[i-k][j-l]\)
- \(a[i][j] = \frac{g[i][j]}{2}\)
- \(f[i][j] = \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i-1 \choose k-1\)\(a[k][l] f[i-k][j-l]\)
注意初值条件\(f[0][0] = 1\)。
最后再通过一个组合数得到\(ans = \sum_{i=1}^{maxL}2^m f[n][i] \times x_{m, i}\)
其中\(x_{m,i} = \sum_{j=0}^{i}(-1)^{i-j}\binom{i}{j}j^m\)表示将\(m\)个相互区分的球放到 \(i\)个相互区分的盒子，且每个盒子非空的方案数。
总的时间复杂度是\(O(n^6 + n^4\log 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)
const int mo = 998244353;
const int M = 1e3;
LL bin(LL x, LL n, LL MOD) {
LL ret = MOD != 1;
for (x %= MOD; n; n >>= 1, x = x * x % MOD)
if (n & 1)
ret = ret * x % MOD;
return ret;
}
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }
LL invf[M], fac[M] = {1};
void fac_inv_init(LL n, LL p) {
FOR(i, 1, n)
fac[i] = i * fac[i - 1] % p;
invf[n - 1] = bin(fac[n - 1], p - 2, p);
FORD(i, n - 2, -1)
invf[i] = invf[i + 1] * (i + 1) % p;
}
inline LL C(LL n, LL m) { // n >= m >= 0
return n < m || m < 0 ? 0 : fac[n] * invf[m] % mo * invf[n - m] % mo;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fac_inv_init(M, mo);
int n, m;
cin >> n >> m;
int maxL = n / 2 * (n + 1) / 2;
vector<vector<int>> h(n + 1, vector<int>(maxL + 1, 0));
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= maxL; ++j)
for (int k = 0; k <= i; ++k) {
h[i][j] += C(i, k) * C(k * (i - k), j) % mo;
if (h[i][j] >= mo)
h[i][j] -= mo;
}
vector<vector<int>> g(n + 1, vector<int>(maxL + 1, 0));
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= maxL; ++j) {
g[i][j] = h[i][j];
for (int k = 1; k <= i; ++k)
for (int l = 0; l <= j; ++l) {
g[i][j] -=
C(i - 1, k - 1) * g[k][l] % mo * h[i - k][j - l] % mo;
if (g[i][j] < 0)
g[i][j] += mo;
}
}
vector<vector<int>> a(n + 1, vector<int>(maxL + 1, 0));
int inv2 = get_inv(2, mo);
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= maxL; ++j) {
a[i][j] = 1ll * g[i][j] * inv2 % mo;
}
vector<vector<int>> f(n + 1, vector<int>(maxL + 1, 0));
f[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= maxL; ++j)
for (int k = 1; k <= i; ++k)
for (int l = 0; l <= j; ++l) {
f[i][j] +=
C(i - 1, k - 1) * a[k][l] % mo * f[i - k][j - l] % mo;
if (f[i][j] >= mo)
f[i][j] -= mo;
}
vector<int> mm(maxL + 1);
for (int i = 0; i <= maxL; ++i)
mm[i] = bin(i, m, mo);
vector<int> x(maxL + 1);
for (int i = 0; i <= maxL; ++i) {
int sig = 1 - 2 * (i & 1);
for (int j = 0; j <= i; ++j) {
x[i] = (x[i] + C(i, j) * mm[j] % mo * sig) % mo;
if (x[i] < 0)
x[i] += mo;
sig *= -1;
}
}
int ans = 0;
int p2 = bin(2, m, mo);
for (int i = 1; i <= maxL; ++i) {
ans += 1ll * p2 * f[n][i] % mo * x[i] % mo;
if (ans >= mo)
ans -= mo;
}
cout << ans << '\n';
return 0;
}
