Uva 10462 Is There A Second Way Left? Kruskal求次小生成树

这两天做了三题次小生成树包括上篇博客都是用Prim算法写的；孤陋寡闻的我还以为smst就是用prim求；

直到碰到这题，很裸的次小生成树！但和以往都不一样的是它会有重边！

这样以来用prim算法考虑的话，used[ i ][ j ]数组就无法做标记；在删除边的时候也不知道怎么删除。

于是我想了一个办法来解决它。

设一个结构体

struct node
{
    int v[maxn];//重边的值
    int cnt;//该重边的数量
    int flag;//是否有重边
    int flag1;
}mark[maxn][maxn];

特意用来处理重边问题；mp[i][j]只要保存的是重边中最小的那条就不影响MST的求值；只要在算SMST的时候把重边考虑进去就行了。

结果……XJB胡写了162行代码，代码太丑，WA了N次，也不知道哪有问题；

/* ***********************************************
Author        :angon
************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define LL long long
#define maxn 210
#define N 100000000


int mp[maxn][maxn];
int used[maxn][maxn];
int Max[maxn][maxn];
int vis[maxn],lowc[maxn],pre[maxn];
int m,n;
struct node
{
    int v[maxn];
    int cnt;
    int flag;
    int flag1;
}mark[maxn][maxn];
int Prim()
{

    memset(Max,0,sizeof(Max));
    memset(used,0,sizeof(used));
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=n;i++)
    {
        pre[i]=1;
        lowc[i]=mp[1][i];
    }
    lowc[1]=0;
    vis[1]=1;
    pre[1]= -1;
    int ans=0;
    for(int i=2;i<=n;i++)
    {
        int minc=N,p=-1;
        for(int j=1;j<=n;j++)
            if(!vis[j] && lowc[j]<minc)
            {
                minc=lowc[j];
                p=j;
            }
        if(minc==N)
            return -1;
        ans+=minc;
        vis[p]=1;
        used[p][pre[p]]=used[pre[p]][p]=1;
        for(int j=1;j<=n;j++)
        {
            if(vis[j] && j!=p)
                Max[p][j]=Max[j][p]=max(Max[j][pre[p]],lowc[p]);
            if(!vis[j] && mp[p][j] < lowc[j])
            {
                lowc[j]=mp[p][j];
                pre[j]=p;
            }
        }
    }
    return ans;
}
int f[maxn][maxn];
int smst()
{

    int minc=N,ans=Prim();
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
        {
            if(mark[i][j].flag && used[i][j])
            {
                for(int k=0;k<mark[i][j].cnt;k++)
                    if(k!=f[i][j])
                        minc=min(minc,ans+mark[i][j].v[k]-mp[i][j]);
            }
            if(mp[i][j]!=N && !used[i][j])
                minc=min(minc,ans+mp[i][j]-Max[i][j]);
        }
    if(minc==N)
        return -1;
    return minc;
}

int main()
{
    int t,ca=1;
    scan(t);
    while(t--)
    {
        int u,v,w;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            for(int j=i+1;j<=n;j++)
            {
                mp[i][j]=mp[j][i]=N;
                f[i][j]=f[j][i]=0;
                mark[i][j].flag=mark[j][i].flag=0;
                mark[i][j].flag1=mark[j][i].flag1=0;
                mark[i][j].cnt=mark[j][i].cnt=1;
            }

        while(m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(mark[u][v].flag1)
            {
                mark[u][v].flag=1;
                int k = mark[u][v].cnt++;
      //          printf("k=%d\n",k);
                mark[u][v].v[k]=w;
                if(mp[u][v]>w)
                {
                    f[u][v]=f[v][u]=k;
                    mp[u][v] = mp[v][u] = w;
                }
                continue;
            }
            mp[u][v]=mp[v][u]=w;
            mark[u][v].v[0]=mark[v][u].v[0]=w;
            mark[u][v].flag1=mark[v][u].flag1=1;

        }
   //     printf("f=%d\n",f);
   //     for(int i=0;i<mark[4][5].cnt;i++)
   //         printf("%d\n",mark[4][5].v[i]);
   //     printf("mp=%d\n",mp[4][5]);
        int ans1=Prim();
        printf("Case #%d : ",ca++);
        if(ans1==-1)
        {
            printf("No way\n");
            continue;
        }
  //      printf("ans1=%d\n",ans1);
        int ans2=smst();
        if(ans2==-1)
            printf("No second way\n");
        else
            printf("%d\n",ans2);

    }
    return 0;
}

百度一下，原来重边用kruskal算法是极好的；又学到了。确是是这样，prim算法有点两两枚举点的感觉，与点的关系比较密切，而kruskal则是从边出发；当边有重边，再枚举点已不合适，从边出发非常符合常理。

kruskal求次小生成树和prim算法求 的核心思想应该说是一致的，都是先求出MST，再通过删除MST上的一条边，构造新的生成树；枚举所有的边，得出答案。Prim时间复杂度 O(V*V); kruskal时间复杂度 O(V*E);（自己分析的，应该没错吧0-0）

最终AC代码：

/* ***********************************************
Author        :angon
************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define LL long long
#define maxn 222
#define INF 1000000

struct Edge
{
    int u,v,w;
}edge[maxn];

bool cmp(Edge n1,Edge n2)
{
    return n1.w<n2.w;
}

int p[maxn],used[maxn];

int find(int x)
{
    if(x==p[x]) return x;
    return p[x]=find(p[x]);
}

int main()
{
   // freopen("out.txt","w",stdout);
   int t,n,m,ca=1;
   scan(t);
   while(t--)
   {
        scann(n,m);
        REP(i,0,m)
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
        sort(edge,edge+m,cmp);
        REPP(i,0,n) p[i]=i;
        int ans=0,cnt=0;
        REP(i,0,m)
        {
            int u=edge[i].u;
            int v=edge[i].v;
            int t1=find(u);
            int t2=find(v);
            if(t1!=t2)
            {
                ans+=edge[i].w;
                p[t1]=t2;
                used[cnt++]=i;
            }
            if(cnt==n-1) break;
        }
        printf("Case #%d : ",ca++);
        if(cnt < n-1)
        {
            printf("No way\n");
            continue;
        }
         /*求次小生成树*/
        if(m==n-1)
        {
            printf("No second way\n");
            continue;
        }
        int ans2=INF;
        //printf("cnt=%d\n",cnt);
        REP(i,0,cnt)
        {
            REPP(j,0,n) p[j]=j;
            int smst=0,ct=0;
            REP(j,0,m)
            {
                if(j==used[i]) //轮流删除MST中的一条边求S_MST
                    continue;
                int u=edge[j].u;
                int v=edge[j].v;
                int t1=find(u);
                int t2=find(v);
                if(t1!=t2)
                {
                    smst += edge[j].w;
                    p[t1]=t2;
                    ct++;

                }
                if(ct==n-1) break;
            }
            if(ct==n-1)
                ans2=min(ans2,smst);
        }
        if(ans2==INF)
            printf("No second way\n");
        else
            printf("%d\n",ans2);
   }
    return 0;
}