UVA 11354 Bond 邦德 （RMQ，最小瓶颈MST）

题意：

　　n个城市，m条路，每条路有个危险值，要使得从s走到t的危险值最小。回答q个询问，每个询问有s和t，要求输出从s到t最小的危险值。（5万个点，10万条边）

思路：

　　其实要求的是任意点对之间的最小瓶颈路的权值。

　　先对图求一次MST，那么所有的瓶颈路都在上面。但是q<=5万，即使预先求出所有点对，也需要O(n*n)，太大了。如果对于每个询问才来找答案，这又更慢了。所以得优化。

　　优化方案（1）：先求出生成树，对于每次询问的两个点，求一次LCA，两个点到LCA所经过的边其中一条边就是答案。很不幸，如果树很稀疏，树枝又很长，那么每次求LCA相当于O(n)的复杂度。

　　优化方案（2）：鉴于方案（1），要解决的是树枝很长的情况，由于要求的是区间最值，那么类似于RMQ问题了，只是在树上而不是序列中而已。假如将某个点p到其LCA之间的一条链作为一个区间的话，那么这段区间的最值，就是p到(p+LCA)/2与(p+LCA)/2到LCA两个区间的最值再取最值。这又变成了类似于ST算法了。

　　

　　具体做法可以这样：

　　（1）预处理每个节点p到p+1,p+2...直到树根的这段区间的最值，那么得到m[p,p+1]，m[p,p+2]，m[p,p+4]...。大小是以2的幂为单位的。若某个点到树根的距离并不是刚好为2的整数次幂，那么这段放弃掉，因为总有点到树根的距离是恰好满足的，那么必要时，找这个区间即可。

　　（2）在查询时，两节点分别到他们的LCA所经过的边不断更新答案。

　　倍增算法：此代码用于优化求LCA的速度，以及从p到LCA这段区间的最值。保证在任何树的情况下都是O(logn)。

 void preprocess(int n)//预处理2的幂次大小的区间内的最值
 {
     for(int i=; i<=n; i++) //初始化，及先记录到父亲的距离
     {
         anc[i][]=far[i];
         maxcost[i][]=cost[i][far[i]];
         for(int j=; (<<j)<n; j++)
             anc[i][j]=-;
     }
     for(int j=; (<<j)<n; j++)
     {
         for(int i=; i<=n; i++ )
         {
             int e=anc[i][j-];
             if(e>)
             {
                 anc[i][j]=anc[e][j-];      //将2的j次幂，分成两个2的j-1次来组成。
                 maxcost[i][j]=max(maxcost[i][j-],maxcost[e][j-]);
             }
         }
     }
 }

 int query(int p,int q)  //先找LCA，再求答案
 {
     int tmp, log, i;
     if(level[p]<level[q])   swap(p,q);//保持p更深一些

     for(log=; (<<log)<=level[p]; log++);//统计最深要几层
     --log;
     int ans=-;
     for(int i=log; i>=; i--)//将p提到与q同层
     {
         if(level[p]-(<<i)>=level[q])//这一步关键，只要多于level[q]的部分都会被抹去
         {
             ans=max(ans, maxcost[p][i]);
             p=anc[p][i];
         }
     }

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

     for(int i=log; i>=; i--)//同时往LCA方向更新，直到成为LCA的孩子
     {
         if(anc[p][i]> && anc[p][i]!=anc[q][i] )
         {
             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][far[p]]);//还有一层，别忘了
     ans=max(ans, cost[q][far[q]]);

     return ans;
 }

主要优化代码注释

　　

 #include <bits/stdc++.h>
 #define INF 0x7f7f7f7f
 #define pii pair<int,int>
 #define LL long long
 using namespace std;
 const int N=;
 int a[N], b[N], w[N], seq[N];     //求MST用的
 int pre[N], level[N], far[N], maxcost[N][], anc[N][];
 int vis[N];
 vector<int>  vect[N];    //建树时用
 map<int,int> cost[N];

 int cmp(int a,int b){return w[a]<w[b];}
 int find(int x){return pre[x]==x? x: pre[x]=find(pre[x]);}  //并查集

 void DFS(int x,int flo)
 {
     vis[x]=;
     level[x]=flo;  //记录在哪一层
     for(int i=; i<vect[x].size(); i++)
     {
         int t=vect[x][i];
         if(!vis[t])
         {
             far[t]=x;  //用孩子索引父亲
             DFS(t, flo+);
         }
     }
 }

 void preprocess(int n)
 {
     for(int i=; i<=n; i++) //对于每个点
     {
         anc[i][]=far[i];
         maxcost[i][]=cost[i][far[i]]; //与父亲的距离。
         for(int j=; (<<j)<n; j++)    //初始化祖先为-1
             anc[i][j]=-;
     }
     for(int j=; (<<j)<n; j++)     //仅需到n-1即可。
     {
         for(int i=; i<=n; i++ )
         {
             int e=anc[i][j-];
             if(e>)
             {
                 anc[i][j]=anc[e][j-];      //将2的j次幂，分成两个2的j-1次来组成。
                 maxcost[i][j]=max(maxcost[i][j-],maxcost[e][j-]);
             }
         }
     }
 }

 int cal(int n,int m)
 {
     memset(maxcost, , sizeof(maxcost));
     memset(far, ,   sizeof(far));
     memset(level, ,  sizeof(level));
     memset(anc, 0x8f, sizeof(anc));
     //kruscal
     for(int i=; i<=n; i++)
     {
         pre[i]=i;
         cost[i].clear();
         vect[i].clear();
     }
     for(int i=; i<m; i++)
     {
         int u=find( a[seq[i]] );
         int v=find( b[seq[i]] );
         if(u!=v)
         {
             pre[u]=v;
             vect[a[seq[i]]].push_back(b[seq[i]]);
             vect[b[seq[i]]].push_back(a[seq[i]]);
             cost[a[seq[i]]][b[seq[i]]]=w[seq[i]];   //因为目前还不知道谁是父亲
             cost[b[seq[i]]][a[seq[i]]]=w[seq[i]];
         }
     }
     //dfs
     memset(vis, , sizeof(vis));
     DFS(, );
     preprocess(n);
     return ;
 }

 int query(int p,int q)  //先找LCA，再求答案
 {
     int tmp, log, i;
     if(level[p]<level[q])   swap(p,q);

     for(log=; (<<log)<=level[p]; log++);
     --log;
     int ans=-;
     for(int i=log; i>=; i--)
     {
         if(level[p]-(<<i)>=level[q])
         {
             ans=max(ans, maxcost[p][i]);
             p=anc[p][i];
         }
     }

     if(p==q)    return ans;

     for(int i=log; i>=; i--)
     {
         if(anc[p][i]> && anc[p][i]!=anc[q][i] )
         {
             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][far[p]]);
     ans=max(ans, cost[q][far[q]]);
     return ans;
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int n, m, q, x, y, k=;

     while(~scanf("%d%d",&n,&m))
     {
         if(k!=)  printf("\n");//格式
         k++;
         for(int i=; i<m; i++)
         {
             seq[i]=i;   //边号
             scanf("%d%d%d", &a[i], &b[i], &w[i]);
         }
         sort(seq, seq+m, cmp);
         cal(n, m);
         scanf("%d",&q);
         for(int i=; i<q; i++)
         {
             scanf("%d%d",&x,&y);
             printf("%d\n", query(x,y));
         }
     }
     return ;
 }

AC代码