这个题是很经典的生成树问题。第一次接触时对倍增算法的理解还不够透彻，没能打出来正解。
首先，原题中给出的是一幅图，询问从某点出发到另一点“需要经过的最短边的最大值”。用floyd来解决是可以的，但是数据范围不能承受O(n^3)的复杂度。于是我们考虑：假设原图是连通的，那么我们从某点到另一点，一定至少存在一条路径；而明显有一条路径是最优的，满足它所经过的最小边最大。既然这样，我们能不能把这条路径找出来呢？于是我们想对原图做一些处理。新的图应该满足：
1. 图仍是连通的。
2. 任意两点间的一条路径满足上述最优条件。
于是我们想到了生成树。从贪心的角度考虑，两点之间一定有一条这样的最优路径是最大生成树上的唯一路径。说明：因为最大生成树外的一条边一定小于等于树上的边权，那么它不可能比这条树上路径更优。
求出MST后，我们要维护的是树上路径的最小值信息。路径本身可以用LCA来搞，可是路径上的信息怎么预处理呢？联想ST算法，我们虽然不能维护任意两点间的信息，但是可以用倍增的思想，维护w(i, k)表示节点i到它的2^k代祖先所需经过的最短路径。w(i, 0)就是生成树上该点入边的权，然后按k从小到大转移，转移方程w(i, k) = min(w(i, k - 1), w(f[i][k-1], k-1))。其中f数组是按倍增法求LCA记录的祖先信息。最后查询时，所求的ans随LCA倍增算法更新最小值即可。
注意原图是不连通的，我们生成的实际上是一个森林，kruscal算法里维护的并查集可以帮助判断两个点是否在一个联通块内。
代码：
- #include <iostream>
- #include <cstdio>
- #include <cstring>
- #include <cctype>
- #include <algorithm>
- #define maxn 10010
- #define maxm 50010
- #define inf (int)2e9
- using namespace std;
- template <typename T>
- void read(T &x) {
- x = 0;
- char ch = getchar();
- while (!isdigit(ch)) ch = getchar();
- while (isdigit(ch)) {
- x = x * 10 + (ch ^ 48);
- ch = getchar();
- }
- return;
- }
- int n, m, q;
- int head[maxn], top = 1;
- struct E {
- int to, nxt, w;
- } edge[maxn << 1];
- struct pE {
- int u, v, w;
- } pedge[maxm];
- bool cmp(pE a, pE b) {
- return a.w > b.w;
- }
- inline void insert(int u, int v, int w) {
- edge[++top] = (E) {v, head[u], w};
- head[u] = top;
- }
- namespace UFS {
- int fa[maxn], rk[maxn];
- void init1() {
- for (int i = 1; i <= n; ++i)
- fa[i] = i;
- }
- int find(int x) {
- if (fa[x] == x) return x;
- return fa[x] = find(fa[x]);
- }
- bool Union(int u, int v) {
- u = find(u), v = find(v);
- if (u == v) return false;
- if (rk[u] < rk[v]) swap(u, v);
- fa[v] = u;
- rk[u] = max(rk[u], rk[v] + 1);
- return true;
- }
- } using namespace UFS;
- void kruscal() {
- init1();
- sort(pedge + 1, pedge + 1 + m, cmp);
- for (int i = 1, cnt = 0; i <= m && cnt < n - 1; ++i) {
- int u = pedge[i].u, v = pedge[i].v, w = pedge[i].w;
- if (Union(u, v)) {
- insert(u, v, w), insert(v, u, w);
- ++cnt;
- }
- }
- }
- namespace LCA {
- const int LG(14);
- int w[LG+2][maxn], f[LG+2][maxn], d[maxn];
- bool vis[maxn];
- void dfs(int u, int pre, int depth) {
- d[u] = depth;
- f[0][u] = pre;
- vis[u] = true;
- for (int i = head[u]; i; i = edge[i].nxt) {
- int v = edge[i].to;
- if (vis[v]) continue;
- w[0][v] = edge[i].w;
- // cout << w[0][v];
- dfs(v, u, depth + 1);
- }
- }
- void init2() {
- for (int i = 1; i <= n; ++i) {
- if (vis[i]) continue;
- dfs(i, 0, 1);
- }
- for (int k = 1; k <= LG; ++k)
- for (int i = 1; i <= n; ++i) {
- f[k][i] = f[k-1][f[k-1][i]];
- w[k][i] = min(w[k-1][i], w[k-1][f[k-1][i]]);
- // cout <<w[k][i];
- }
- }
- int query(int u, int v) {
- if (find(u) != find(v)) return -1;
- int ans = inf;
- if (d[u] > d[v]) swap(u, v);
- int del = d[v] - d[u];
- for (int i = 0; del; ++i, del >>= 1)
- if (del & 1)
- ans = min(ans, w[i][v]), v = f[i][v];
- if (u == v) return ans;
- for (int i = LG; i >= 0; --i)
- if (f[i][u] != f[i][v]) {
- ans = min(ans, min(w[i][u], w[i][v]));
- u = f[i][u], v = f[i][v];
- }
- return min(ans, min(w[0][u], w[0][v]));
- }
- } using namespace LCA;
- int main() {
- read(n), read(m);
- int u, v, w;
- for (int i = 1; i <= m; ++i) {
- read(u), read(v), read(w);
- if (u != v)
- pedge[i] = (pE) {u, v, w};
- }
- kruscal();
- init2();
- read(q);
- while (q--) {
- read(u), read(v);
- printf("%d\n", query(u, v));
- }
- return 0;
- }
PS：看了这个题以后觉得树剖貌似是个好东西，有空学习一个。