AtCoder Beginner Contest 318
咕咕咕，总力战还没打，凹不过卷狗，躺了.jpg
A - Full Moon (abc318 A)
题目大意
给定\(n, m, p\)，问有多少个 \(i\)满足 \(0 < m+pi \leq n\)
解题思路
减去初始的\(m\)，剩下的就是看 \(p\)的倍数个数。
神奇的代码
#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, p;
cin >> n >> m >> p;
cout << (n - m) / p + (n >= m) << '\n';
return 0;
}
B - Overlapping sheets (abc318 B)
题目大意
一个二维空间，有\(n\)个矩形覆盖。
问有多大的空间被覆盖了。重复覆盖算一次。
解题思路
空间大小只有\(100\)，矩形只有 \(100\)，对每个矩形直接 \(O(100^2)\)更新格子的覆盖情况，最后统计被覆盖的个数即可。
时间复杂度为 \(O(100^3)\)。
神奇的代码
#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;
array<array<int, 101>, 101> tu{};
while (n--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
for (int i = a; i < b; ++i)
fill(tu[i].begin() + c, tu[i].begin() + d, 1);
}
int ans = 0;
for (auto& i : tu)
ans += count(i.begin(), i.end(), 1);
cout << ans << '\n';
return 0;
}
C - Blue Spring (abc318 C)
题目大意
\(n\)天旅行，第 \(i\)天旅行花费 \(f_i\)元。
你可以购买一日游券，可以免去任意一天的旅游费用。
但是一日游券是捆绑售卖的，你需要花 \(p\)元买 \(d\)张 一日游券。这意味着你可以免去任意\(d\)天的旅游费用。你可以购买多次，最后一日游券可以剩余。
问旅游完 \(n\)天所需要的最小费用。
解题思路
假设我购买了\(x\)张一日游券，我肯定是免去旅游费用最高的那 \(x\)天的费用。
那就直接枚举买多少次一日游券，用于免去最高的旅游费用，然后其费用与剩余天数的费用相加求个最小值即可。
神奇的代码
#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, d, p;
cin >> n >> d >> p;
vector<int> f(n);
for (auto& i : f)
cin >> i;
sort(f.begin(), f.end(), greater<int>());
LL sum = accumulate(f.begin(), f.end(), 0ll);
LL ans = sum;
for (int i = 0; i < n; i += d) {
for (int j = i; j < min(n, i + d); ++j)
sum -= f[j];
sum += p;
ans = min(ans, sum);
}
cout << ans << '\n';
return 0;
}
D - General Weighted Max Matching (abc318 D)
题目大意
给定一张无向图，边有边权。要求选择一些边，最大化边权和，使得每条边的顶点不重复。
解题思路
点数只有\(16\)，考虑到每条边的顶点不能重复，那么当我们考虑某条边能不能选时，必须得知道目前已经选了哪些点，以决定这条边能不能选，因此设 \(dp[i]\)表示选择的点的情况是 \(i\)（二进制压缩的状态，0表示不选，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;
vector<vector<int>> edge(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
int x;
cin >> x;
edge[i].push_back(x);
}
}
vector<LL> dp((1 << n), 0);
for (int i = 0; i < (1 << n); ++i) {
for (int j = 0; j < n; ++j) {
if ((~i >> j) & 1)
continue;
for (int k = j + 1; k < n; ++k) {
if ((~i >> k) & 1)
continue;
int w = edge[j][k - j - 1];
dp[i] = max(dp[i], dp[i ^ (1 << j) ^ (1 << k)] + w);
}
}
}
cout << *max_element(dp.begin(), dp.end()) << '\n';
return 0;
}
E - Sandwiches (abc318 E)
题目大意
给定一个\(n\)个数的数组 \(a\)，问有多少个 \((i, j, k)\)，满足
- \(i < j < k\)
- \(a_i = a_k\)
- \(a_i \neq a_k\)
解题思路
由于数有\(10^5\)，我们只能枚举其中一个。要么枚举 \(i\)要么枚举 \(j\)。分别考虑后发现枚举 \(j\)简单一点。
如果枚举下标\(i\)会发现比较难计算，对于当前的 \(a_i\)，那么对于之后的每个 \(a_k\)都要考虑它们之间的其他数的个数，感觉复杂度会比较大。
考虑枚举下标\(j\)，剩下的就是考虑 \(j\)左边和 \(j\)右边的相同数。这个\(j\)对答案的贡献就是 \(\sum_{x \neq a_j} l_{x} \times r_{x}\)，其中 \(l_x\)表示 \(j\)左边 \(x\)（是值，不是下标）的个数， \(r_x\)就是右边的 \(x\)的个数。
考虑当 \(j\)移动时，只有 \(a_j\)和 \(a_{j + 1}\)这两个数的个数发生变化。因此我们事先维护 \(\sum\)的值，\(\sum - l_{a_j} \times r_{a_j}\)就是此时的 \(j\)对答案的贡献。转移时通过加减那两个数的贡献，就得到 \(j\)移动到下一个数时的 \(\sum\)的值。然后累计就是答案了。
神奇的代码
#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);
vector<int> l(n, 0), r(n, 0);
for (auto& i : a) {
cin >> i;
--i;
r[i]++;
}
LL ans = 0;
LL tmp = 0;
for (int i = 0; i < n; ++i) {
tmp -= 1ll * l[a[i]] * r[a[i]];
r[a[i]]--;
ans += tmp;
l[a[i]]++;
tmp += 1ll * l[a[i]] * r[a[i]];
}
cout << ans << '\n';
return 0;
}
F - Octopus (abc318 F)
题目大意
给定\(n\)个宝藏的位置，以及\(n\)只长度为 \(l_i\)的手。你要求合法的位置的个数。
一个位置\(x\)合法，意味着你可以用\(n\)只手拿到 \(n\)个宝藏。一只手只能拿一个宝藏，且拿的范围为 \([x - l_i, x + l_i]\)。
解题思路
考虑合法位置的情况，分三种，最左边，最右边，以及两个宝藏之间。
然后考虑最左边的种类，很显然，我们对手的长度进行从小到大排序，那就根据宝藏的坐标从小到大分配手。即对于第\(i\)个宝藏，分配的是长度为 \(l_i\)的手，那么能够及该宝藏的最左边的距离就是 \(x_i - l_i\)，对该距离取个最大值，就是最左边的合法位置了。
然后考虑这个合法位置不断往右边移动，在到达第一个宝藏的位置前都是合法位置。
然后合法位置到了第一个宝藏和第二个宝藏之间。考虑在这区间移动，我们的手分配宝藏的方案是不变的，直到第二个宝藏距离当前位置比第一个位置更近时，分配方案才发生变化，需要重新计算。
注意到需要重新计算的情况，是宝藏距离当前位置的排名发生了变化，因此手分配宝藏的方案需要改变，重新计算当前位置的合法性。而排名发生变化的位置被称为关键位置。
考虑这些关键位置在哪，既然是排名发生变化，那就是在某两个宝藏的中点，因此枚举左右两边宝藏，求个中点就能得到这些关键位置，注意到关键位置的数量只有\(O(n^2)\)个。
对于每个关键位置，重新计算下各个宝藏到该位置的距离，然后排个序分配手，在区间[当前关键位置，下一个关键位置-1]，其手的分配方案都不变，此时对于左边的宝藏，会有一个最小值 \(L = x_i + l_i\)，而对于右边的宝藏，会有个最大值 \(R = x_i - l_i\)，这之间的[R, L]就是合法位置的区间。
因此对所有这样的关键位置累计\(L - R + 1\)的值就是答案。总的时间复杂度是 \(O(n^3 \log 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<LL> x(n), l(n);
for (auto& i : x)
cin >> i;
for (auto& i : l)
cin >> i;
LL ans = 0;
LL L = numeric_limits<LL>::min(), R = numeric_limits<LL>::max();
for (int i = 0; i < n; ++i) {
L = max(L, x[i] - l[i]);
R = min(R, x[i] + l[n - i - 1]);
}
ans += max(0ll, x[0] - L);
ans += max(0ll, R - x[n - 1] + 1);
vector<int> id(n);
vector<int> rk(n);
iota(id.begin(), id.end(), 0);
for (int i = 0; i < n - 1; ++i) {
vector<LL> div{x[i]};
for (int j = 0; j <= i; ++j) {
for (int k = i + 1; k < n; ++k) {
LL mid = (x[j] + x[k] + 1) / 2;
if (mid > x[i] && mid < x[i + 1])
div.push_back(mid);
}
}
sort(div.begin(), div.end());
div.push_back(x[i + 1]);
for (int k = 0; k < div.size() - 1; ++k) {
LL mid = div[k];
vector<LL> pos(n);
for (int j = 0; j < n; ++j) {
pos[j] = abs(x[j] - mid);
}
sort(id.begin(), id.end(), [&](int a, int b) {
if (pos[a] != pos[b])
return pos[a] < pos[b];
else
return a > b;
});
for (int j = 0; j < n; ++j)
rk[id[j]] = j;
L = div[k + 1] - 1, R = div[k];
for (int j = 0; j <= i; ++j) {
L = min(L, x[j] + l[rk[j]]);
}
for (int j = i + 1; j < n; ++j)
R = max(R, x[j] - l[rk[j]]);
ans += max(0ll, L - R + 1);
}
}
cout << ans << '\n';
return 0;
}
其实上面想复杂了（其实写也写复杂了，其实可以直接\(O(n^2)\)，枚举宝藏求中点，然后遍历所有关键点，上述这么写是因为当时考虑的每两个宝藏之间的情况，所以就一段一段的），不过是一个很朴素的从特殊位置开始的思路。
还是考虑关键位置，这个关键位置可以是两个宝藏的中点，它们的距离排名发生了变化；也可以是某个宝藏使用某只手的极限位置（即\(x_i - l_j\)和\(x_i + l_j\)，以这些极限距离作为分割点\(div_i\)，分别考虑每个分割点是否合法（同上面一样距离排序然后分配手），如果可以则代表 \([div_i, div_{i+1} - 1]\)都可以。可以参考jiangly的代码，但是正确性不太能理解，因为是以最优分配方式判断合法性，能保证这个区间都能取到最优方案吗（？
G - Typical Path Problem (abc318 G)
题目大意
给定一张简单无向图，问是否存在一个简单路径，从点\(a\)出发经过点 \(b\)到达点 \(c\)。
解题思路
题目可以转化成是否存在一棵生成树，其根为\(b\)，点 \(a\)和点 \(c\)的 \(lca\)是根，然后就一直在研究生成树，就不会了
神奇的代码
Ex - Count Strong Test Cases (abc318 Ex)
题目大意
<++>
解题思路
<++>
神奇的代码
