我是真的不稳定的垃圾选手。
对于一张图来说，两个人能满足题面关系等价于这张图不是链，很好证明，如果有度数 (> 2) 的点，让一个人跑到一个度数 (= 1) 的地方就可以了。
如果离线就可以什么启发式合并 + 并查集做到一个 (log)。就是合并两个点 (x, y)，动态维护每个联通块是不是链。
- 连接两个已经在同一个联通块的点变成环就不是链了
- 若 (x, y) 之前所在联通块不是链总共也不是链了
- 若 (x, y) 其中有一个是不是端点总共也不是链了。
- 如果 (x) 所在联通块大小 (> 1) 那么 (x) 就不是端点了，(y) 同理。
然后这是强制在线的。。可持久化并查集，询问的时候要二分，每次 check 还是两个 (log)，最后 (O(m log^2 n + q log ^ 3 n))，居然只会 TLE 五六个点。。。然后我也不会卡常，自闭了。
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 100005, MAXM = 200005;
int n, m, arr[MAXM], tot;
struct E{
int u, v, w;
bool operator < (const E &b) const {
return w < b.w;
}
} e[MAXM];
struct T{
int l, r, v;
};
struct Array{
int rt[MAXM], idx;
T t[MAXN * 22];
void build(int &p, int l, int r, int o) {
p = ++idx;
if (l == r) { t[p].v = o == -1 ? r : o; return ; }
int mid = (l + r) >> 1;
build(t[p].l, l, mid, o);
build(t[p].r, mid + 1, r, o);
}
void update(int &p, int q, int l, int r, int x, int o) {
t[p = ++idx] = t[q];
if (l == r) { t[p].v = o; return; }
int mid = (l + r) >> 1;
if (x <= mid) update(t[p].l, t[q].l, l, mid, x, o);
else update(t[p].r, t[q].r, mid + 1, r, x, o);
}
int query(int p, int l, int r, int x) {
if (l == r) return t[p].v;
int mid = (l + r) >> 1;
if (x <= mid) return query(t[p].l, l, mid, x);
else return query(t[p].r, mid + 1, r, x);
}
void inline set(int x, int k, int i) { update(rt[i], rt[i], 0, n - 1, x, k); }
int inline get(int x, int i) { return query(rt[i], 0, n - 1, x); }
} p, f, d, sz;
int find(int x, int i) {
int fa = f.get(x, i);
return x == fa ? x : find(fa, i);
}
void inline merge(int x, int y, int i) {
int a = find(x, i), b = find(y, i);
if (a == b) {
p.set(a, 1, i);
} else {
int sa = sz.get(a, i), sb = sz.get(b, i);
if (sa > sb) swap(sa, sb), swap(a, b), swap(x, y);
f.set(a, b, i);
int dx = d.get(x, i), dy = d.get(y, i);
if (p.get(a, i) || !dx || !dy) p.set(b, 1, i);
if (dx && sa > 1) d.set(x, 0, i);
if (dy && sb > 1) d.set(y, 0, i);
sz.set(b, sa + sb, i);
}
}
void init(int N, int M,
std::vector<int> U, std::vector<int> V, std::vector<int> W) {
n = N, m = M;
for (int i = 0; i < m; i++) {
arr[++tot] = W[i];
e[i] = (E) { U[i], V[i], W[i] };
}
sort(arr + 1, arr + 1 + tot);
tot = unique(arr + 1, arr + 1 + tot) - arr - 1;
sort(e, e + m);
f.build(f.rt[0], 0, n - 1, -1), sz.build(sz.rt[0], 0, n - 1, 1);
p.build(p.rt[0], 0, n - 1, 0), d.build(d.rt[0], 0, n - 1, 1);
for (int i = 1, j = 0; i <= tot; i++) {
p.rt[i] = p.rt[i - 1], f.rt[i] = f.rt[i - 1];
d.rt[i] = d.rt[i - 1], sz.rt[i] = sz.rt[i - 1];
while (j < m && e[j].w <= arr[i]) {
merge(e[j].u, e[j].v, i);
++j;
}
}
}
bool inline check(int X, int Y, int i) {
int a = find(X, i), b = find(Y, i);
return a == b && p.get(a, i);
}
int getMinimumFuelCapacity(int X, int Y) {
if (!check(X, Y, tot)) return -1;
int l = 1, r = tot;
while (l < r) {
int mid = (l + r) >> 1;
if (check(X, Y, mid)) r = mid;
else l = mid + 1;
}
return arr[r];
}
然后就去无耻的看题解，然后去学了一下 Kruscal 重构树。
我们不妨设计一个特殊的 Kruscal 重构树，使得对于 (x, y) 的询问，答案就是他们的 LCA ，即他们的 LCA 是合并过程中让他们从链变成不是链的那条关键边！
那么，设计一种类似于普通 Kruscal 最小重构树的方式，只不过改动如下：
- 对于合并还是链的联通块，先不要在重构树上连边。
- 当一条链 (Rightarrow) 不是链的时候，把这条边的新点是链里所有点两两的关键边，所以把这个新点作为这条链上所有点的父亲就行了！这样的意义是这些点两两关键边就是这个边。
发现这么构造仍然满足大根堆性质。
用启发式合并存储当前联通块的所有点，每个原始点只会连一次，即连向他所在联通块转变的关键边新点，所以复杂度是 (O(n log n)) 的。
正确性：在 LCA 这个子树中，所有边都是 (le w_{LCA}) 的，LCA 的子树形成的结构不是链，因为只有不是链才会连边，所以必然 LCA 的权值是可以的。然后证明 (ans ge w_{LCA})。(ans < w_{LCA}) 显然是不行的，因为他们要用这条关键边。所以 (ans = w_{LCA})。
所以每次询问求个 LCA 就行了。
时间复杂度 (O((n + q) log n))
我代码偷了一下懒，即只在链的时候维护各种信息，已经不是链了，除了 (f) 数组剩下就不用维护。
#include "swap.h"
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int N = 100005, M = 200005, L = 19;
int n, m, f[N << 1], fa[N << 1][L], dep[N << 1], cnt, sz[N], a[N << 1];
bool ch[N << 1], d[N];
vector<int> g[N << 1];
vector<int> c[N << 1];
struct E {
int u, v, w;
bool operator<(const E &b) const { return w < b.w; }
} e[M];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void dfs(int u) {
for (int i = 1; i < L && fa[u][i - 1]; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
fa[v][0] = u, dep[v] = dep[u] + 1;
dfs(v);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y])
swap(x, y);
for (int i = L - 1; ~i; i--)
if (dep[x] - (1 << i) >= dep[y])
x = fa[x][i];
if (x == y)
return x;
for (int i = L - 1; ~i; i--)
if (fa[x][i] != fa[y][i])
x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void inline merge(int u, int v, int w) {
int x = find(u), y = find(v);
if (x == y) {
if (ch[x]) {
a[++cnt] = w;
for (int i = 0; i < sz[x]; i++) g[cnt].push_back(c[x][i]);
f[x] = cnt, ch[cnt] = false;
}
} else {
if (sz[x] > sz[y])
swap(x, y), swap(u, v);
if (!ch[x] || !ch[y] || !d[u] || !d[v]) {
a[++cnt] = w;
if (ch[y])
for (int i = 0; i < sz[y]; i++) g[cnt].push_back(c[y][i]);
else
g[cnt].push_back(y);
if (ch[x])
for (int i = 0; i < sz[x]; i++) g[cnt].push_back(c[x][i]);
else
g[cnt].push_back(x);
f[x] = f[y] = cnt;
} else {
if (sz[x] > 1)
d[u] = false;
if (sz[y] > 1)
d[v] = false;
f[x] = y, sz[y] += sz[x];
for (int i = 0; i < sz[x]; i++) c[y].push_back(c[x][i]);
}
}
}
void init(int N, int M, std::vector<int> U, std::vector<int> V, std::vector<int> W) {
n = cnt = N, m = M;
for (int i = 1; i <= m; i++) e[i] = (E){ U[i - 1] + 1, V[i - 1] + 1, W[i - 1] };
sort(e + 1, e + 1 + m);
for (int i = 1; i < 2 * n; i++) {
f[i] = i;
if (i <= n)
sz[i] = 1, c[i].push_back(i), ch[i] = true, d[i] = true;
}
for (int i = 1; i <= m; i++) merge(e[i].u, e[i].v, e[i].w);
if (cnt > n)
dfs(cnt);
}
int getMinimumFuelCapacity(int X, int Y) {
++X, ++Y;
if (ch[find(X)])
return -1;
return a[lca(X, Y)];
}