坐在前面的老哥 AK 了。他怎么这么成功，我怎么这么失败/ll。
T1
小 W 有 \(n\) 个球，每个球都有一种颜色，其中第 \(i\) 个球初始的颜色可以用正整数 \(a_i\) 来表示，一共有 \(m\) 种颜色。
在一次染色操作中，小 W 可以选择一个球，然后在 \(m\) 种颜色中选择一种颜色并将选中的球染为该颜色。
现在小 W 想让这 \(m\) 种颜色均在这 \(n\) 个球中出现过并且每种颜色的出现次数均为偶数，请问最少需要几次染色操作或者判断这不可能。
显然（出现次数为）\(0,1\) 需要改成 \(2\)，任意一个非 \(1\) 奇数需要改成最近的偶数，发现第三种可以和第一第二种合并做。
void work() {cin >> n >> m;fill(cnt + 1, cnt + 1 + m, 0ll);for (int i = 1; i <= n; ++i) {cin >> a[i];cnt[a[i]]++;}if (n % 2 == 1 || m * 2 > n) return cout << -1 << endl, void();int cnt0 = 0, cnt1 = 0, cntodd = 0;for (int i = 1; i <= m; ++i) {if (cnt[i] == 0) ++cnt0;if (cnt[i] == 1) ++cnt1;if (cnt[i] > 1 && cnt[i] % 2 == 1) ++cntodd;}// cout << "!" << cnt1 << ' ' << cnt0 << ' ' << cntodd << endl;cntodd -= min(cntodd, cnt0 * 2);cntodd -= min(cntodd, cnt1);assert(cntodd % 2 == 0);cntodd /= 2;// for (int i = 1; i <= m; ++i)// cout << cnt[i] << ' ';// cout << endl;cout <</* "ans=" << */(cntodd + cnt0 * 2 + cnt1) << endl;
}
T2
小 \(\gamma\) 最近学习了动态图完全连通性，对于给定的无向图 \(G = (V, E)\)，称节点 \(x, y\) 是可达的当且仅当存在有限长度顶点序列 \(p = (p_1, p_2, \cdots, p_m)\)，使得 \(p_1 = x, p_m = y\) 且对于 \(1 \le i < m\) 均有边 \((p_i, p_{i+1}) \in E\)。特别的，当 \(x = y\) 时总有 \(x, y\) 可达。
一般而言，动态图的问题一般围绕着加边、删边以及查询连通性展开。现在，小 \(\gamma\) 需要解决另一个动态图问题，围绕着加边、扩展以及查询边的存在性展开：
有一张由 \(n\) 个节点构成的无向图 \(G\)，节点编号依次为 \(1, 2, \cdots, n\)，初始时图中没有无向边，即 \(V = \{1, 2, \cdots, n\}, E = \emptyset\)。
小 \(\gamma\) 需要维护 \(q\) 次操作，操作有三种类型，分别为：
- 加边：给定一条无向边的两个端点 \(x, y (x \ne y)\)，将 \(E\) 更新为 \(E \cup \{(x, y)\}\)；
- 扩展：给定节点 \(x\)，对于任意无序顶点数对 \((a, b)\)，若此时 \((a, b) \notin E\) 且 \(a, x\) 可达并且 \(b, x\) 可达，则将所有满足该条件的无向边 \((a, b)\) 同时加入到边集 \(E\) 中；
- 查询：给定无向边 \((x, y) (x \ne y)\)，查询是否有 \((x, y) \in E\)。
这个问题对于小 \(\gamma\) 来说有点困难了，所以小 \(\gamma\) 找到了你来帮忙处理这 \(q\) 次操作。
注意到操作二相当于是将 \(x\) 所在的连通块变成一个完全图。
开两个并查集，一个并查集用于维护实际图的连通性，并且存储当前连通块有哪些边还没有被加入到实际答案的并查集里，一个并查集用户维护实际的答案。
每次询问 \((u,v)\) 看一下：
- 是不是显式加的边。
- \(u,v\) 在答案并查集里是否联通。
每次加边 \((u,v)\) 做：
- 将他们在实际图的连通性合并，并启发式合并连通块之间没有加进去的边。
每次扩展做：
- 对于所有 \(x\) 连通块内的没有加进去的边，把让他们在答案并查集里合并。
最后时间复杂度 \(O(n \log n)\) 的，但是被卡常了。
const int MAXN = 1e6 + 5;
struct _edge {int u, v;bool operator < (const _edge b) const {return (u == b.u ? v < b.v : u < b.u);}
};
vector<_edge> G[MAXN]; // slow vector??? check this later
int _c, n, q, faq[MAXN], far[MAXN];
set<_edge> st;int findr(int x) {if (far[x] == x) return x;else return far[x] = findr(far[x]);
}void merger(int x, int y) {// 将两个连通块合并，同时更新他们的边x = findr(x);y = findr(y);if (G[x].size() > G[y].size()) swap(x, y); // 将 x 合并到 yfor (auto e:G[x]) {G[y].push_back(e);}G[x].clear();far[x] = y;
}int findq(int x) {if (faq[x] == x) return x;else return faq[x] = findq(faq[x]);
}void mergeq(int x, int y) {x = findq(x);y = findq(y);faq[x] = y;
}void work() {cin >> _c >> n >> q;for (int i = 1; i <= n; ++i) {faq[i] = far[i] = i;}int cnt = 0;for (int i = 1; i <= q; ++i) {int opt; cin >> opt;assert(1 <= opt && opt <= 3);if (opt == 1) {int x, y; cin >> x >> y;assert(x != y);st.insert({x, y});if (findr(x) != findr(y)) merger(x, y);G[findr(y)].push_back({x, y});} else if (opt == 2) {int x; cin >> x; x = findr(x);for (auto e:G[x]) {if (findq(e.u) != findq(e.v)) mergeq(e.u, e.v);}G[x].clear(); // is my complexity right????????} else {++cnt;int x, y; cin >> x >> y;assert(x != y);if (st.find({x, y}) != st.end() || st.find({y, x}) != st.end()) {cout << "Yes" << endl;continue;}if (findq(x) == findq(y)) {cout << "Yes" << endl;continue;}cout << "No" << endl;}}
}
T3
给定一张由 \(n\) 个点 \(m\) 条边组成的简单有向图 \(G = (V, E)\)，其中 \(V = \{1, 2, \cdots, n\}\) 为点集，\(E\) 为边集，其中 \(|E| = m\)。
对于 \(V\) 的任意非空子集 \(S \subseteq V\)，如果对任意 \(u \in S\) 及 \(u\) 的出边 \((u, v) \in E\) 均满足 \(v \in S\)，则称 \(S\) 是 \(G\) 的一个闭合子图。
请求出 \(G\) 的点编号连续的闭合子图 \(S\) 的数量，即对于任意整数 \(x < y < z\)，若 \(x \in S, z \in S\)，则 \(y \in S\)。
设 \(f_i\) 表示 \(i\) 可达的最小编号，\(g_i\) 表示 \(i\) 可达的最大编号。一段区间 \([l,r]\) 合法当且仅当 \(l\le \min\limits_{i=l}^r f_i\) 且 \(\max\limits_{i=l}^r g_i \le r\)。
然后这里好像可以 CDQ 分治做（我前面的老哥就是 CDQ 分治做的这个）。不过这个是 2log 的，能过也是卡常奇迹了。
官方做法是，分治。假设我们现在要算 \([L,R]\) 区间内有多少个合法的 \([l,r]\)，那么限制可以拆成：
- \(\min\limits_{i=l}^{mid} f_i \ge l\)。
- \(\max\limits_{i=mid +1}^r g_i \le r\)。
- \(\min\limits_{i=mid +1}^r f_i \ge l\).
- \(\max\limits_{i=l}^{mid} g_i \le r\)
显然限制 \(1,2\) 是好做的，因为他们只和 \(l\) 或 \(r\) 中的一个有关，所以你 \(O(n)\) 把他们拿出来。
然后考虑第二个限制，这时候你的 \(\max g\) 和 \(\min f\) 就是静态的了，所以你可以把前缀 \(\min f\) 和后缀 \(\max g\) 拿出来，用双指针维护。
最后时间复杂度 $O(n \log n)。
T4
在一个房间内有 \(n\) 个绝顶聪明的人，并且这些人也知道别人绝顶聪明，每个人的头顶上戴着一顶帽子，其中第 \(i\) 个人头顶上的帽子写着 \(a_i\)。
每个人可以看到其余所有人头上帽子的数字，但是不能看到自己帽子上的数字。
同时，还有两个长度为 \(n - 1\) 的数列 \(b\) 和 \(c\)，称一个帽子上的数的分配方案是合法的当且仅当 \(a_i\) 均为整数且存在至少一个 \(1 \le i \le n - 1\) 满足 \(a_{i+1} < a_i + b_i\) 或 \(a_{i+1} > a_i + c_i\)。
现在，同时告诉这 \(n\) 个人数列 \(b\) 和 \(c\)，同时也告诉这些人帽子上的数的分配是合法的，此时游戏开始。
每一天，如果在这一天开始之前存在一个人知道自己帽子上写的数字一定不等于某一整数 \(x\)，则这个人将在这一天结束时宣布，然后游戏结束。如果在一天中没有任何一个人宣布这一事实，则游戏继续，下一天开始。
请求出游戏将在哪一天结束或判断游戏将会不停进行下去。
考虑假设只有一个位置满足条件（也就是不在区间内），那么第一天，他看了一圈发现没有合法的，他就知道自己是合法的那个，所以游戏结束。
如果有两个位置满足条件，第一天他们各自看着对面（因为他们两个能看到一个合法的，其他人能看到两个合法的），但是第一天没有人宣布结束，所以这两个合法的人就知道有两个合法的人，所以第二天游戏结束。
稍微推理一下，发现如果有 \(x\) 个位置合法，那么在第 \(x\) 天游戏结束。所以现在要求，有多少个合法的位置。
因为这个合法的是不在区间，这个东西不好求，所以我们转而求有多少个不合法的位置。如果我们选出一个子序列 \(i_1,i_2,\cdots i_k\) 满足他们不合法，这几个位置的条件是 \(a_{i_x}\in [a_{i_{x+1}} + \sum b_y,a_{i_{x+1}}+\sum c_y]\)。
所以很经典的移项，令 \(x_i=a_i-\sum\limits_{j=1}^{i-1} b_j,y_i=a_i-\sum\limits_{j=1}^{i-1} c_j\)，条件变成一个三维偏序：
- \(i<j\)。
- \(x_i\le x_j\)。
- \(y_i\ge y_j\)。
用 CDQ 分治优化 DP 即可。复杂度 \(O(n \log^2 n)\)，官方题解说稍微分析性质可以做到 \(O(n\log n)\)，但是我不会，所以喜提最劣解。
const int MAXN = 2e5 + 5;
int n, a[MAXN], b[MAXN], c[MAXN], f[MAXN];struct _point {int x, y, t;
} p[MAXN];struct _bit {int tr[MAXN], v[MAXN], now;int lowbit(int x) { return x & (-x); }int get(int x) {return now == v[x] ? tr[x] : INT_MIN;}void modify(int x, int val) {while (x <= n) {tr[x] = max(get(x), val);v[x] = now;x += lowbit(x);}}int query(int x) {int ret = INT_MIN;while (x) {ret = max(ret, get(x));x -= lowbit(x);}return ret;}void clear() { ++now; }
} t;void solve(int l, int r) {if (l == r) return f[l] = max(f[l], 1ll), void();solve(l, mid);vector<_point> v;for (int i = l; i <= r; ++i)v.push_back({p[i].x, p[i].y, i});sort(v.begin(), v.end(), [](auto u, auto v) {if (u.y == v.y) return u.t < v.t;return u.y > v.y;});for (auto [x, y, i]:v) {if (i <= mid) {t.modify(x, f[i]);} else {f[i] = max(f[i], t.query(x) + 1);}}t.clear();solve(mid + 1, r);
}void work() {cin >> n;fill(f + 1, f + 1 + n, 0ll);fill(a + 1, a + 1 + n, 0ll);fill(b + 1, b + 1 + n, 0ll);fill(c + 1, c + 1 + n, 0ll);for (int i = 1; i <= n; ++i)cin >> a[i];for (int i = 1; i < n; ++i) {cin >> b[i] >> c[i];}for (int i = 1; i < n; ++i) {if (b[i] > c[i]) return cout << -1 << endl, void();}for (int i = 1; i <= n; ++i) {b[i] += b[i - 1];c[i] += c[i - 1];}vector<int> v1, v2;for (int i = 1; i <= n; ++i) {p[i].x = a[i] - b[i - 1];p[i].y = a[i] - c[i - 1];v1.push_back(p[i].x);v2.push_back(p[i].y);}sort(v1.begin(), v1.end());v1.erase(unique(v1.begin(), v1.end()), v1.end());sort(v2.begin(), v2.end());v2.erase(unique(v2.begin(), v2.end()), v2.end());for (int i = 1; i <= n; ++i) {p[i].x = lower_bound(v1.begin(), v1.end(), p[i].x) - v1.begin() + 1;p[i].y = lower_bound(v2.begin(), v2.end(), p[i].y) - v2.begin() + 1;}solve(1, n);int ans = 0;for (int i = 1; i <= n; ++i)ans = max(ans, f[i]);cout << n - ans << endl;
}
)
)
