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=55555;
const int INF=1e9;
const int POW =18;

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,1,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-1);
}

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

void kruskal(int n)
{
    int ans=0,cnt=0;
    rep(i,1,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]+1;
    p[u][0]=fa;
    Max[u][0]=c;

    rep(i,1,POW-1){//写rep的原因，忘记-1了，又因为数组开的[POW],下标越界了，不过返回wa实在很无语
        p[u][i]=p[p[u][i-1]][i-1];
        Max[u][i]=max(Max[u][i-1],Max[p[u][i-1]][i-1]);//注意下标...写顺手写成Max[Max[u][i-1]][i-1]
    }
    int sz=G[u].size();
    rep(i,0,sz-1){
        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 = 0; i < POW; i++ )
            if(del&(1<<i)){
                ans=max(ans,Max[b][i]);//注意处理顺序，先取最值，在更新当前点
                b=p[b][i];
            }
    }
    if( a != b ){
        for( int i = POW-1; i >= 0; 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][0]);
        ans=max(ans,Max[b][0]);
        a = p[a][0];
        b = p[b][0];
    }
    return ans;
}

void LCA(int n)
{
    int x,u,v;
    clr(p,0);
    d[1]=0;
    dfs(1,1,0);
    
    scanf("%d",&x);
    rep(i,1,x){
        scanf("%d%d",&u,&v);
        printf("%d
",lca(u,v));
    }
}

int main()
{
    int n,m,cnt=0;
    int u,v,c;
    while(~scanf("%d%d",&n,&m))
    {
        if(cnt++)puts("");
        init(n);
        rep(i,1,m){
            scanf("%d%d%d",&u,&v,&c);
            q.push((Edge){u,v,c});
        }
        kruskal(n);
        LCA(n);
    }
    return 0;
}
/*
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
*/