uva 11354 Bond

题意：

邦德在逃命！他在一个有N个城市，由M条边连接的道路网中。一条路的危险度被定义为这条路上危险度最大的边的危险度。

现在给出若干个询问，s，t，问从s到t的最小的危险度是多少。

思路：

首先可以证明这条路是固定的，就是最小生成树，证明略。

之后就是计算生成树上两点间的最长边，用prim算法预处理的话，由于N的规模较大，所以会超时。

由于MST是一棵树，想到树上两点之间的距离有O(log(n))的求法，即倍增求lca，按照同样的处理方法，只不过维护最大值，就可以在O(log(n))的时间内求出两点之间的最长边，查询为Q，总复杂度Qlog(n)。

代码：

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <vector>
 #include <math.h>
 using namespace std;

 const int maxn = ;
 //const int inf = 0x3f3f3f3f;

 struct edge
 {
     int fr,to,len;

     edge(int a,int b,int c)
     {
         fr = a;
         to = b;
         len = c;
     }
 };

 bool cmp(edge x,edge y)
 {
     return x.len < y.len;
 }

 vector<edge> g[maxn],es;
 int p[maxn][];
 int fa[maxn];
 int par[maxn];
 bool vis[maxn];
 int md[maxn][];
 int deep[maxn];

 int fin(int x)
 {
     if (x == par[x]) return x;
     else return par[x] = fin(par[x]);
 }

 void unit(int x,int y)
 {
     x = fin(x);
     y = fin(y);

     if (x == y) return;

     par[x] = y;
 }

 void dfs(int u)
 {
     vis[u] = ;

     for (int i = ;i < g[u].size();i++)
     {
         edge e = g[u][i];

         int to = e.to;

         if (vis[to]) continue;

         fa[to] = u;

         deep[to] = deep[u] + ;

         md[to][] = e.len;

         dfs(to);
     }
 }

 void pre_deal(int n)
 {
     for (int i = ;i <= n;i++)
     {
         p[i][] = fa[i];
     }

     //int sz = (int)(log(n*1.0) / log(2.0)) + 1;

     for (int j = ;j<= ;j++)
     {
         for (int i = ;i <= n;i++)
         {
             p[i][j] = p[p[i][j-]][j-];
             md[i][j] = max(md[i][j-],md[p[i][j-]][j-]);
         }
     }
 }

 int query(int a,int b,int n)
 {
     if (deep[a] < deep[b]) swap(a,b);

     int c = deep[a] - deep[b];

     int ans = ;

     //int sz = (int)(log(n * 1.0) / log(2.0)) + 1;

     for (int i = ;i <= ;i++)
     {
         if (c & ( << i))
         {
             ans = max(ans,md[a][i]);
             a = p[a][i];
             //printf("%d **\n",ans);
         }
     }

     if (a == b) return ans;
     else
     {
         for (int i = ;i >= ;i--)
         {
             if (p[a][i] != p[b][i])
             {
                 ans = max(ans,md[a][i]);
                 ans = max(ans,md[b][i]);

                 a = p[a][i];
                 b = p[b][i];
             }
         }
     }

     ans = max(ans,md[a][]);
     ans = max(ans,md[b][]);

     return ans;
 }

 void init(int n)
 {
     for (int i = ;i <= n;i++)
     {
         g[i].clear();
         par[i] = i;
     }

     es.clear();

     memset(vis,,sizeof(vis));
     memset(md,,sizeof(md));
     memset(deep,,sizeof(deep));
     memset(md,,sizeof(md));
 }

 int main()
 {
     int n,m;

     int kase = ;

     while (scanf("%d%d",&n,&m) != EOF)
     {
         if (kase++) printf("\n");

         init(n);

         for (int i = ;i < m;i++)
         {
             int a,b,c;

             scanf("%d%d%d",&a,&b,&c);

             es.push_back(edge(a,b,c));
         }

         sort(es.begin(),es.end(),cmp);

         for (int i = ;i < m;i++)
         {
             int x = es[i].fr,y = es[i].to;

             if (fin(x) == fin(y)) continue;

             unit(x,y);

             g[x].push_back(edge(x,y,es[i].len));
             g[y].push_back(edge(y,x,es[i].len));
         }

         deep[] = ;
         //
         dfs();
         //printf("233\n");
         pre_deal(n);

         int q;

         scanf("%d",&q);

         for (int i = ;i < q;i++)
         {
             int a,b;

             int ans = ;

             scanf("%d%d",&a,&b);

             ans = query(a,b,n);

             printf("%d\n",ans);
         }
     }

     return ;
 }