UVA - 10462 Is There A Second Way Left?

题意：

给你一张无向图，让你判断三种情况：1.不是连通图（无法形成生成树）2.只能生成唯一的生成树 3.能生成的生成树不唯一（有次小生成树），这种情况要求出次小生成树的边权值和。

思路：

比较常见的次小生成树做法：先求出最小生成树，再依次使用不在最小生成树上的边与最小生成树连接，连接后必然出现且仅出现一个环（由于生成树上的任意两点之间都有唯一的一条路径，且图中所有的点都在生成树上），将这条边与环上除了这条边权值最大的边替换，就形成了新的生成树，在不断尝试新边的过程中维护一个最小的生成树的边权值和即是次小生成树的边权值和。

可以发现生成的环形成的路径即是两个端点与它们的LCA（最近公共祖先）的路径，所以可以用求LCA的办法顺便记录路径中边权的最大值。

代码：

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <queue>
 typedef long long ll;
 using namespace std;

 const int N=1e2+;

 struct edge {
     int id;
     int from;
     int to;
     int val;
 }E[N<<];

 struct cmp {
     bool operator()(edge a,edge b) {
         return a.val>b.val;
     }
 };

 int fir[N],nex[N<<],cnt;
 int pre[N],dis[N],dep[N];
 bool vis[N],used[N<<];
 int T=,t,n,m,cost;

 void init() {
     memset(fir,-,sizeof(fir));
     cost=cnt=;
 }

 void connect(int from,int to,int val,int id) {
     E[cnt]=(edge){id,from,to,val};
     nex[cnt]=fir[from];
     fir[from]=cnt++;
     E[cnt]=(edge){id,to,from,val};
     nex[cnt]=fir[to];
     fir[to]=cnt++;
 }

 bool prim() {
     int node=;//记录生成树上的点的数量。
     memset(vis,false,sizeof(vis));
     memset(used,false,sizeof(used));
     priority_queue <edge,vector <edge>,cmp> Q;
     Q.push((edge){-,,,});
     dep[]=;
     while(!Q.empty()) {
         edge q=Q.top();
         Q.pop();
         if(vis[q.to]) continue;
         vis[q.to]=true;
         cost+=q.val; node++;
         pre[q.to]=q.from;
         dis[q.to]=q.val;
         dep[q.to]=dep[q.from]+;//在求最小生成树的过程中顺便记录生成树上的点的深度以及父节点、与父节点连接的边的权值。
         used[q.id]=true;//记录哪些边在最小生成树上，到时在求次小生成树的过程中跳过这些边。
         for(int i=fir[q.to];i!=-;i=nex[i]) {
             int to=E[i].to;
             if(!vis[to]) Q.push(E[i]);
         }
     }
     if(node<n) return false;//生成树上的点少于n，说明不是连通图，无法形成最小生成树。
     return true;
 }

 int lca(int x,int y) {
     int MAX=;
     if(dep[x]>dep[y]) swap(x,y);
     while(dep[y]>dep[x]) {
         MAX=max(MAX,dis[y]);
         y=pre[y];
     }
     while(x!=y) {
         MAX=max(MAX,dis[y]);
         y=pre[y];
         MAX=max(MAX,dis[x]);
         x=pre[x];
     }
     return MAX;
 }

 void solve() {
     bool flag=false;
     int second=2e9;
     for(int i=;i<cnt;i+=) {
         if(used[E[i].id]) continue;
         flag=true;
         second=min(second,cost+E[i].val-lca(E[i].from,E[i].to));
     }
     if(flag) printf("Case #%d : %d\n",++T,second);//若除了最小生成树上的边以外没有剩下的边，那么没有次小生成树。
     else printf("Case #%d : No second way\n",++T);
 }

 int main() {
     scanf("%d",&t);
     while(t--) {
         scanf("%d%d",&n,&m);
         init();
         for(int i=;i<=m;i++) {
             int x,y,z;
             scanf("%d%d%d",&x,&y,&z);
             connect(x,y,z,i);
         }
         if(!prim()) {
             printf("Case #%d : No way\n",++T); continue;
         }
         solve();
     }
     return ;
 }