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 = 50005;
//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][35];
int fa[maxn];
int par[maxn];
bool vis[maxn];
int md[maxn][35];
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] = 1;
    
    for (int i = 0;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] + 1;
        
        md[to][0] = e.len;
        
        dfs(to);
    }
}

void pre_deal(int n)
{
    for (int i = 0;i <= n;i++)
    {
        p[i][0] = fa[i];
    }
    
    //int sz = (int)(log(n*1.0) / log(2.0)) + 1;
    
    for (int j = 1;j<= 20;j++)
    {
        for (int i = 1;i <= n;i++)
        {
            p[i][j] = p[p[i][j-1]][j-1];
            md[i][j] = max(md[i][j-1],md[p[i][j-1]][j-1]);
        }
    }
}

int query(int a,int b,int n)
{
    if (deep[a] < deep[b]) swap(a,b);
    
    int c = deep[a] - deep[b];
    
    int ans = 0;
    
    //int sz = (int)(log(n * 1.0) / log(2.0)) + 1;
    
    for (int i = 0;i <= 20;i++)
    {
        if (c & (1 << i))
        {
            ans = max(ans,md[a][i]);
            a = p[a][i];
            //printf("%d **\n",ans);
        } 
    }
    
    if (a == b) return ans;
    else
    {
        for (int i = 20;i >= 0;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][0]);
    ans = max(ans,md[b][0]);
    
    return ans;
}

void init(int n)
{
    for (int i = 0;i <= n;i++)
    {
        g[i].clear();
        par[i] = i;
    }
    
    es.clear();
    
    memset(vis,0,sizeof(vis));
    memset(md,0,sizeof(md));
    memset(deep,0,sizeof(deep));
    memset(md,0,sizeof(md));
}

int main()
{
    int n,m;
    
    int kase = 0;
    
    while (scanf("%d%d",&n,&m) != EOF)
    {
        if (kase++) printf("\n");
        
        init(n);
        
        for (int i = 0;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 = 0;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[1] = 0;
        //
        dfs(1);
        //printf("233\n");
        pre_deal(n);
        
        int q;
        
        scanf("%d",&q);
        
        for (int i = 0;i < q;i++)
        {
            int a,b;
            
            int ans = 0;
            
            scanf("%d%d",&a,&b);
            
            ans = query(a,b,n);
            
            printf("%d\n",ans);
        }
    }
    
    return 0;
}