UVa 11354 邦德（最小瓶颈路+LCA）

https://vjudge.net/problem/UVA-11354

题意：

有n个城市m条道路，每条道路有一个危险系数。先在有若干个询问，要求找到一条从s到t的路，使得途径所有边的最大危险系数最小。

思路：

最小瓶颈路肯定是在最小生成树上的。所有先求最小生成树。

然后将它转化成有根树，让fa[i]和cost[i]分别表示结点i的父亲编号和它与父亲之间的边权L[i]表示结点i的深度。

anc[i][j]表示结点i的第2^j级祖先的编号（j==0时候就是fa[i],如果第2^j祖先不存在，设为-1）。

maxcost[i][j]表示结点i和第2^j级祖先之间路径上的最大权值。

 #include<iostream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<vector>
 #include<queue>
 #include<cmath>
 #include<map>
 using namespace std;
 typedef long long LL;
 const int maxn=+;
 const int INF=0x3f3f3f;

 struct node
 {
     int u,v,d;
     bool operator < (const node& rhs) const
     {
         return d<rhs.d;
     }
 }edge[*maxn];

 int n,m;
 int cnt;
 int p[maxn];
 vector<int> g[maxn];
 vector<int> c[maxn];

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

 struct LCA
 {
     int n;
     int fa[maxn];
     int cost[maxn];
     int L[maxn];
     int anc[maxn][];  //结点i的第（1<<j)级祖先编号，anc[i][0]就是父亲fa[i],anc[i][j]=-1表示该祖先不存在
     int maxcost[maxn][];  //结点i和它的(1<<j)级祖先之间的路径上的最大权值

     void preprocess()   //预处理
     {
         for(int i=;i<n;i++)
         {
             anc[i][]=fa[i]; maxcost[i][]=cost[i];
             for(int j=;(<<j)<n;j++)  anc[i][j]=-;
         }
         for(int j=;(<<j)<n;j++)
         {
             for(int i=;i<n;i++)
                 if(anc[i][j-]!=-)
             {
                 int a=anc[i][j-];
                 anc[i][j]=anc[a][j-];
                 maxcost[i][j]=max(maxcost[i][j-],maxcost[a][j-]);
             }
         }
     }

     int query(int p,int q)
     {
         int tmp, log, i;
         if(L[p] < L[q]) swap(p,q);
         for(log=; (<<log) <= L[p]; log++);  log--;

         int ans=-INF;
         for(int i=log; i>=;i--)
             if(L[p]-(<<i)>=L[q])    //让p和q处于同一层
         {
             ans=max(ans,maxcost[p][i]);
             p=anc[p][i];
         }

         if(p==q)   return ans;  //LCA为p

         for(int i=log;i>=;i--)
             if(anc[p][i]!=-&&anc[p][i]!=anc[q][i])//否则，让p,q同时往上爬，保证爬的时候始终处于同一层
             {
                 ans=max(ans,maxcost[p][i]);p=anc[p][i];
                 ans=max(ans,maxcost[q][i]);q=anc[q][i];
             }
         ans=max(ans,cost[p]);
         ans=max(ans,cost[q]);
         return ans;  //LCA为fa[p]（或fa[q]）
     }
 }solver;

 void MST()
 {
     sort(edge,edge+cnt);
     int num=;
     for(int i=;i<cnt;i++)
     {
         int x=edge[i].u,y=edge[i].v;
         int u=find(x),v=find(y);
         if(u!=v)
         {
             p[u]=v;
             g[x].push_back(y); c[x].push_back(edge[i].d);
             g[y].push_back(x); c[y].push_back(edge[i].d);
             if(++cnt==n-)  break;
         }
     }
 }

 void dfs(int u,int fa,int level)   //无根树转有根树
 {
     solver.L[u]=level;
     for(int i=;i<g[u].size();i++)
     {
         int v=g[u][i];
         if(v!=fa)
         {
             solver.fa[v]=u;
             solver.cost[v]=c[u][i];  //cost就是v点到其父亲结点的权值
             dfs(v,u,level+);
         }
     }
 }

 int main()
 {
     //freopen("D:\\input.txt","r",stdin);
     int kase=;
     while(~scanf("%d%d",&n,&m) && n)
     {
         cnt=;
         for(int i=;i<n;i++)  {p[i]=i;g[i].clear();c[i].clear();}
         for(int i=;i<m;i++)
         {
             int x,y,d;
             scanf("%d%d%d",&x,&y,&d);
             edge[cnt].u=x-;
             edge[cnt].v=y-;
             edge[cnt].d=d;
             cnt++;
         }
         MST();
         dfs(,-,);
         solver.n=n;
         solver.preprocess();
         int q;
         if(kase++!=)  puts("");
         scanf("%d",&q);
         while(q--)
         {
             int x,y;
             scanf("%d%d",&x,&y);
             printf("%d\n",solver.query(x-,y-));
         }
     }
     return ;
 }