UVA 11354 Bond（最小生成树+LCA）

给出一个图，边权，然后m次询问：(u，v) 两点之间边权最小的路径上边权最大为多少；

一看就知道是求瓶颈路：给出一种求法，在最小生成数上，两点之间的最长边就为瓶颈路；

先对图生成最小树，然后考虑怎么求两点之间的最长边，路径必过LCA,那么就用倍增的思想来求瓶颈路；

在用倍增求LCA时，有一个数组p[i][j]，定义为 i 点 向上 跳 2 的 j 次方步到达的点，那么同样的，建立一个新的数组，max[i][j]，表示从 i 点出发 向上跳 j 步的路径上的最长边长为max[i][j]；预处理过程跟LCA的预处理差不多，求法也差不多，要注意，在一步一步向上跳的时候，先维护最大边长，再维护落点，最后看一下这个题格式控制就行了；

#include<stdio.h>
#include<algorithm>
#include<string>
#include<string.h>
#include<queue>
#include<vector>
#include<stack>
#include<math.h>
#include<map>
#include<iostream>
using namespace std;
#define maxn 100005
struct nodee
{
    int l;int r;int len;
    bool operator <(const nodee &x)const
    {
        if(len<x.len)
            return true;
        else
            return false;
    }
}a[maxn*2];
struct node
{
    int en,len,next;
}E[maxn*2];
int pr[maxn*2],cnt;
int n,m,f[maxn*2],dep[maxn*2],p[maxn][30],maxdis[maxn][30];
void inti()
{
    cnt=0;
    memset(dep,0,sizeof(dep));
    memset(p,0,sizeof(p));
    memset(pr,-1,sizeof(pr));
    memset(maxdis,-1,sizeof(maxdis));
    for(int i=0;i<=n;i++)
        f[i]=i;
}
void addedge(int st,int en,int len)
{
    E[cnt].en=en;
    E[cnt].len=len;
    E[cnt].next=pr[st];
    pr[st]=cnt;
    cnt++;
}
int findfa(int x)
{
    if(x==f[x])
        return x;
    return f[x]=findfa(f[x]);
}
void dfs(int u,int fa,int d)
{
    d++;
    for(int i=pr[u];i!=-1;i=E[i].next)
    {
        int v=E[i].en;
        int len=E[i].len;
        if(v==fa)
            continue;
        dep[v]=d;
        maxdis[v][0]=len;
        p[v][0]=u;
        dfs(v,u,d);
    }
}
int query(int x,int y)
{
    if(dep[x]>dep[y])
        swap(x,y);
    int f=dep[y]-dep[x];
    int ansx=-1;
    int ansy=-1;
    for(int i=0;(1<<i)<=f;i++)
    {
        if(((1<<i)&f)!=0)
        {
            ansy=max(ansy,maxdis[y][i]);
            y=p[y][i];
        }
    }
    if(x==y)
        return max(ansx,ansy);
    for(int i=(int)log2(n);i>=0;i--)
    {
        if(p[y][i]!=p[x][i])
        {
            ansx=max(ansx,maxdis[x][i]);
            ansy=max(ansy,maxdis[y][i]);
            y=p[y][i];x=p[x][i];
        }
    }
    ansx=max(ansx,maxdis[x][0]);
    ansy=max(ansy,maxdis[y][0]);
    return max(ansx,ansy);
}
int kase=0;
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(kase)
            puts("");
        else
            ++kase;
        inti();
        for(int i=0;i<m;i++)
            scanf("%d%d%d",&a[i].l,&a[i].r,&a[i].len);
        sort(a,a+m);
        for(int i=0;i<m;i++)
        {
            nodee now=a[i];
            int dx=findfa(now.l);
            int dy=findfa(now.r);
            if(dx!=dy)
            {
                f[dx]=dy;
                addedge(a[i].l,a[i].r,a[i].len);
                addedge(a[i].r,a[i].l,a[i].len);
            }
        }
        dep[1]=0;maxdis[1][0]=-1;p[1][0]=-1;
        dfs(1,-1,0);
        for(int j=1;(1<<j)<=n;j++)
        {
            for(int i=1;i<=n;i++)
            {
                maxdis[i][j]=max(maxdis[i][j-1],maxdis[p[i][j-1]][j-1]);
                p[i][j]=p[p[i][j-1]][j-1];
            }
        }
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int x;int y;
            scanf("%d%d",&x,&y);
            int ans=query(x,y);
            printf("%d\n",ans);
        }

    }

return 0;
}