uva 11354 Bond

这题要求最小瓶颈路 ， 由于数据太多 ， 所以用一般的bfs或dfs肯定会超时 。

在这个题目上就应该充分的考虑到 ， 最小生成树是一棵树 ， 所有就可以通过树的性质来解决这个问题 。
1、首先把最小生成树 ， 建成一颗有根树 ， 最好用bfs因为dfs可能会爆栈。
2、在建树的时候 ， 记录每个点的深度（根节点的深度为0）、每个节点的父亲节点（根节点的为-1）、每个节点和父亲节点的距离（根节点为0）；
3、然后再通过题目给出的两个节点 ，  来遍历这颗树 。
4、如果这两个节点的深度不一样 ， 那么就先要把深度调成一样 ，
5、深度一样之后 ， 再同时往树根的方向遍历 ， 则在这个遍历过程 ， 一定会得到两个节点的祖先是一样的 ， 到了这个时候就得到了我们想要的结果。

时间复杂度分析：这个算法之所以快 ， 是因为我们两个节点同时在走 ， 就等于是双向搜索一样 ， 并且大多数情况下 ， 都不需要遍历所有的节点。

代码：

#include
#include
#include
#include
#include
#include
#include
using namespace std;

struct node
{
    int from , to ;
    int dist;
    node(int from , int to , double dist)
    {
        this->from = from;
        this->to = to;
        this->dist = dist;
    }
    bool operator <(const struct node &ans) const
    {
        return dist > ans.dist;
    }
};  // 这是为了用优先队列来存储所有边

const int MAXN = 50000+5 ;
int n , m  , p[MAXN] , f[MAXN];  //  记录父亲节点 、 深度
int dist[MAXN];  //  记录节点和父亲节点的距离
priority_queueedge;

void init()
{
    int i , x , y , z;
    for(i = 1; i <= n; i++)
        f[i] = i;
    for(i = 1; i <= m; i++)
    {
        scanf("%d %d %d" , &x , &y  , &z);
        edge.push(node(x , y , z));
    }
    memset(dist , 0 , sizeof(dist));
    memset(p , 0 , sizeof(p));
}

int find(int x)  //并查集 ， 来判断新加入的两个节点是否属于同一个连通图
{
    int y = x;
    while(x != f[x])
        x = f[x];
    while(y != x)
    {
        int xy = f[y];
        f[y] = x;
        y =xy;
    }
    return x;
}

void mintree()  //  求最小生成树 ， 并将其转变为有根树
{
    int bz =0  , done[MAXN];
    vectords[MAXN];
    vectorq[MAXN];
    while(!edge.empty())
    {
        struct node s = edge.top();
        edge.pop();
        int x = find(s.from) , y = find(s.to);
        if(x != y)
        {
            f[y] = x;
            bz += 1;
            q[s.from].push_back(s.to); //用邻接表来记录最小生成树的边 ， 并记录所加入边的权 ， 并使其相对应
            q[s.to].push_back(s.from);
            ds[s.to].push_back(s.dist);
            ds[s.from].push_back(s.dist);
        }
        if(bz == n-1)  break;  //  如果加入的边达到n-1时 ， 最小生成树就完成了
    }
    while(!edge.empty())  edge.pop();  //  放出优先队列占用的空间 ， 由于这个题目的数据太大
    memset(done , 0 , sizeof(done));
    memset(f , 0 , sizeof(f));
    f[1] = 0;
    done[1] = 1;
    queuesq ;
    sq.push(1);
    p[1] = -1;
    while(!sq.empty())
    {
        int u_bian = sq.front(); sq.pop();
        for(int i = 0 ; i < q[u_bian].size() ; i++)
        {
            int zy = q[u_bian][i];
            if(done[zy])  continue ;
            p[zy] = u_bian;  //  父亲节点
            f[zy] = f[u_bian]+1; //  深度
            dist[zy] = ds[u_bian][i];  //  和父亲节点的距离
            done[zy] = 1; //  标记这个点 ， 已经遍历过了
            sq.push(zy);
        }
    }
}

int solve(int x , int y)
{
    int m1 = -1 , m2 = -1;  //  初始化两个节点在遍历过程中的最大边权
    if(f[x] > f[y])   //  当这两个节点深度不一样时
    {
        while(f[x]>f[y])
        {
            if(m1 < dist[x])  m1 = dist[x];  //  改变最大边权
            x = p[x]; //  向上走后的节点 ， 也就是其父亲节点
        }
    }
    else if(f[x] < f[y])
    {
        while(f[x] < f[y])
        {
            if(m2 < dist[y])  m2 = dist[y];
            y = p[y];
        }
    }
    while(x != y)  //  这时 ， 两个节点的深度已经一样了
    {
        if(m1 < dist[x])  m1= dist[x];  //  两个节点同时向上走 ， 直到两个节点相同时
        if(m2 < dist[y])  m2 = dist[y];
        x = p[x];
        y = p[y];
    }
    return m1>m2?m1:m2;  // 返回两个节点中的最大边权
}

int main()
{
    int t = 0;
    while(scanf("%d %d" , &n , &m) != EOF)
    {
        int i , q;
        init();
        if(t++ != 0)
            puts("");
        mintree();
        cin>>q;
        int x , y;
        for(i = 1; i <= q; i++)
        {
            scanf("%d %d" , &x , &y);
            printf("%d\n" , solve(x , y));
        }
        for(; !edge.empty(); )
            edge.pop(); 
        //cout<<endl;
    }
    return 0;
}