AtCoder Beginner Contest 368
A - Cut (abc368 A)
题目大意
给定一个数组，将右边\(k\)个数保持原顺序挪到左边，输出。
解题思路
即从左边第\(n-k\)个数开始输出即可。或者用rotate函数转换一下。
神奇的代码
#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, k;
cin >> n >> k;
k = n - k;
vector<int> a(n);
for (auto& i : a)
cin >> i;
rotate(a.begin(), a.begin() + k, a.end());
for (auto i : a)
cout << i << ' ';
cout << '\n';
return 0;
}
B - Decrease 2 max elements (abc368 B)
题目大意
给定一个数组，每次将最大的两个数减一，直到只有一个或无正数。输出操作的次数。
解题思路
最多\(100\)个数，每个数最大 \(100\)，因此最大的操作次数只有\(O(100^2)\)，加上每次操作的复杂度是 \(O(n\log n)\)，因此直接模拟的复杂度即为 \(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<int> a(n);
for (auto& i : a)
cin >> i;
int cnt = 0;
while (count_if(a.begin(), a.end(), [](int x) { return x > 0; }) > 1) {
sort(a.begin(), a.end(), greater<int>());
a[0]--;
a[1]--;
cnt++;
}
cout << cnt << '\n';
return 0;
}
C - Triple Attack (abc368 C)
题目大意
\(n\)个怪兽血量 \(h_i\)，依次打它们。当前怪物死了则打下一个。
初始时刻\(t=0\)，每时刻都会对当前怪物造成 \(1\)的伤害，如果 \(t \% 3 == 0\)，则可以额外造成 \(2\)的伤害（即一共 \(3\)的伤害）。
问打死所有怪物时的时刻。
解题思路
直接模拟时刻流逝，其最大时刻高达\(O(10^{14})\)，但注意到打怪物的时刻越多，伤害越高，因此对于每个怪兽，我们不必模拟时刻流逝，而是二分打死怪物的时刻 \(T\)，看看时间\((t, T]\)的伤害是否足够打死当前怪兽。
对每个怪兽都二分求出一下打死的时刻，最后的二分结果即为答案。
计算 \((t, T]\)时间的伤害，即为 \(T - t + \lfloor \frac{T}{3} \rfloor - \lfloor \frac{t}{3} \rfloor\)
神奇的代码
#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;
LL t = 0;
LL up = 1e18;
auto check = [](LL l, LL r) -> LL { return r - l + 2ll * (r / 3 - l / 3); };
auto solve = [&](LL t, int x) -> LL {
LL l = t, r = up;
while (l + 1 < r) {
LL mid = (l + r) / 2;
if (check(t, mid) < x)
l = mid;
else
r = mid;
}
return r;
};
while (n--) {
int x;
cin >> x;
t = solve(t, x);
}
cout << t << '\n';
return 0;
}
D - Minimum Steiner Tree (abc368 D)
题目大意
给定一棵树，问保留\(k\)个点且连通的最小点数是多少。
解题思路
以第一个保留的点为根，进行\(DFS\)。
在 \(DFS\)过程中的当前点 \(u\)，判断其是否需要保留，则需要知道其子树是否有需要保留的点，有则当前点 \(u\)需要保留。
因此 \(DFS\)返回的东西即为该子树是否有需要保留的点\(fixed\)。最后答案就是 fixed点的数量。
神奇的代码
#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, k;
cin >> n >> k;
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);
}
vector<int> fix(n, 0);
int root = 0;
for (int i = 0; i < k; ++i) {
cin >> root;
--root;
fix[root] = 1;
}
int ans = 0;
auto dfs = [&](auto dfs, int u, int fa) -> bool {
bool fixed = fix[u];
for (auto v : edge[u]) {
if (v == fa)
continue;
fixed |= dfs(dfs, v, u);
}
ans += fixed;
return fixed;
};
dfs(dfs, root, root);
cout << ans << '\n';
return 0;
}
E - Train Delay (abc368 E)
题目大意
给定\(n\)个城市和 \(m\)个火车的信息，从\(s_i \to t_i\)，时间是 \(S_i \to T_i\)。
先给定 \(x_1\)，即第一个城市火车延误出发时间，要求 \(x_2,x_3,...,x_n\)，使得：
- 对于任意两个火车信息满足 \(t_i = s_j, T_i \leq S_j\)的，也满足\(T_i + x_i \leq S_j + x_j\)，即原来可换乘的俩列车， 在延误后仍可换乘。
- \(\sum_{i=2}^n x_i\)最小
解题思路
<++>
神奇的代码
F - Dividing Game (abc368 F)
题目大意
给定\(n\)个数， \(Anna\)杏菜和 \(Bruno\)玩游戏， \(Anna\)先。
每轮，选一个数，将其变为真因子。
无法操作即输。问最优情况下谁赢。
解题思路
知道博弈论的\(SG\)知识就可以解了。
每个数之间是互不干扰的，因此每个数可以视为一个独立局面，因此整个局面的\(sg\)值就是每个独立局面的 \(sg\)值的异或。
考虑一个独立局面的 \(sg\)值怎么求，即 \(sg[x]\)。根据 \(sg\)值定义，其为所有后继情况的 \(sg\)值的 \(mex\)，即 \(sg[x] = \mex_{x \% i == 0} (sg[i])\) 。
枚举因子数是\(O(\sqrt{x}) = 10^{2.5}\)，而\(n=10^5\) ，因此花\(O(n\sqrt{x})\)预处理出所有数的\(sg\)值，然后异或一下，为 \(0\)则 先手输，否则 先手赢。
神奇的代码
#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 = 1e5 + 8;
vector<int> sg(N);
sg[1] = 0;
auto getSG = [&](int x) {
set<int> hold{sg[1]};
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
hold.insert(sg[x / i]);
hold.insert(sg[i]);
}
}
for (int i = 0; i < N; ++i) {
if (hold.find(i) == hold.end()) {
return i;
}
}
assert(0);
};
for (int i = 2; i < N; ++i) {
sg[i] = getSG(i);
}
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
ans ^= sg[x];
}
if (ans) {
cout << "Anna" << '\n';
} else {
cout << "Bruno" << '\n';
}
return 0;
}
G - Add and Multiply Queries (abc368 G)
题目大意
给定两个数组\(a,b\)，维护下列三种操作：
1 i x，令\(a_i = x\)2 i x，令\(b_i = x\)3 l r，求最大值\(v\)，其初始 \(v=0\)，依次 \(i \in [l,r]\) ，令\(v = v + a_i\)或 \(v = v * b_i\)
题目保证操作三的答案不超过\(10^{18}\)。
解题思路
对于一次操作\(3\)，很显然对于 \(i \in [l,r]\) ，我令\(v = \max(v + a_i, v * b_i)\)。一次的复杂度是 \(O(n)\)。
注意到操作三的答案不超过\(10^{18}\)，这意味着什么呢。
首先，如果 \(b_i = 1\)，我们很显然是选择操作 \(1\)，而对于要判断最大值的，必定有 \(b_i \geq 2\)， \(v = \max(v + a_i, v*b_i) \geq 2v\)，也就是说，每做一次判断， \(v\)都会翻倍，最多翻 \(64\)次，就达到 \(10^{18}\)了。
所以，每次区间 \([l,r]\)中，实际上只有最多\(O(64)\)个 \(b_i \geq 2\)，其余都是 \(1\)，这意味着都会选择 \(v=v+a_i\)。
因此每次操作区间 \([l,r]\)，我们直接模拟，
- 找到第一个 \(b_{pos} \geq 2\)
- 处理 \([l, pos-1]\)的操作，即 \(v = v + suma[l..pos-1]\)
- 处理 \([pos, pos]\)的操作，即 \(v = \max(v + a_{pos}, v * b_{pos})\)
- \(l = pos + 1\)，重复第一个操作
最多跑 \(O(60)\)次就跑完了，因为带修改，第一步操作就用线段树上二分，通过区间最大值>1找到其位置，第二步操作就是一个区间和。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e5 + 8;
class info {
public:
LL sum;
int maxx;
info(LL sum = 0, int maxx = 0) : sum(sum), maxx(maxx) {}
info operator+(const info& rhs) const {
return info(sum + rhs.sum, max(maxx, rhs.maxx));
}
};
class segment {
#define lson (root << 1)
#define rson (root << 1 | 1)
public:
info val[N << 2];
void build(int root, int l, int r, vector<int>& a, vector<int>& b) {
if (l == r) {
val[root] = info(a[l], b[l]);
return;
}
int mid = (l + r) >> 1;
build(lson, l, mid, a, b);
build(rson, mid + 1, r, a, b);
val[root] = val[lson] + val[rson];
}
void update(int root, int l, int r, int pos, info& v) {
if (l == r) {
val[root] = v;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(lson, l, mid, pos, v);
else
update(rson, mid + 1, r, pos, v);
val[root] = val[lson] + val[rson];
}
info query(int root, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return val[root];
}
int mid = (l + r) >> 1;
info resl{}, resr{};
if (L <= mid)
resl = query(lson, l, mid, L, R);
if (R > mid)
resr = query(rson, mid + 1, r, L, R);
return resl + resr;
}
int findfirst(int root, int l, int r, int L, int R) {
if (l > R || r < L) {
return 0;
}
if (L <= l && r <= R && val[root].maxx < 2) {
return 0;
}
if (l == r) {
return l;
}
int mid = (l + r) >> 1;
int ret = findfirst(lson, l, mid, L, R);
if (ret == 0) {
ret = findfirst(rson, mid + 1, r, L, R);
}
return ret;
}
} seg;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; ++i)
cin >> a[i];
vector<int> b(n + 1);
for (int i = 1; i <= n; ++i)
cin >> b[i];
seg.build(1, 1, n, a, b);
int q;
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int pos, x;
cin >> pos >> x;
a[pos] = x;
info v(a[pos], b[pos]);
seg.update(1, 1, n, pos, v);
} else if (op == 2) {
int pos, x;
cin >> pos >> x;
b[pos] = x;
info v(a[pos], b[pos]);
seg.update(1, 1, n, pos, v);
} else {
int l, r;
cin >> l >> r;
LL ans = a[l];
l++;
while (l <= r) {
int pos = seg.findfirst(1, 1, n, l, r);
if (pos == 0) {
ans += seg.query(1, 1, n, l, r).sum;
break;
} else {
info v = seg.query(1, 1, n, l, pos - 1);
ans += v.sum;
ans = max(ans + a[pos], ans * b[pos]);
l = pos + 1;
}
}
cout << ans << '\n';
}
}
return 0;
}
