UVA 11354 Bond（最小瓶颈路+倍增）

题意：问图上任意两点(u,v)之间的路径上，所经过的最大边权最小为多少？

求最小瓶颈路，既是求最小生成树。因为要处理多组询问，所以需要用倍增加速。

先处理出最小生成树，prim的时间复杂度为O(n*n)，kruskal为O(mlogm)。前者适合处理稠密图，后者适合处理稀疏图。

这里的倍增处理是值得记住的，在树上做多组询问；亦或是，将无向图缩点在询问，都是可以这样加速的。

注意：边权<=1e9

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #define clr(a,m) memset(a,m,sizeof(a))
 #define rep(i,a,b) for(int i=a;i<=b;i++)
 using namespace std;

 const int MAXN=;
 const int INF=1e9;
 const int POW =;

 struct Edge{
     int u,v,c;
     bool operator < (const Edge rhs)const {
         return c>rhs.c;
     }
 };

 priority_queue<Edge>q;
 vector<int>G[MAXN];
 vector<Edge>edge;

 int fa[MAXN];

 int p[MAXN][POW],Max[MAXN][POW],d[MAXN];

 void init(int n)
 {
     while(!q.empty())
         q.pop();

     edge.clear();
     rep(i,,n)
         G[i].clear();
 }

 void add(int u,int v,int c)
 {
     edge.push_back((Edge){u,v,c});
     int m=edge.size();
     G[u].push_back(m-);
 }

 int find(int x)
 {
     return x==fa[x]?x:fa[x]=find(fa[x]);
 }

 void kruskal(int n)
 {
     int ans=,cnt=;
     rep(i,,n)
         fa[i]=i;
     while(!q.empty())
     {
         Edge e=q.top();q.pop();
         int x=find(e.u);
         int y=find(e.v);
         if(x!=y){
             ans+=e.c;
             fa[x]=y;
             add(e.u,e.v,e.c);
             add(e.v,e.u,e.c);
         }
     }
 }

 void dfs(int u,int fa,int c)
 {
     d[u]=d[fa]+;
     p[u][]=fa;
     Max[u][]=c;

     rep(i,,POW-){//写rep的原因，忘记-1了，又因为数组开的[POW],下标越界了，不过返回wa实在很无语
         p[u][i]=p[p[u][i-]][i-];
         Max[u][i]=max(Max[u][i-],Max[p[u][i-]][i-]);//注意下标...写顺手写成Max[Max[u][i-1]][i-1]
     }
     int sz=G[u].size();
     rep(i,,sz-){
         Edge e=edge[G[u][i]];
         if(e.v==fa)
             continue;
         dfs(e.v,u,e.c);
     }
 }

 int lca( int a, int b )
 {
     int ans=-INF;
     if( d[a] > d[b] ) a ^= b, b ^= a, a ^= b;
     if( d[a] < d[b] ){
         int del = d[b] - d[a];
         for( int i = ; i < POW; i++ )
             if(del&(<<i)){
                 ans=max(ans,Max[b][i]);//注意处理顺序，先取最值，在更新当前点
                 b=p[b][i];
             }
     }
     if( a != b ){
         for( int i = POW-; i >= ; i-- )
             if( p[a][i] != p[b][i] ){
                  ans=max(ans,Max[a][i]);
                  ans=max(ans,Max[b][i]);
                  a = p[a][i];
                  b = p[b][i];
             }
         ans=max(ans,Max[a][]);
         ans=max(ans,Max[b][]);
         a = p[a][];
         b = p[b][];
     }
     return ans;
 }

 void LCA(int n)
 {
     int x,u,v;
     clr(p,);
     d[]=;
     dfs(,,);

     scanf("%d",&x);
     rep(i,,x){
         scanf("%d%d",&u,&v);
         printf("%d\n",lca(u,v));
     }
 }

 int main()
 {
     int n,m,cnt=;
     int u,v,c;
     while(~scanf("%d%d",&n,&m))
     {
         if(cnt++)puts("");
         init(n);
         rep(i,,m){
             scanf("%d%d%d",&u,&v,&c);
             q.push((Edge){u,v,c});
         }
         kruskal(n);
         LCA(n);
     }
     return ;
 }
 /*
 9 8
 1 2 10
 1 3 20
 2 4 20
 2 5 30
 3 6 30
 3 7 10
 4 8 30
 5 9 10
 36
 1 2
 1 3
 1 4
 1 5
 1 6
 1 7
 1 8
 1 9
 2 3
 2 4
 2 5
 2 6
 2 7
 2 8
 2 9
 3 4
 3 5
 3 6
 3 7
 3 8
 3 9
 4 5
 4 6
 4 7
 4 8
 4 9
 5 6
 5 7
 5 8
 5 9
 6 7
 6 8
 6 9
 7 8
 7 9
 8 9
 */