A - Wrong Answer (abc343 A)
题目大意
给定\(a,b\)，输出 \(c\)，使得 \(a+b \neq c\)
解题思路
从\(0\)开始枚举\(c\)的取值即可。
神奇的代码
#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 a, b;
cin >> a >> b;
int ans = 0;
while (ans == a + b)
++ans;
cout << ans << '\n';
return 0;
}
B - Adjacency Matrix (abc343 B)
题目大意
给定一个邻接矩阵，对于第\(i\)个点，输出与之有连边的点的编号，升序。
解题思路
即输出第\(i\)行中值为 \(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;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int x;
cin >> x;
if (x)
cout << j + 1 << " ";
}
cout << '\n';
}
return 0;
}
C - 343 (abc343 C)
题目大意
给定一个数\(n\)，问不超过 \(n\)的最大的数 \(x\)，其是回文数，且是某个数\(y\)的三次方。
解题思路
我们可以枚举\(y\)而不是 \(x\)，这样得到的 \(x=y^3\)就一定是个三次方数，剩下的就是判断 \(x\)是不是回文数。
\(n\)只有 \(10^{18}\)，对应的\(y\)的范围就只有\(10^6\)，判断回文数的复杂度是 \(O(\log )\)，因此直接枚举判断即可。
判断回文数可以直接用 to_string转换成字符串然后对应位比较。
神奇的代码
#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;
int up = 1e6;
LL ans = 0;
for (int i = 1; i <= up; ++i) {
LL x = 1ll * i * i * i;
if (x > n)
break;
string s = to_string(x);
bool ok = true;
int len = s.size();
for (int i = 0; i < len; ++i) {
ok &= s[i] == s[len - i - 1];
}
if (ok) {
ans = x;
}
}
cout << ans << '\n';
return 0;
}
D - Diversity of Scores (abc343 D)
题目大意
初始\(n\)个人都是 \(0\)分。
第\(i\)个时刻，第 \(a_i\)个人分数增加 \(b_i\) 。
问每个时刻后，不同分数的个数。
解题思路
用map维护每个数出现的次数，当其次数减为\(0\)的就删去该元素。
每个时刻的答案就是 map的元素个数。
神奇的代码
#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, t;
cin >> n >> t;
map<LL, int> cnt;
vector<LL> score(n);
cnt[0] = n;
for (int i = 0; i < t; ++i) {
int a, b;
cin >> a >> b;
--a;
cnt[score[a]]--;
if (cnt[score[a]] == 0)
cnt.erase(score[a]);
score[a] += b;
cnt[score[a]]++;
cout << cnt.size() << '\n';
}
return 0;
}
E - 7x7x7 (abc343 E)
题目大意
三维坐标，三个\(7 \times 7 \times 7\)的方块放置。
给定 \(v1,v2,v3\)，要求
- 恰好属于一个方块的体积是 \(v1\)。
- 恰好属于两个方块的体积是 \(v2\)。
- 恰好属于三个方块的体积是 \(v3\)。
输出任意一种摆放方式。
解题思路
由于数都不大，考虑直接枚举。
由于空间的平移不变形，第一个方块放置位置可以是\((0,0,0)\)。
考虑枚举第二个和第三个的方块，其坐标范围则是\([-7,7]\)。再远的地方和 \(-7,7\)的放置效果是一样的。
花\(O(2^6 7^6)\)枚举三个方块位置后，要求\(v1,v2,v3\)，再花\(O(2^3 7^3)\)统计的话总复杂度就是 \(10^{10}\)，会超时了。
考虑 \(v3\)怎么求，其实这跟求两个线段的交线长度、两个矩形的相交面积一样，分别考虑每一维的交线长度，即右端点的最小值 \(-\)左端点的最大值，然后三维长度乘起来就是相交体积。
\(v2\)就是俩俩相交，再减去 \(v3\)对应的部分。
\(v1\)就是所有体积加起来，减去 \(v2\)和 \(v3\)对应的部分。
这样就可以\(O(1)\)判断，最终的时间复杂度是 \(O(2^6 7^6)\)。
神奇的代码
#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 v1, v2, v3;
cin >> v1 >> v2 >> v3;
array<array<int, 3>, 3> a;
a[0] = {0, 0, 0};
constexpr int len = 7;
constexpr int sz = 4 * len;
array<array<array<int, sz>, sz>, sz> cnt{};
for (int i = 0; i < len; ++i) {
for (int j = 0; j < len; ++j) {
for (int k = 0; k < len; ++k) {
cnt[i][j][k]++;
}
}
}
auto calc = [&](auto& cnt) {
array<int, 4> tmp{};
for (auto& i : cnt)
for (auto& j : i)
for (auto& k : j) {
tmp[k]++;
}
return tmp;
};
auto calc3 = [&](int i, int j, int k, int l, int m, int n, int o, int p,
int q) {
int a = max(0, min({i + len, l + len, o + len}) - max({i, l, o}));
int b = max(0, min({j + len, m + len, p + len}) - max({j, m, p}));
int c = max(0, min({k + len, n + len, q + len}) - max({k, n, q}));
return a * b * c;
};
auto calc2 = [&](int i, int j, int k, int l, int m, int n) {
int a = max(0, min(i + len, l + len) - max(i, l));
int b = max(0, min(j + len, m + len) - max(j, m));
int c = max(0, min(k + len, n + len) - max(k, n));
return a * b * c;
};
auto solve = [&]() {
for (int i = -len; i <= len; ++i) {
for (int j = -len; j <= len; ++j) {
for (int k = -len; k <= len; ++k) {
for (int l = -len; l <= len; ++l) {
for (int m = -len; m <= len; ++m) {
for (int n = -len; n <= len; ++n) {
int n3 = calc3(0, 0, 0, i, j, k, l, m, n);
int n2 = calc2(0, 0, 0, i, j, k) +
calc2(0, 0, 0, l, m, n) +
calc2(i, j, k, l, m, n) - 3 * n3;
int n1 = 3 * len * len * len - n2 * 2 - n3 * 3;
if (n1 == v1 && n2 == v2 && n3 == v3) {
a[1] = {i, j, k};
a[2] = {l, m, n};
return true;
}
}
}
}
}
}
}
return false;
};
if (solve()) {
cout << "Yes" << '\n';
for (auto& i : a)
for (auto& j : i)
cout << j << ' ';
cout << '\n';
} else
cout << "No" << '\n';
return 0;
}
F - Second Largest Query (abc343 F)
题目大意
\(n\)个数\(a_i\)， \(q\)个询问 ，分两种：
1 p x，将\(a_p = x\)2 l r，问\(a_{l..r}\)的次大值的出现次数，
解题思路
可以考虑带修莫队，但貌似会超时。
注意到次大值的出现次数这信息是可合并的，即两个区间的这一信息，可以合并起来，得到更大区间的这一信息。
因此用线段树维护这一信息即可，对应的是单点修改和区间查询。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e5 + 8;
class segment {
#define lson (root << 1)
#define rson (root << 1 | 1)
public:
array<int, 2> max[N << 2];
array<int, 2> cmax[N << 2];
void pushup(int root) {
array<array<int, 2>, 4> tmp = {max[lson], max[rson], cmax[lson],
cmax[rson]};
map<int, int> cnt;
for (auto& x : tmp) {
cnt[x[0]] += x[1];
}
max[root] = {cnt.rbegin()->first, cnt.rbegin()->second};
cmax[root] = {0, 0};
cnt.erase(cnt.rbegin()->first);
if (!cnt.empty())
cmax[root] = {cnt.rbegin()->first, cnt.rbegin()->second};
}
array<array<int, 2>, 2> combine(array<array<int, 2>, 2> a,
array<array<int, 2>, 2> b) {
array<array<int, 2>, 4> tmp = {a[0], a[1], b[0], b[1]};
map<int, int> cnt;
for (auto& x : tmp) {
cnt[x[0]] += x[1];
}
array<array<int, 2>, 2> ret;
ret[0] = {cnt.rbegin()->first, cnt.rbegin()->second};
ret[1] = {0, 0};
cnt.erase(cnt.rbegin()->first);
if (!cnt.empty())
ret[1] = {cnt.rbegin()->first, cnt.rbegin()->second};
return ret;
}
void build(int root, int l, int r, vector<int>& a) {
if (l == r) {
max[root] = {a[l - 1], 1};
cmax[root] = {0, 0};
return;
}
int mid = (l + r) >> 1;
build(lson, l, mid, a);
build(rson, mid + 1, r, a);
pushup(root);
}
void update(int root, int l, int r, int pos, int val) {
if (l == r) {
max[root] = {val, 1};
cmax[root] = {0, 0};
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(lson, l, mid, pos, val);
else
update(rson, mid + 1, r, pos, val);
pushup(root);
}
array<array<int, 2>, 2> query(int root, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return {max[root], cmax[root]};
}
int mid = (l + r) >> 1;
array<array<int, 2>, 2> lret = {{{0, 0}, {0, 0}}},
rret = {{{0, 0}, {0, 0}}};
if (L <= mid)
lret = query(lson, l, mid, L, R);
if (R > mid)
rret = query(rson, mid + 1, r, L, R);
return combine(lret, rret);
}
} sg;
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& x : a)
cin >> x;
sg.build(1, 1, n, a);
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
sg.update(1, 1, n, x, y);
} else {
auto ret = sg.query(1, 1, n, x, y);
cout << ret[1][1] << '\n';
}
}
return 0;
}
G - Compress Strings (abc343 G)
题目大意
给定\(n\)个字符串，问最小长度的字符串，使得这 \(n\)个字符串都是该串的子串。
解题思路
注意到\(n\)只有 \(20\)。
考虑最朴素的做法，就是花\(O(n!)\)枚举这\(n\)个字符串的顺序，然后再把俩俩相邻的字符串中，重复的部分（最长前后缀）删去，得到一个字符串。所有这样的字符串长度取个最小值则为答案，
但还是有点小问题，在原来的\(n\)个字符串中，对于相同的字符串，我们肯定只保留一个，而对于子串的情况，该子串也不需要。因此得事先预处理，将相同串和子串的都去掉，可以用hash的方法在\(O(n^210^5)\)内做到。
考虑优化这个朴素做法，容易发现，当确定了前 \(i\)个字符串的顺序后， 对于第\(i+1\)个字符串取什么，使得拼接字符串的长度所造成的影响，只取决于第 \(i\)个字符串是什么，对于前面的字符串的顺序怎样没关系。
因此我们不必保留前 \(i\)个字符串的顺序 这一信息，只需知道我取了哪些字符串，且第 \(i\)个字符串是什么。通过这两个信息，我就可以进行转移：即选择哪个还未取的字符串，以及取了之后最终长度是多少。
因此设\(dp[i][j]\)表示我取的字符串的二进制表示为 \(i\) ，最后一个字符串是\(j\)的最小长度。
事先花\(O(n^2 10^5)\)预处理 \(cost[i][j]\)表示字符串 \(i\)（左）和字符串 \(j\)（右）拼接起来 后增加的长度（枚举前后缀长度，再hash判断是否相等）。这样转移时枚举下一个字符串后，就可以\(O(1)\)得到代价。因此转移的复杂度是 \(O(n)\)。
总的时间复杂度是 \(O(n^2 2^n)\)
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
typedef long long LL;
typedef unsigned long long ULL;
const int x = 135;
const int N = 2e5 + 10;
const int p1 = 1e9 + 7, p2 = 1e9 + 9;
ULL xp1[N], xp2[N], xp[N];
void init_xp() {
xp1[0] = xp2[0] = xp[0] = 1;
for (int i = 1; i < N; ++i) {
xp1[i] = xp1[i - 1] * x % p1;
xp2[i] = xp2[i - 1] * x % p2;
xp[i] = xp[i - 1] * x;
}
}
struct String {
char s[N];
int length, subsize;
bool sorted;
ULL h[N], hl[N];
ULL hash() {
length = strlen(s);
ULL res1 = 0, res2 = 0;
h[length] = 0; // ATTENTION!
for (int j = length - 1; j >= 0; --j) {
#ifdef ENABLE_DOUBLE_HASH
res1 = (res1 * x + s[j]) % p1;
res2 = (res2 * x + s[j]) % p2;
h[j] = (res1 << 32) | res2;
#else
res1 = res1 * x + s[j];
h[j] = res1;
#endif
// printf("%llu\n", h[j]);
}
return h[0];
}
// 获取子串哈希，左闭右开区间
ULL get_substring_hash(int left, int right) const {
int len = right - left;
#ifdef ENABLE_DOUBLE_HASH
// get hash of s[left...right-1]
unsigned int mask32 = ~(0u);
ULL left1 = h[left] >> 32, right1 = h[right] >> 32;
ULL left2 = h[left] & mask32, right2 = h[right] & mask32;
return (((left1 - right1 * xp1[len] % p1 + p1) % p1) << 32) |
(((left2 - right2 * xp2[len] % p2 + p2) % p2));
#else
return h[left] - h[right] * xp[len];
#endif
}
void get_all_subs_hash(int sublen) {
subsize = length - sublen + 1;
for (int i = 0; i < subsize; ++i)
hl[i] = get_substring_hash(i, i + sublen);
sorted = 0;
}
void sort_substring_hash() {
sort(hl, hl + subsize);
sorted = 1;
}
bool match(ULL key) const {
if (!sorted)
assert(0);
if (!subsize)
return false;
return binary_search(hl, hl + subsize, key);
}
void init(const char* t) {
length = strlen(t);
strcpy(s, t);
}
};
const int inf = 1e9;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init_xp();
int n;
cin >> n;
vector<String> s(n);
for (auto& i : s) {
string x;
cin >> x;
i.init(x.c_str());
i.hash();
}
vector<String> t;
vector<int> sub(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j || sub[j])
continue;
if (s[i].length > s[j].length)
continue;
s[j].get_all_subs_hash(s[i].length);
s[j].sort_substring_hash();
if (s[j].match(s[i].h[0])) {
sub[i] = true;
break;
}
}
if (!sub[i])
t.push_back(s[i]);
}
n = t.size();
int up = (1 << n);
vector<vector<int>> dp(up, vector<int>(n, inf));
dp[0][0] = 0;
auto calc = [&](int i, int j) {
int ans = min(t[i].length, t[j].length);
while (ans > 0 &&
t[i].get_substring_hash(t[i].length - ans, t[i].length) !=
t[j].get_substring_hash(0, ans))
--ans;
return t[j].length - ans;
};
vector<vector<int>> cost(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j)
continue;
cost[i][j] = calc(i, j);
}
}
for (int i = 0; i < n; ++i)
dp[1 << i][i] = t[i].length;
for (int i = 0; i < up; ++i) {
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) {
for (int k = 0; k < n; ++k) {
if (j != k && i & (1 << k)) {
dp[i][j] =
min(dp[i][j], dp[i ^ (1 << j)][k] + cost[k][j]);
}
}
}
}
}
cout << ranges::min(dp.back()) << '\n';
return 0;
}