次小生成树(POJ1679/CDOJ1959)

POJ1679

首先求出最小生成树，记录权值之和为MinST。然后枚举添加边(u,v)，加上后必形成一个环，找到环上非(u,v)边的权值最大的边，把它删除，计算当前生成树的权值之和，取所有枚举加边后生成树权值之和的最小值

思路：

最小生成树唯一性判断，求次小生成树的val再与最小生成树比较。
1.先用prim算法求出最小生成树。并在其过程中保存加入到MST中的Max[i][j]（ i 到 j 路径中的最大边 ） 
2.对未加入MST的边进行遍历：从MST中去掉i j路径中的最大边，加入未访问边G[i][j]，如果得到的生成树的权值和MST的相等，则存在次小生成树的权值=MST的权值和

 #include <algorithm>
 #include <iostream>
 #include <cstdio>
 #include <cmath>
 #include <cstring>
 using namespace std;
 #define INF 0x3f3f3f3f

 const int N = 1e3+;
 int G[N][N]; // graph matrix
 int f[N];    // pre node
 int vis[N];  // visited node
 int dis[N];  // main matrix: the edges(set-u)
 int mark[N][N];
 int Max[N][N]; // path from i to j max edge
 int n,m,best;

 int prim(int v)
 {
     int ans=;
     vis[v]=;
     for(int i=;i<=n;i++)
     {
         dis[i]=G[v][i];
         f[i]=v;
     }
     dis[v]=;
     for(int i=;i<n;i++) // n-1
     {
         int u=-;
         for(int j=;j<=n;j++)
             if(!vis[j]&&(u==-||dis[j]<dis[u]))u=j;
         if(u==-)break;
         vis[u]=;
         mark[u][f[u]] = mark[f[u]][u] = ;
         ans += dis[u];
         for(int j=;j<=n;j++)
         {
             // compare with visited node record path max edge
             if(vis[j])Max[u][j]=Max[j][u]=max(Max[j][f[u]],dis[u]);
             if(!vis[j]&&dis[j]>G[u][j])
             {
                 dis[j]=G[u][j];
                 f[j]=u;
             }
         }
     }
     return ans;
 }

 int SMST()
 {
     int mini=INF;
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)  //or for(int j=i+1;j<=n;j++)
         {
             if(i!=j&&!mark[i][j])
                 mini = min(mini,best+G[i][j]-Max[i][j]);
         }
     return mini;
 }

 int main()
 {
     int x,y,w,T;
     scanf("%d",&T);
     while(T--)
     {
         memset( vis,  ,sizeof(vis) );
         memset( Max,  ,sizeof(Max) );
         memset( f,  ,sizeof(f) );
         memset( dis,  ,sizeof(dis) );
         memset( mark,  ,sizeof(mark) );
         scanf("%d%d",&n,&m);
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
             {
                 if(i==j)G[i][j]==;
                 else G[i][j]=INF;
             }
         for(int i=;i<m;i++)
         {
             scanf("%d%d%d",&x,&y,&w);
             G[x][y]=w;
             G[y][x]=w;
         }
         best = prim();
         int temp = SMST();
         if(temp == best)
             printf("Not Unique!\n");
         else
             printf("%d\n",best);
     }
     return ;
 }

CDOJ 1959

思路：这道题会出现重边，用Kruskal算法处理起来比较方便。（用邻接表方便，邻接矩阵还要考虑同两点之间的多条权值相同的边。）

次小生成树的权值如果等于最小生成树的权值， 其替换边只会是权值相同的边，于是可以把权值相同边放在一起考虑，分别判断全部没有合并时有多少可以合并（cnt1记录的是可以加入集合的边数），边合并边判断有多少可以合并（cnt2记录的是选中一条加入到集合），如果可选的大于构成最小生成树所需要的，那么就存在一种相同的边权可以替换原来的，从而最小生成树不唯一。

 #include <bits/stdc++.h>
 #define LL long long
 using namespace std;
 const int N = 2e5+;
 struct Node
 {
     int u,v;
     LL w;
 }G[N];

 int n,m;
 int f[];
 int find(int x)
 {
     return x==f[x]?x:f[x]=find(f[x]);
 }

 bool cmp(Node & a, Node & b)
 {
     return a.w<b.w;
 }

 void kruskal()
 {
     int cnt1=;
     int cnt2=;
     for(int i=;i<=n;i++)f[i]=i;
     sort(G,G+m,cmp);
     for(int i=;i<m;)
     {
         int j=i;
         while(j<m&&G[j].w==G[i].w)
         {
             int u = find(G[j].u);
             int v = find(G[j].v);
             if(u!=v)cnt1++;
             j++;
         }
         j=i;
         while(j<m&&G[j].w==G[i].w)
         {
             int u = find(G[j].u);
             int v = find(G[j].v);
             if(u!=v){
                 cnt2++;
                 f[u]=v;
             }
             j++;
         }
         i=j;
         if(cnt1>cnt2)break;
     }
     if( cnt1 > cnt2 ){
         printf("zin\n");
     }else{
         printf("ogisosetsuna\n");
     }
 }

 int main()
 {
     int x,y;
     LL w;
     cin>>n>>m;
     for(int i=;i<m;i++)
     {
         cin>>x>>y>>w;
         G[i].u=x;
         G[i].v=y;
         G[i].w=w;
     }
     kruskal();
     return ;
 }