AtCoder Beginner Contest 336
A - Long Loong (abc336 A)
题目大意
给定一个数\(n\)，将 long中的o重复\(n\)次后输出。
解题思路
模拟即可。
神奇的代码
#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;
cout << "L" << string(n, 'o') << "ng" << '\n';
return 0;
}
B - CTZ (abc336 B)
题目大意
给定一个数\(n\)，问 \(n\)的二进制表示下的末尾零的数量。
解题思路
即找到最小的\(i\)使得 \(n & (1 << i)\) 不为零的位置。枚举即可。
或者直接用内置函数 __builtin_ctz。（count tail zero?
神奇的代码
#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;
cin >> x;
cout << __builtin_ctz(x) << '\n';
return 0;
}
C - Even Digits (abc336 C)
题目大意
定义一个数种类，每个数位都是偶数。
给定\(n\)，问第 \(n\)大的数。
解题思路
每一位的取值只有0,2,4,6,8五种，其实就是一个5进制的转换，再将每个数位乘以\(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);
LL n;
cin >> n;
--n;
string ans;
while (n) {
ans += (n % 5) * 2 + '0';
n /= 5;
}
reverse(ans.begin(), ans.end());
if (ans.empty())
ans = "0";
cout << ans << '\n';
return 0;
}
D - Pyramid (abc336 D)
题目大意
给定一个数组\(a\)，求经过以下操作可以得到的最长的金字塔序列。
金字塔序列形如\(1,2,3,4,5,...,k-1,k,k-1,...,5,4,3,2,1\)。
可进行的操作为：
- 将某数减1
- 将开头或末尾的数移除
解题思路
考虑这个金字塔序列的特点，如果选择中间最高点的\(k\)的位置，以及 \(k\)的值，那剩下的就是看从该位置左右延伸，是否都不小于对应的值。但这复杂度是 \(O(n^3)\)，不大行。
注意到金字塔序列是一个对称的，可以考虑 \(1\)的位置，然后看看能往左和往右延伸到多远。那最后再枚举左边的 \(1\)的位置和右边 \(1\)的位置， 看看它们往右和往左延伸的距离能不能覆盖这两个\(1\)之间的值。
考虑如何求从 \(a_i\)往右能延伸多远，假设能延伸到\(a_j\)，就要要求这期间的 \(a_k\)都满足 \(a_k \leq k - i + 1\)。朴素求法是 \(O(n^2)\)。但注意到一个性质，比如 \(a_i\)能延伸到 \(a_j\)，那 \(a_{i+1}\)至少也会延伸到 \(a_{j}\)，因为原本在\(a_i\)为起点时，\(k \in [i,j]\)需要满足 \(a_k \leq k - i + 1\)， 而以\(a_{i+1}\)为起点时需要满足的是 \(a_k \leq k - i\) ，条件更松了，之前满足的也肯定满足，因此求\(a_{i+1}\)时直接从上次的 \(a_j\)继续往右延伸即可，而不必重新从\(a_{i+1}\)开始求 。即双指针的求法，复杂度是\(O(n)\)。
往左和往右的求法是一样的，当求出从 \(a_i\)往左和往右延伸的最远距离 \(l_i\)和 \(r_i\)后，如果枚举两个 \(1\)的位置判断，那还是 \(O(n^2)\)不行。但容易发现这个也可以用双指针的方法枚举两个 \(1\)的位置。因此时间复杂度就是 \(O(n)\)。
注意金字塔序列的长度是奇数。
神奇的代码
#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> a(n);
for (auto& x : a)
cin >> x;
auto solve = [&](vector<int>& a) {
vector<int> pos(n);
int l = 0;
for (int i = 0; i < n; ++i) {
while (l < i && a[i] <= i - l) {
pos[l] = i - l;
++l;
}
}
while (l < n) {
pos[l] = n - l;
++l;
}
return pos;
};
auto r = solve(a);
ranges::reverse(a);
auto l = solve(a);
int ans = 0;
ranges::reverse(l);
int R = 0;
for (int L = 0; L < n; ++L) {
while (R < n && r[L] + l[R] >= R - L + 1) {
if ((R - L + 1) & 1)
ans = max(ans, (R - L + 1) / 2 + 1);
++R;
}
}
cout << ans << '\n';
return 0;
}
E - Digit Sum Divisible (abc336 E)
题目大意
给定\(n\)，问 \(1 \sim n\)中，能被自己的数位和整除的数的个数。
解题思路
\(n\)有 \(10^{14}\)，显然不能枚举求。
对能整除的数的计数，可以从高位到低位一位一位地考虑，只要知道高位对除数的取余结果，就可以决定低位的取值，进而知道取余的结果变为多少，最后看是否为 \(0\)来判断是不是整除。即一个经典的数位\(dp\)的形式。
但棘手的是 除数不是固定的，它是由一个数的数位和决定，在一般的数位\(dp\)过程中，其数位和会变化，即除数会变化，这就导致余数不能求得，进而最后的能否整除就难以判断。
但注意到数位和的范围不大，它只有\([1,9\times 14]\)，可以考虑枚举数位和\(sum\)， 那剩下的就是求：数位和是\(sum\)，且对\(sum\) 取余结果为\(0\)的值的数的个数。
这两个都是常规条件，数位\(dp\)即可解决。
时间复杂度为\(O((10\log n)^4)\)
数位\(dp\)就考虑递归的形式，从高位到低位考虑每一位的取值，记录中间状态有：当前考虑的位数，取值是否受\(n\)的限制，高位的取余结果，已经填的高位的数位和（下述代码里是低位需要的数位和，反了过来）。然后记忆化一下。记忆化的数组\(dp[pos][mod][sum]\)可以理解成：已经填了\(pos\)的高位，其取余结果为 \(mod\)，数位和为 \(sum\)时，低位的全部填法中，满足题目要求（取余为\(0\)和数位和）的填法数量。
有时候 \(dp\)数组会加一维 \(limit\)，这个可有可无， 没有的话就这部分会重复求解，但因为数量不多，所以不会太费时间。有的话就可能会更快，但会费点空间。
神奇的代码
#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;
cin >> n;
vector<int> s;
while (n) {
s.push_back(n % 10);
n /= 10;
}
ranges::reverse(s);
LL ans = 0;
int maxsum = 9 * min(14ul, s.size());
vector<vector<vector<LL>>> dp(
s.size(), vector<vector<LL>>(maxsum + 1, vector<LL>(maxsum + 1, -1)));
auto solve = [&](auto self, int pos, int limit, int mod, int sum,
int div) -> LL {
if (sum < 0)
return 0ll;
if (pos == s.size())
return LL(mod == 0 && sum == 0);
if (!limit && dp[pos][mod][sum] != -1)
return dp[pos][mod][sum];
int up = (limit ? s[pos] : 9);
LL ret = 0;
for (int i = 0; i <= up; ++i) {
ret += self(self, pos + 1, limit && i == up, (mod * 10 + i) % div,
sum - i, div);
}
if (!limit)
dp[pos][mod][sum] = ret;
return ret;
};
for (int i = 1; i <= maxsum; ++i) {
for (auto& i : dp)
for (auto& j : i)
ranges::fill(j, -1);
auto ret = solve(solve, 0, 1, 0, i, i);
ans += ret;
}
cout << ans << '\n';
return 0;
}
F - Rotation Puzzle (abc336 F)
题目大意
给定一个\(h \times w\)的矩阵，\([1,h\times w]\)的恰好填了一次。
问能否经过不超过 \(20\)次操作，使得矩阵变成一个正常的矩阵，即\((i,j)\)上的数是 \(((i-1) \times w + j)\)。若可，输出最小的操作次数。
操作为：选定一个 \((h-1) \times (w-1)\) 的子矩阵，旋转\(180\)度。
解题思路
注意到只有\(4\)个子矩阵，那每次操作其实只有 \(4\)种选择，直接\(BFS\)的复杂度是 \(O(4^20)\)，即 \(O(2^40)\)。
注意到这是个非常特别的复杂度，它的一半即 \(O(2^20)\)是可做的。
注意到起始局面和终点局面都是已知的，且操作都是可逆的。因此可以从起点和终点分别$BFS$10步， 然后看搜得的局面是否有交集，取步数和最小值即可。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int inf = 1e9;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int h, w;
cin >> h >> w;
vector<vector<int>> a(h, vector<int>(w));
for (auto& i : a)
for (auto& j : i)
cin >> j;
vector<vector<int>> b(h, vector<int>(w));
for (int i = 0, cnt = 1; i < h; ++i)
for (int j = 0; j < w; ++j) {
b[i][j] = cnt;
cnt++;
}
auto tr = [&](vector<vector<int>>& st, int x, int y) {
auto ret = st;
for (int i = x; i < x + h - 1; ++i)
for (int j = y; j < y + w - 1; ++j) {
ret[i][j] = st[h - 2 - (i - x) + x][w - 2 - (j - y) + y];
}
return ret;
};
auto BFS = [&](vector<vector<int>>& st, int up) {
map<vector<vector<int>>, int> dis;
queue<vector<vector<int>>> team;
team.push(st);
dis[st] = 0;
while (!team.empty()) {
auto u = team.front();
team.pop();
if (dis[u] == up)
break;
for (int i = 0; i <= 1; ++i)
for (int j = 0; j <= 1; ++j) {
auto v = tr(u, i, j);
if (dis.count(v))
continue;
dis[v] = dis[u] + 1;
team.push(v);
}
}
return dis;
};
auto sol1 = BFS(a, 10);
auto sol2 = BFS(b, 10);
int ans = inf;
for (auto& [tu, dis] : sol1) {
if (sol2.count(tu)) {
ans = min(ans, dis + sol2[tu]);
}
}
if (ans == inf)
ans = -1;
cout << ans << '\n';
return 0;
}
G - 16 Integers (abc336 G)
题目大意
给定\(16\)个数 \(x_{i,j,k,l}\)。
设\(n\)为这 \(16\)个数的和。
问一个长度为 \(n+3\)的\(01\)数组\(a\)的数量，满足以下条件：
- 对于每一个数 \(x_{i,j,k,l}\)，数组\(a\)中恰好有 \(x_{i,j,k,l}\)个下标\(s\)满足：\(a_s = i, a_{s+1} = j, a_{s + 2}=k, a_{s+3}=l\)
解题思路
感觉是个神仙题，以后再来探索吧
神奇的代码
