C.Coins
有 \(x+y+z\) 个人，第 \(i\) 个人有 \(a_i\) 个金币，\(b_i\) 个银币，\(c_i\) 个铜币。选 \(x\) 个人获得金币、\(y\) 个人获得银币、\(z\) 个人获得铜币，不重复选人，最大化获得的币的总数。
\(x + y + z \leq 10^5\)。
先考虑如果是二元组怎么做：先假设所有人都拿金币，问题就转化成了选出 \(b_i - a_i\) 最大的 \(y\) 个人改成银币，排序就行了。
三元组的情况也可以用类似的方式转化成二元组：先假设所有人都拿金币，令 \(e_i = b_i - a_i,f_i = c_i - a_i\)，这样问题就转化为了在 \(n\) 个二元组 \((e_i,f_i)\) 中选 \(y\) 个拿 \(e\)，选 \(z\) 个拿 \(f\)，最大化总收益。
考虑两个二元组 \((e_i,f_i),(e_j,f_j)\)，假设此时 \(i\) 选 \(f\) 且 \(j\) 选 \(e\)，考虑什么时候交换它们的选择收益不会变少，即 \(e_i + f_j \geq f_i + e_j\)，移项可得 \(e_i - f_i \geq e_j - f_j\)。
也就是说，如果我们将二元组按照 \(e - f\) 从小到大排序，那么对于任意 \(i < j\)，如果 \(i\) 选 \(f\) 且 \(j\) 选 \(e\)，那么交换它们的选择收益一定不会变少。这意味着一定存在一个最优解满足选 \(e\) 的二元组全在选 \(f\) 的左边。
考虑枚举分界点，用优先队列预处理出前缀前 \(y\) 大的 \(e\) 的和及后缀前 \(z\) 大的 \(f\) 的和即可。时间复杂度 \(O(n \log n)\)。
code
/*
挥拂去蒙尘半生的晦暗
用这嶙峋双臂迎接 振翅吧 我的蝴蝶
最后一支 赤诚赞歌盘旋
潮起潮落翻覆昼夜 澎湃在生命刻度之前
此刻色彩挣脱谎言 献予你 赤红纸花遍野
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 5e5 + 5;
const LL inf = 1e18;
struct dat { int a, b; } v[N];
int n, x, y, z; LL ans, l[N], r[N];
priority_queue <int, vector <int>, greater <int> > q;
int main() {
ios :: sync_with_stdio(0);
cin >> x >> y >> z; n = x + y + z;
for (int i = 1, a, b, c; i <= n; i++) {
cin >> a >> b >> c; ans += a, b -= a, c -= a;
v[i].a = b, v[i].b = c;
}
sort(v + 1, v + n + 1, [&](dat i, dat j){ return i.a - i.b > j.a - j.b; });
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1] + v[i].a, q.push(v[i].a);
if ((int)q.size() > y) l[i] -= q.top(), q.pop();
}
while (!q.empty()) q.pop();
for (int i = n; i >= 1; i--) {
r[i] = r[i + 1] + v[i].b, q.push(v[i].b);
if ((int)q.size() > z) r[i] -= q.top(), q.pop();
}
LL mx = -inf;
for (int i = y; i <= n - z; i++) mx = max(mx, l[i] + r[i + 1]);
cout << ans + mx << endl;
return 0;
}
D.Tree and Hamilton Path
给定一颗 \(n\) 个顶点的树，边带权。有一张 \(n\) 个点的完全图 \(G\)，图上两点之间的边的边权为它们在树上的距离。求 \(G\) 的最长哈密顿路径的长度。
\(n \leq 10^5\)。
发现我好像不是很会求哈密顿路径，但如果是求哈密顿回路我就很懂了，考虑每条边最多包含在几条路径内，假设这条边将树分成 \(x,n-x\) 两部分，那么这个上界就是 \(\min(x,n-x)\)。通过调整法容易说明这个上界是可以达到的，于是我们把所有边的贡献加起来就行了。
现在只需要删掉一条路径就可以把它变成哈密顿路径了。但有一个问题是有些路径可能不包含在任何一个最优解中，所以我们并不能随便瞎删。
事实上有且仅有所有不经过重心的路径不包含在任一最优解中，这个通过调整法也容易说明。那么所有经过重心的路径都可以随便删，直接删掉最短的一条就行了。如果有两个重心就删掉两重心之间的边。时间复杂度 \(O(n)\)。
code
/*
挥拂去蒙尘半生的晦暗
用这嶙峋双臂迎接 振翅吧 我的蝴蝶
最后一支 赤诚赞歌盘旋
潮起潮落翻覆昼夜 澎湃在生命刻度之前
此刻色彩挣脱谎言 献予你 赤红纸花遍野
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair <int, int> pi;
#define mp make_pair
#define fi first
#define se second
#define pb push_back
const int N = 2e5 + 5;
const LL inf = 1e18;
int n; LL ans, sz[N], mx[N];
vector <pi> e[N];
LL min(LL x, LL y) { return x < y ? x : y; }
void dfs(int u, int pr) {
sz[u] = 1;
for (auto p : e[u]) {
int v = p.fi;
if (v == pr) continue;
dfs(v, u);
sz[u] += sz[v], mx[u] = max(mx[u], sz[v]);
ans += 2 * min(sz[v], n - sz[v]) * p.se;
}
mx[u] = max(mx[u], n - sz[u]);
}
int main() {
ios :: sync_with_stdio(0);
cin >> n;
for (int i = 1, x, y, z; i < n; i++) {
cin >> x >> y >> z;
e[x].pb(mp(y, z)), e[y].pb(mp(x, z));
}
dfs(1, 0);
LL mi = inf; int g1 = 0, g2 = 0;
for (int i = 1; i <= n; i++) mi = min(mi, mx[i]);
for (int i = 1; i <= n; i++) if (mx[i] == mi) {
!g1 ? g1 = i : g2 = i;
}
LL sub = inf;
for (auto p : e[g1]) {
int v = p.fi;
if (g2 && v != g2) continue;
sub = min(sub, p.se);
}
cout << ans - sub << endl;
return 0;
}
E.Sightseeing Plan
给定三个矩形，保证它们从左下到右上排开，且不相交。分别从三个矩形中选出三个点 \(P_1,P_2,P_3\)，求 \(P_1 \to P_2 \to P_3\) 的最短路径条数之和对 \(10^9+7\) 取模后的值。
\(1 \leq x_i,y_i \leq 10^6\)。
一步一步来。首先有小学奥数：\((x_1,y_1) \to (x_2,y_2)\) 的最短路径条数为 \(\binom{x_2 - x_1 + y_2 - y_1}{x_2 - x_1}\)。
然后考虑怎么把这个拓展到一个点到一个矩形的情况，设 \(f(x,y)\) 表示 \((0,0) \to (x,y)\) 的路径条数（以下路径条数都指最短路径条数），那么 \(f\) 有如下关系：\(f(x,y) = \sum_{j=0}^y f(x-1,j)\)。
一个简单的证明是考虑组合意义，相当于走到 \((x-1,j)\)，然后按 \((x-1,j) \to (x,j) \to (x,y)\) 这样走，显然不重不漏。
扩展到二维的情况，可以得到 \(\sum_{i = 0}^x \sum_{j=0}^y f(i,j) = f(x+1,y+1)-1\)。
那么 \((0,0) \to (x_1,y_1,x_2,y_2)\) 的方案数 \(\sum_{x = x_1}^{x_2} \sum_{y = y_1}^{y_2} f(x,y)\)，容斥一下就能得到它等于 \(f(x_2 + 1,y_2 + 1) - f(x_2 + 1,y_1) - f(x_1,y_2 + 1) + f(x_1,y_1)\)。
于是我们成功将一个点到一个矩阵的方案数转化成了一个点到 \(O(1)\) 个点的方案数的线性组合。
一个矩形到一个矩形的方案也是类似的，利用分配率可以转化成 \(O(1)\) 个点到 \(O(1)\) 个点的方案数的线性组合。
现在只要加上中间的矩形就行了。点对数量是 \(O(1)\) 的，我们只需要管一个已知点经过一个矩形到达另一个已知点的方案数怎么算。
之后的做法看起来就比较厉害了：由于我们是需要在中间的矩阵中选一个点的，因此如果矩形内部经过了 \(L\) 个点，那么贡献要带一个 \(L\) 的系数。考虑把 \(L\) 拆开：假设在 \((x_1,y_1)\) 进入矩阵，\((x_2,y_2)\) 走出矩阵，那么 \(L = x_2 - x_1 + y_2 - y_1 + 1 = (x_2 + y_2 + 1) - (x_1 + y_1)\)。
那么只需要枚举进入点和离开点就可以 \(O(n)\) 算了。
所以说还是不能急啊，一上来就试图算矩形到矩形的方案数就啥也不会做了
。
code
/*
挥拂去蒙尘半生的晦暗
用这嶙峋双臂迎接 振翅吧 我的蝴蝶
最后一支 赤诚赞歌盘旋
潮起潮落翻覆昼夜 澎湃在生命刻度之前
此刻色彩挣脱谎言 献予你 赤红纸花遍野
*/
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5, mod = 1e9 + 7;
struct dat {
int x, y, coef;
dat(int _x = 0, int _y = 0, int _coef = 0) : x(_x), y(_y), coef(_coef) {}
} p[9];
int x3, y3, x4, y4, x[7], y[7];
int ans, fac[N], inv[N];
int qpow(int a, int b = mod - 2, int ret = 1) {
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod, b >>= 1;
}
return ret;
}
void add(int &x, int y) { x = (x + y >= mod) ? (x + y - mod) : (x + y); }
void del(int &x, int y) { x = (x - y < 0) ? (x - y + mod) : (x - y); }
int C(int n, int m) { return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int f(int x1, int y1, int x2, int y2) {
int A = abs(x2 - x1), B = abs(y2 - y1);
return C(A + B, A);
}
int solve(int i, int j) {
int ret = 0;
int x1 = p[i].x, y1 = p[i].y, x2 = p[j].x, y2 = p[j].y;
for (int x = x3; x <= x4; x++) {
add(ret, 1ll * f(x1, y1, x, y4) * f(x, y4 + 1, x2, y2) % mod * (x + y4 + 1) % mod);
del(ret, 1ll * f(x1, y1, x, y3 - 1) * f(x, y3, x2, y2) % mod * (x + y3) % mod);
}
for (int y = y3; y <= y4; y++) {
add(ret, 1ll * f(x1, y1, x4, y) * f(x4 + 1, y, x2, y2) % mod * (x4 + y + 1) % mod);
del(ret, 1ll * f(x1, y1, x3 - 1, y) * f(x3, y, x2, y2) % mod * (x3 + y) % mod);
}
return ret;
}
int main() {
ios :: sync_with_stdio(0);
for (int i = 1; i <= 6; i++) cin >> x[i];
for (int i = 1; i <= 6; i++) cin >> y[i];
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[N - 1] = qpow(fac[N - 1]);
for (int i = N - 1; i >= 1; i--) inv[i - 1] = 1ll * inv[i] * i % mod;
x3 = x[3], y3 = y[3], x4 = x[4], y4 = y[4];
p[1] = dat(x[1] - 1, y[1] - 1, 1);
p[2] = dat(x[2], y[1] - 1, -1);
p[3] = dat(x[1] - 1, y[2], -1);
p[4] = dat(x[2], y[2], 1);
p[5] = dat(x[5], y[5], 1);
p[6] = dat(x[5], y[6] + 1, -1);
p[7] = dat(x[6] + 1, y[5], -1);
p[8] = dat(x[6] + 1, y[6] + 1, 1);
for (int i = 1; i <= 4; i++) {
for (int j = 5; j <= 8; j++) {
int w = solve(i, j);
(p[i].coef * p[j].coef > 0) ? add(ans, w) : del(ans, w);
}
}
cout << ans << endl;
return 0;
}
F.Two Trees
给定两棵 \(n\) 个节点的有根树，给每个标号定一个权值，使在两棵树上均满足任意节点子树权值和为 \(1\) 或 \(-1\)。构造方案，或判断无解。
\(n \leq 10^5\)。
真不会构造，狂暴膜题解了。以下称第一棵树为左树，第二棵树为右树。
首先考虑怎么判无解：因为每个子树的权值和 \(\equiv 1 \pmod{2}\)，因此如果一个点在左树和右树中儿子数量的奇偶性不同，那么无解。
然后因为这个跟度数奇偶性相关，不难想到构造一个图然后在上面跑欧拉回路。具体来说，我们先在两个根之间连边保证图联通，然后对于度数为奇数的点，我们将它们对应的两个点连边（下文称作横叉边）。这样图中所有点度数都是偶数，即它存在欧拉回路。
我们可以断言，如果有解，那么只需要用 \(0,1,-1\) 就可以构造出合法解。构造方法如下：
我们跑一遍欧拉回路，对于度数为偶数的点，我们设定它的权值为 \(0\)，对于度数为奇数的点，如果它对应的横叉边在欧拉回路上的方向是从左往右，那么我们设定它的权值为 \(1\)，否则为 \(-1\)。
考虑证明这个构造的正确性：
我们把欧拉回路拆成若干个简单环，对于一个环对某个结点的贡献，我们分三类情况讨论：
- 某个节点往儿子走，然后从儿子或自己的横叉边回来；
- 某个节点往儿子走，然后从父亲回来；
- 某个节点往横叉边 / 父亲走，然后从父亲 / 横叉边回来。
第一类环会在子树内贡献一个 \(1\) 和一个 \(-1\)，所以这个环没啥用。第二类环和第三类环会造成 \(1\) 或 \(-1\) 的贡献，但因为都需要用到 \(u \to f_u\)（\(f_u\) 为 \(u\) 的父亲）这条边，因此对一个节点来说，这两类环有且仅有一个。
对于两个根节点，开始我们在它们之间连一条边相当于是建了一个虚点，让这个虚点当两个根的父亲，于是我们就不需要特殊讨论了。虚点的权值对答案没有影响，于是就做完了，时间复杂度 \(O(n)\)。
其实我开头说的 “不难想到” 纯纯是在口嗨，因为我真没想到。有人来教教我到底该怎么做构造题吗
。
code
/*
挥拂去蒙尘半生的晦暗
用这嶙峋双臂迎接 振翅吧 我的蝴蝶
最后一支 赤诚赞歌盘旋
潮起潮落翻覆昼夜 澎湃在生命刻度之前
此刻色彩挣脱谎言 献予你 赤红纸花遍野
*/
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
const int N = 1e5 + 5, M = 3e5 + 5;
int n, m, eu[M], ev[M], dir[M], a[N], b[N], rt1, rt2;
int deg1[N], deg2[N], ans[N];
vector <int> e[N * 2];
void dfs(int u) {
while (!e[u].empty()) {
int p = e[u].back();
e[u].pop_back();
if (dir[p] != 0) continue;
int v = eu[p] ^ ev[p] ^ u;
dir[p] = u == eu[p] ? 1 : -1, dfs(v);
}
}
int main() {
ios :: sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
if (a[i] != -1) {
deg1[a[i]]++, deg1[i]++;
m++, eu[m] = a[i], ev[m] = i;
e[a[i]].pb(m), e[i].pb(m);
} else rt1 = i;
if (b[i] != -1) {
deg2[b[i]]++, deg2[i]++;
m++, eu[m] = n + b[i], ev[m] = n + i;
e[n + b[i]].pb(m), e[n + i].pb(m);
} else rt2 = i;
}
deg1[rt1]++, deg2[rt2]++;
m++, eu[m] = 2 * n + 1, ev[m] = rt1;
e[2 * n + 1].pb(m), e[rt1].pb(m);
m++, eu[m] = 2 * n + 1, ev[m] = n + rt2;
e[2 * n + 1].pb(m), e[n + rt2].pb(m);
for (int i = 1; i <= n; i++) if ((deg1[i] ^ deg2[i]) & 1) return puts("IMPOSSIBLE"), 0;
puts("POSSIBLE");
for (int i = 1; i <= n; i++) if (deg1[i] & 1) {
m++, eu[m] = i, ev[m] = n + i;
e[i].pb(m), e[n + i].pb(m);
}
dfs(2 * n + 1);
for (int i = m; i > 2 * n; i--) ans[eu[i]] = dir[i];
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}