POJ 2831 Can We Build This One：次小生成树【N^2预处理】

题目链接：http://poj.org/problem?id=2831

题意：

　　给你一个图，每条边有边权。

　　然后有q组询问(i,x)，问你如果将第i条边的边权改为x，这条边是否有可能在新的最小生成树中。

题解：

　　更改边权相当于新添加了一条边。

　　新边在新MST中的充要条件是：

　　　　加入新边后，在原来的MST上形成的环中，有一条旧边的边权>=x。

　　　　（因为如果这样的话，新边可以替换掉那条最大的边）

　　所以可以预处理出 maxn[i][j]：在原来的MST上，任意两点间路径上的最大边权。

　　dfs即可。

　　对于每一个新访问到的节点i，枚举每一个已访问过的节点j，那么：

　　　　maxn[i][j] = maxn[j][i] = max(maxn[j][fa[i]], v[fa[i]][i])

　　复杂度O(N^2)。

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <vector>
 #define MAX_N 1005
 #define MAX_M 100005

 using namespace std;

 struct E
 {
     int s;
     int t;
     int len;
     E(int _s,int _t,int _len)
     {
         s=_s;
         t=_t;
         len=_len;
     }
     E(){}
     friend bool operator < (const E &a,const E &b)
     {
         return a.len<b.len;
     }
 };

 struct Edge
 {
     int dest;
     int len;
     Edge(int _dest,int _len)
     {
         dest=_dest;
         len=_len;
     }
     Edge(){}
 };

 int n,m,q;
 int s[MAX_M];
 int t[MAX_M];
 int v[MAX_M];
 int par[MAX_N];
 int maxn[MAX_N][MAX_N];
 bool vis[MAX_N];
 vector<E> e;
 vector<Edge> edge[MAX_N];

 void read()
 {
     scanf("%d%d%d",&n,&m,&q);
     for(int i=;i<=m;i++)
     {
         scanf("%d%d%d",&s[i],&t[i],&v[i]);
         e.push_back(E(s[i],t[i],v[i]));
     }
 }

 void init_union_find()
 {
     for(int i=;i<=n;i++)
     {
         par[i]=i;
     }
 }

 int find(int x)
 {
     return par[x]==x ? x : par[x]=find(par[x]);
 }

 void unite(int x,int y)
 {
     int px=find(x);
     int py=find(y);
     if(px==py) return;
     par[px]=py;
 }

 bool same(int x,int y)
 {
     return find(x)==find(y);
 }

 int kruskal()
 {
     init_union_find();
     sort(e.begin(),e.end());
     int cnt=;
     int res=;
     for(int i=;i<e.size();i++)
     {
         E temp=e[i];
         if(!same(temp.s,temp.t))
         {
             cnt++;
             res+=temp.len;
             unite(temp.s,temp.t);
             edge[temp.s].push_back(Edge(temp.t,temp.len));
             edge[temp.t].push_back(Edge(temp.s,temp.len));
         }
     }
     return cnt==n- ? res : -;
 }

 void dfs(int now)
 {
     vis[now]=true;
     for(int i=;i<edge[now].size();i++)
     {
         Edge temp=edge[now][i];
         if(!vis[temp.dest])
         {
             for(int j=;j<=n;j++)
             {
                 if(vis[j])
                 {
                     maxn[j][temp.dest]=maxn[temp.dest][j]=max(maxn[j][now],temp.len);
                 }
             }
             dfs(temp.dest);
         }
     }
 }

 void work()
 {
     kruskal();
     memset(maxn,,sizeof(maxn));
     memset(vis,false,sizeof(vis));
     dfs();
     int i,x;
     while(q--)
     {
         scanf("%d%d",&i,&x);
         if(x<=maxn[s[i]][t[i]]) printf("Yes\n");
         else printf("No\n");
     }
 }

 int main()
 {
     read();
     work();
 }