[noip2013]货车运输(kruskal + 树上倍增)

描述

A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

格式

输入格式

第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道路。

接下来 m 行每行 3 个整数 x、y、z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意：x 不等于 y，两座城市之间可能有多条道路。

接下来一行有一个整数 q，表示有 q 辆货车需要运货。

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。

输出格式

输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1。

样例1

样例输入1

 

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

样例输出1

 

3
-1
3

限制

每个测试点1s。

提示

对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q < 1,000； 
对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q < 1,000； 
对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q < 30,000，0 ≤ z ≤ 100,000。

因为货车要运输最大货物，必须在整张图的最大生成树上选边，可以想到kruskal算法，但此时若要对每一个询问进行一次遍历的话需要 O(mn) 的时间复杂度，那么就需要把答案预先处理出来。

RMQ问题的ST算法 是用 d(i, j) 表示 从 i 开始 长度为 2^j 的一段元素之间的最小值

那么 d(i, j) = min{d(i ,j - 1), d(i + 2 ^ (j - 1), j - 1)}; 从 i 开始长度为 2^j 的最小值 = min{从 i 开始长度为2^(j - 1) 的一段元素的最小值， 从i + 2^(j - 1) + 1开始长度为2^(j - 1)的最小值}；

这个题在处理时同样可以借鉴这种思路，这个题在树上(我也不知道在说啥)，所以：

以 f[i][j] 表示第i个结点的第2^j个祖先是哪个点，那么 f[i][0] 为第i个节点的父亲。

以 g[i][j] 表示第i个结点到 f[i][j](第i个结点的第2^j个祖先) 的最短距离，那么 g[i][0] 表示第i个节点到自己父亲的(最短)距离。

转移可以模仿ST算法：

f[i][j] = f[ f[i][j - 1] ][j - 1]; 第i个点的第2^j个祖先 = 【第i个点第2^(j - 1)的祖先】 的 【第2^(j - 1)的祖先】

g[i][j] = min(g[i][j - 1], g[ f[i][j - 1] ][j - 1]); 第i个结点到 自己的第2^j个祖先 的最短距离 = min{第i个结点到 自己的第 2^(j - 1) 个祖先 的最短距离,【 第i个结点的第2^(j - 1)个祖先】到 【自己的第2^(j - 1)个祖先】 的最短距离}

【】只是为了帮助断句。。。

之后若要查询(x, y)的最短距离只需查询 min{(x, pos)的最短距离，(y, pos)的最短距离} pos为x，y的最近公共祖先

那么借用dfs的思路即可预处理整张图得到f和g

 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include <algorithm>
 using namespace std;
 struct node {
     int x, y, val;
 }edge[];
 int n, m, cnt;
 bool cmp(node a, node b) { return a.val > b.val; }
 int u[], v[], next[], first[], w[];
 int in[], father[], hi[];
 void addedge(int st, int end, int value)
 {
     u[++cnt] = st, v[cnt] = end, w[cnt] = value;
     next[cnt] = first[st];
     first[st] = cnt;
 }
 int getfather(int x) { return father[x] == x ? x : father[x] = getfather(father[x]); }
 void kruskal()
 {
     int count;
     for (int i = ; i <= n; i++) father[i] = i;
     for (int i = ; i <= m; i++) {
         int st = edge[i].x, end = edge[i].y;
         int fa = getfather(father[st]), fb = getfather(father[end]);
         if (fa != fb) {
             addedge(st, end, edge[i].val);
             addedge(end, st, edge[i].val);
             father[fb] = fa;
             count++;
             if (count == n - ) return;
         }
     }
 }
 int vis[];
 int fa[][], Min[][];
 void dfs(int o)
 {
     vis[o] = ;
     for (int i = ; i <= ; i++) {
         if (hi[o] < ( << i)) break;
         fa[o][i] = fa[fa[o][i - ]][i - ];
         Min[o][i] = min(Min[o][i - ], Min[fa[o][i - ]][i - ]);
     }
     for (int i = first[o]; i; i = next[i]) {
         int end = v[i];
         if (!vis[end]) {
             fa[end][] = o;
             Min[end][] = w[i];
             hi[end] = hi[o] + ;
             dfs(end);
         }
     }
 }
 int lca(int l, int r)
 {
     if (hi[l] < hi[r]) swap(l, r);
     int t = hi[l] - hi[r];
     for (int i = ; i <= ; i++) {
         if (( << i) & t) l = fa[l][i];
     }
     for (int i = ; i >= ; i--) {
         if (fa[l][i] != fa[r][i]) {
             l = fa[l][i], r = fa[r][i];
         }
     }
     if (l == r) return l;
     return fa[l][];
 }
 int ask(int l, int r)
 {
     int ret = 0x3f3f3f3f;
     int t = hi[l] - hi[r];
     for (int i = ; i <= ; i++) {
         if (t & ( << i)) {
             ret = min(ret, Min[l][i]);
             l = fa[l][i];
         }
     }
     return ret;
 }
 int main()
 {
     memset(Min, 0x3f3f3f3f, sizeof(Min));
     scanf("%d%d", &n, &m);
     for (int i = ; i <= m; i++) {
         scanf("%d%d%d", &edge[i].x, &edge[i].y, &edge[i].val);
     }
     sort(edge + , edge +  + m, cmp);
     kruskal();
     for (int i = ; i <= n; i++) if (!vis[i]) dfs(i);
     int t, l, r;
     scanf("%d", &t);
     while (t--) {
         scanf("%d%d", &l, &r);
         if (getfather(father[l]) != getfather(father[r])) printf("-1\n");
         else {
             int pos = lca(l, r);
             printf("%d\n", min(ask(l, pos), ask(r, pos)));
         }
     }
     return ;
 }

变量名不好起啊。