【次小生成树】【Kruskal】【prim】【转】

原博客出处：https://blog.csdn.net/yasola/article/details/74276255

   通常次小生成树是使用Prim算法进行实现的，因为可以在Prim算法松弛的同时求得最小生成树上任意两点之间的最长边。但是利用Kruskal算法却没办法在松弛的同时求得。

    所以我们就要在Kruskal求完最短路后，对于每个顶点bfs一次，得到树上任意两点的最长边。之后求可以像之前一样枚举不在树上的边，代替找最小值了。

    两种方法的时间杂度是一样的，但Kruskal的实现代码回长非常多，不过Kruskal的实现可以处理Prim难以处理的重边。

一、Kruskal模板

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
using namespace std;
#define INF 0x3f3f3f3f
#define fi first
#define se second
#define mem(a,b) memset((a),(b),sizeof(a))

const int MAXV=100+3;
const int MAXE=200+3;

struct Edge
{
    int from,to,cost;
    Edge(int f=0,int t=0,int c=0):from(f),to(t),cost(c){}
    bool operator<(const Edge &other)const
    {
        return cost<other.cost;
    }
}edge[MAXE];

int V,E,par[MAXV],high[MAXV],the_max[MAXV][MAXV];
bool used[MAXE];//边是否使用的标记
bool vis[MAXV];
vector<pair<int,int> > G[MAXV];//最小生成树

void init()//初始化
{
    for(int i=1;i<=E;++i)
        used[i]=false;
    for(int i=1;i<=V;++i)
    {
        par[i]=i;
        high[i]=0;
        G[i].clear();
    }
}

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

bool unite(int a,int b)
{
    int fa=findfather(a),fb=findfather(b);
    if(fa==fb)
        return false;
    if(high[fa]>high[fb])
        par[fb]=fa;
    else
    {
        par[fa]=fb;
        if(high[fa]==high[fb])
            ++high[fb];
    }
    return true;
}

void bfs(int s)
{
    mem(vis,0);
    vis[s]=true;
    the_max[s][s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=0;i<G[u].size();++i)
        {
            int v=G[u][i].fi;
            if(!vis[v])
            {
                vis[v]=true;
                the_max[s][v]=max(the_max[s][u],G[u][i].se);
                the_max[v][s]=the_max[s][v];
                que.push(v);
            }
        }
    }
}

int main()
{
    int T_T;
    scanf("%d",&T_T);
    for(int cas=1;cas<=T_T;++cas)
    {
        printf("Case #%d : ",cas);
        scanf("%d%d",&V,&E);
        init();
        for(int i=0;i<E;++i)
            scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].cost);
        sort(edge,edge+E);
        int res=0;
        for(int i=0;i<E;++i)
            if(unite(edge[i].from,edge[i].to))
            {
                res+=edge[i].cost;
                used[i]=true;
                G[edge[i].from].push_back(make_pair(edge[i].to,edge[i].cost));
                G[edge[i].to].push_back(make_pair(edge[i].from,edge[i].cost));
            }
        bool ok=true;
        for(int i=2;i<=V;++i)
            if(findfather(i)!=findfather(1))
            {
                ok=false;
                break;
            }
        if(!ok)//不联通
        {
            puts("No way");
            continue;
        }
        if(E==V-1)//生成树唯一
        {
            puts("No second way");
            continue;
        }
        for(int i=1;i<=V;++i)
            bfs(i);
        int ans=INF;
        for(int i=0;i<E;++i)
            if(!used[i])
                ans=min(ans,res-the_max[edge[i].from][edge[i].to]+edge[i].cost);
        printf("%d
",ans);
    }
    
    return 0;
}

二、prim模板

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=100+10;
bool link[maxn][maxn],vis[maxn];
int w[maxn][maxn],lowc[maxn],pre[maxn],Max[maxn][maxn];
int n,m;
int prim()
{
    int i,j,p,k;
    int minc,res=0;
    memset(vis,false,sizeof(vis));
    memset(pre,0,sizeof(pre));
    memset(Max,0,sizeof(Max));
    vis[1]=true,pre[1]=1;
    for(i=2; i<=n; i++) //初始化
    {
        lowc[i]=w[1][i];
        pre[i]=1;
    }
    for(i=2; i<=n; i++) //prim
    {
        minc=inf,p=-1;
        for(j=1; j<=n; j++)
        {
            if(!vis[j]&&lowc[j]<minc)
            {
                minc=lowc[j];
                p=j;
            }
        }
        vis[p]=true;
        res+=minc;//最小生成树加权值
        Max[pre[p]][p]=minc;//直接相连的两点最大权值就是边权值本身
        link[pre[p]][p]=true;//将这两条边标记为最小生成树的边
        link[p][pre[p]]=true;
        for(k=1; k<=n; k++)
            Max[k][p]=max(Max[pre[p]][p],Max[k][p]);//非直接相连的最大权值需要不断更新
        for(j=1; j<=n; j++)
            if(!vis[j]&&lowc[j]>w[p][j])
            {
                lowc[j]=w[p][j];
                pre[j]=p;
            }

    }
    return res;
}
int main()
{
//     freopen("in.txt","r",stdin);
//     freopen("out.txt","w",stdout);
    int s,e,t,ans,ans1;

    while(~scanf("%d%d",&n,&m))
    {
        int i,j;
         bool ok=true;//是否唯一最小生成树的标志
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                w[i][j]=inf;
        memset(link,false,sizeof(link));
        for(i=1; i<=m; i++)
        {
            scanf("%d%d%d",&s,&e,&t);
            w[s][e]=t;
            w[e][s]=t;
        }
        ans=prim();//最小生成树的权值
        for(i=1; i<=n; i++)
        {
            for(j=i+1; j<=n; j++)
            {
                if(w[i][j]!=inf&&!link[i][j])
                {
                    ans1=ans+w[i][j]-Max[i][j];//ans1次小生成树的权值
                }
                if(ans1==ans)
                {
                    ok=0;
                    break;
                }
            }
            if(!ok)
                break;
        }
        printf("ans=%d ans1=%d
",ans,ans1);
    }
    return 0;
}