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;
}