AtCoder Beginner Contest 312
A - Chord (abc312 A)
题目大意
给定一个长度为\(3\)的字符串，问是不是ACE, BDF, CEG, DFA, EGB, FAC, GBD中的一个。
解题思路
依次判断即可。
神奇的代码
#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);
set<string> q{"ACE", "BDF", "CEG", "DFA", "EGB", "FAC", "GBD"};
string a;
cin >> a;
if (q.find(a) != q.end()) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
return 0;
}
B - TaK Code (abc312 B)
题目大意
给定一个仅包含#.的二维图案，找出所有符合以下模板的\(9 \times 9\)的子图案。
###.?????
###.?????
###.?????
....?????
?????????
?????....
?????.###
?????.###
?????.###
其中#.必须严格符合，而?随意。
解题思路
数据规模不大，直接枚举\(9 \times 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);
string t = "###.?????"
"###.?????"
"###.?????"
"....?????"
"?????????"
"?????...."
"?????.###"
"?????.###"
"?????.###";
int n, m;
cin >> n >> m;
vector<string> s(n);
for (auto& i : s)
cin >> i;
auto ok = [&](int x, int y) {
for (int i = 0; i < 9; ++i)
for (int j = 0; j < 9; ++j) {
int pos = i * 9 + j;
int nx = x + i, ny = y + j;
if (nx >= n || ny >= m)
return false;
if (t[pos] != '?' && s[nx][ny] != t[pos])
return false;
}
return true;
};
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (ok(i, j))
cout << i + 1 << ' ' << j + 1 << '\n';
return 0;
}
C - Invisible Hand (abc312 C)
题目大意
有\(n\)个售卖者和\(m\)个购买者。
你现在要决定一个最小的价格\(x\)，使得愿意售卖的人数不小于愿意购买的人数。
对于第\(i\)个售卖者，如果 \(x \geq a_i\)，则他愿意售卖。
对于第\(i\)个购买者，如果 \(x \leq b_i\)，则他愿意购买。
解题思路
注意到\(x\)越大，愿意售卖的人会越来越多，愿意购买的人会越来越小，两者均呈现一个单调性，因而愿意售卖人数-愿意购买人数也具有 单调性，而题意就是找零点。因此我们可以二分这个x。
事先对售卖者的\(a_i\)和购买者的\(b_i\)排个序，对于一个\(x\)，可通过二分找到愿意售卖和购买的人数，然后判断是否符合条件即可。
时间复杂度是\(O(\log 10^9 \log nm)\)
神奇的代码
#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(n), b(m);
for (auto& i : a)
cin >> i;
for (auto& i : b)
cin >> i;
int l = -1, r = 1e9 + 1;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
while (l + 1 < r) {
int mid = (l + r) >> 1;
int seller = upper_bound(a.begin(), a.end(), mid) - a.begin();
int buyer = b.end() - lower_bound(b.begin(), b.end(), mid);
if (seller >= buyer)
r = mid;
else
l = mid;
}
cout << r << '\n';
return 0;
}
或许你可以注意到最终答案一定是其中的\(a_i\)或 \(b_i\)，因此可以从小到大枚举这些候选答案，故愿意售卖的人数会越来越多，愿意购买的人数会越来越小，两个双指针维护一下其人数也可以。
D - Count Bracket Sequences (abc312 D)
题目大意
给定一个()?的序列，将其中的?替换成(或)。
问有多少种替换方案，满足替换后的序列符合一个合法的括号序列。
解题思路
要判断一个序列是否是合法的括号序列，就要求从左到右的每个位置，(的数量不少于)的数量，且最后两者数量相等。
因此为了保证方案的合法性，我们在搜索时需要记录此时有多少个(和)，但这样的状态是\(O(n^2)\)，注意到我们实际上并不需要记录括号的对数，只需要保证其差 不小于0，且最后的差等于0，因此我们只需记录两者的差，就可以转移了。
即设\(dp[i][j]\)表示前 \(i\)个字符中，替换 ?后(数量 - )数量 = j的方案数。
根据当前的字符转移即可，如果是?则决定是(还是)。
初始条件就是\(dp[0][0] = 1\)
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int mo = 998244353;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
vector<int> dp(n + 1, 0);
dp[0] = 1;
for (auto& c : s) {
vector<int> dp2(n + 1, 0);
for (int i = 0; i <= n; ++i) {
if (c == '(' && i)
dp2[i] = dp[i - 1];
else if (c == ')' && i != n)
dp2[i] = dp[i + 1];
else if (c == '?') {
if (i)
dp2[i] = dp[i - 1];
if (i != n)
dp2[i] += dp[i + 1];
if (dp2[i] >= mo)
dp2[i] -= mo;
}
}
dp.swap(dp2);
}
cout << dp[0] << '\n';
return 0;
}
E - Tangency of Cuboids (abc312 E)
题目大意
给定\(n\)个没有相交的正方体，对于每个正方体，问它与多少个正方体会有面的相切。
解题思路
考虑正方体面相切的情况，分别为上下切、左右切、前后切，其实分别对应着某一维度的坐标相同。
因此我们分别考虑三个坐标相同的情况。
比如对于同为\(z=1\)的面，我们要判断的就是这个面上的一个正方形与多少个正方形相交。
考虑如何判断正方形相交，或者相离，由于坐标大小只有\(100\)，感觉可以前缀和然后容斥下，但发现貌似非常复杂。
注意到正方形相交的情况，由于题意表示正方体之间没有相交，这意味着在这个平面内，某点最多被两个正方形覆盖（上下相切的话，那么某点被正方形覆盖，只有上正方体和下正方体的两个面），这意味着我们可以直接记录某个位置是被哪个正方形覆盖的，这样通过遍历每个位置，就知道每个位置有哪两个正方形相互覆盖了。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int sz = 101;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<array<int, 6>> p(n);
for (auto& i : p) {
for (auto& j : i)
cin >> j;
}
vector<unordered_set<int>> ans(n);
auto solve = [&](int x, int y, int z) {
array<vector<int>, sz> id;
for (int i = 0; i < n; ++i) {
id[p[i][x]].push_back(i);
id[p[i][x + 3]].push_back(i);
}
for (int Z = 0; Z < sz; ++Z) {
array<array<int, sz>, sz> belong{};
for (auto& i : belong)
fill(i.begin(), i.end(), -1);
for (auto& i : id[Z]) {
for (int X = p[i][y]; X < p[i][y + 3]; ++X)
for (int Y = p[i][z]; Y < p[i][z + 3]; ++Y) {
int& own = belong[X][Y];
if (own != -1) {
ans[own].insert(i);
ans[i].insert(own);
} else {
own = i;
}
}
}
}
};
solve(0, 1, 2);
solve(1, 0, 2);
solve(2, 0, 1);
for (auto& i : ans) {
cout << i.size() << '\n';
}
return 0;
}
F - Cans and Openers (abc312 F)
题目大意
给定\(n\)个物品，物品分三种：
- 普通物品，快乐值 \(x_i\)
- 特殊物品，需要钥匙打开，快乐值 \(x_i\)
- 钥匙物品，可打开\(x_i\) 个特殊物品。
你现在只能拿\(m\)个物品，问最大的快乐值。
解题思路
初看此题，有一些比较显然的性质。
如果规定了只能拿\(a\)个普通物品，那我肯定拿快乐值最大的那 \(a\)个。 同理对于特殊物品、钥匙物品，都是贪心的取最大的那些。
由于\(n\)有 \(10^5\)，注定我们只能枚举一种物品的数量。
可以发现如果考虑枚举取\(a\)个钥匙物品的数量的话，假设这\(a\)个钥匙物品可打开 \(b\)个特殊物品，那剩下的就是从所有普通物品和前 \(b\)大的特殊物品中取快乐值最大的 \(m-a\)个。随着这个 \(a\)的递增，可取的特殊物品的范围越来越大，这意味着我们可以继承上一步的信息，考虑新增的特殊物品是否取即可。
维护一堆物品的前 \(m\)大的和，用一个小根堆的优先队列维护，当新增的物品的快乐值大于堆顶时，且堆大小等于 \(m\)，则丢弃堆顶，将新的放进去。
神奇的代码
#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;
array<vector<int>, 3> items;
for (int i = 0; i < n; ++i) {
int t, x;
cin >> t >> x;
items[t].push_back(x);
}
for (auto& item : items)
sort(item.begin(), item.end(), greater<int>());
priority_queue<int> s;
LL sum = 0;
for (int i = 0; i < items[0].size(); ++i) {
if (s.size() == m)
break;
s.push(-items[0][i]);
sum += items[0][i];
}
LL ans = sum;
int l = 0;
for (auto& i : items[2]) {
--m;
if (m < 0)
break;
int r = l + i;
while (s.size() > m) {
sum += s.top();
s.pop();
}
while (l < r) {
if (l >= items[1].size())
break;
if (s.size() < m) {
sum += items[1][l];
s.push(-items[1][l]);
} else if (-s.top() < items[1][l]) {
sum += s.top();
s.pop();
sum += items[1][l];
s.push(-items[1][l]);
}
++l;
}
ans = max(ans, sum);
}
cout << ans << '\n';
return 0;
}
G - Avoid Straight Line (abc312 G)
题目大意
给定一棵树，问有多少个递增的三元组\((i,j,k)\)，满足不存在一条简单路径覆盖这三个点。
解题思路
首先考虑怎样的三个点不能被一条简单路径覆盖。
树上两点确定唯一一条路径，如果第三点在这条路径上，或者在两点的子树里，则可以存在一条路径覆盖这三个点，其点数就是两个子树大小+路径长度，这两个值都可以通过预处理很快算出来，其补集就是不存在覆盖情况。
但如果枚举这两点的话，复杂度避免不了\(O(n^2)\)，因此只能枚举一个点。
同样考虑枚举这条路径，要么枚举路径最边边的点要么枚举路径的中间点。
可以发现枚举路径的中间点\(u\)时，另外两个点的所在情况只有两种：
- 两个点在\(u\)的两个不同的儿子子树中，这个用类似树形\(dp\)的方式合并求答案即可。
- 一个点在\(u\)的儿子子树 ，另一个点在父亲往上的其余位置。父亲往上的情况数就是总点数减去子树大小。
两种情况累加就是存在简单路径覆盖三个点的情况。
用总情况数(\(\frac{n(n-1)(n-2)}{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 n;
cin >> n;
vector<vector<int>> edge(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
edge[u].push_back(v);
edge[v].push_back(u);
}
LL ans = 0;
vector<int> son(n, 0);
function<void(int, int)> dfs = [&](int u, int fa) {
for (auto& v : edge[u]) {
if (v == fa)
continue;
dfs(v, u);
ans += 1ll * son[u] * son[v];
son[u] += son[v];
}
son[u] += 1;
ans += 1ll * (son[u] - 1) * (n - son[u]);
};
dfs(0, 0);
ans = (1ll * n * (n - 1) * (n - 2) / 6 - ans);
cout << ans << '\n';
return 0;
}
Ex - snukesnuke (abc312 Ex)
题目大意
有\(n\)个人及其名字 \(s_i\)。
但名字可能有重复，为了不重复，你需要依次对每个人的名字操作。
对于第 \(i\)个人的名字，如果它与前面的重复了，你需要决定一个最小的数 \(k\)，使得 \(s_i\)重复 \(k\)次后与前面不重复。
对于每个人，输出 \(k\)的大小。
解题思路
考虑对字符串hash，这样的话重复操作相当于hash的一个简单四则运算（乘以一个关于长度的基底+原字符串hash值）。
然后我们记录哪些hash值出现过，暴力做貌似最坏会\(O(n^2)\) ，就像样例\(3\)的五个 x。究其原因是我们经过了很多次的x -> xx -> xxx这样重复的变换了，为了不重复，我们可以把这样的信息记录下来，即记录某个hash值因冲突而被重复的最高次数，或许就能\(O(\text{能过})\)?
写了写发现过了，朴素的自然hash也没被卡。细想一下复杂度貌似确实是\(O(n)\)的，考虑每个字符串被后面字符串考虑是否冲突的次数，会发现最多只有一次，即在因冲突而进行重复操作后，之后因为记录了最高重复次数，所以之后考虑时就不再会考虑这个字符串了。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const int x = 135;
const int N = 2e5 + 10;
ULL xp[N];
void init_xp() {
xp[0] = 1;
for (int i = 1; i < N; ++i) {
xp[i] = xp[i - 1] * x;
}
}
ULL hash_string(const string& s) {
int l = s.size();
ULL val = 0;
for (int j = l - 1; j >= 0; --j) {
val = val * x + s[j];
}
return val;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init_xp();
int n;
cin >> n;
unordered_set<ULL> name;
unordered_map<ULL, int> k;
unordered_map<ULL, ULL> khash;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
ULL val = hash_string(s);
ULL cur = val;
int ans = 0;
if (name.find(val) == name.end()) {
ans = 1;
} else {
if (k.find(val) == k.end())
ans = 1;
else {
ans = k[val];
cur = khash[val];
}
while (name.find(cur) != name.end()) {
cur = cur * xp[s.size()] + val;
++ans;
}
}
k[val] = ans;
khash[val] = cur;
name.insert(cur);
cout << ans << " \n"[i == n - 1];
}
return 0;
}
