最小生成树（Kruska、Prim）

最新推荐文章于 2021-07-19 17:42:32 发布

原创最新推荐文章于 2021-07-19 17:42:32 发布 · 410 阅读

0 ·

CC 4.0 BY-SA版权

ACM-ICPC 2016暑期特训1 专栏收录该内容

26 篇文章

订阅专栏

本文详细介绍了两种经典的最小生成树算法——Kruskal算法和Prim算法。Kruskal算法通过并查集避免形成环路，适用于稀疏图；Prim算法从任意顶点开始逐步扩展，适用于密集图。文中提供了详细的实现代码，帮助读者理解算法原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Kruska:
将所有边从小到大加入，在此过程中判断是否构成回路
– 使用数据结构：并查集
– 时间复杂度：O(ElogE)
– 适用于稀疏

堆（结构体优先队列）

http://acm.hdu.edu.cn/showproblem.php?pid=1233

#include<bits/stdc++.h>
using namespace std;
const int N=1e3;
struct node
{
    int x,y,val;
    node(){}
    node(int a,int b,int c){x=a;y=b;val=c;}
    bool operator <(const node &xx)const
    {
        return xx.val<val;
    }
};
int pre[N];
int finds(int x)
{
    return x==pre[x]?x:pre[x]=finds(pre[x]);
}
bool bing(int x,int y)
{
    x=finds(x);
    y=finds(y);
    if(x!=y) {pre[x]=y;return 1;}
    return 0;
}
int main()
{
    int i,j,t,tt=0;
    int n,m;
    while(~scanf("%d",&n),n)
    {
        for(i=0;i<=n;i++) pre[i]=i;
        m=(n-1)*n/2;
        priority_queue<node> q;
        while(!q.empty()) q.pop();
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            q.push(node(a,b,c));
        }
        int ans=0;
        while(!q.empty())
        {
            node g=q.top();q.pop();
            if(bing(g.x,g.y)) ans+=g.val;
        }
        printf("%d\n",ans);
    }
}

sort(快排)

#include<bits/stdc++.h>
using namespace std;
const int N=1e2;
struct node
{
    int x,y,val;
    node(){}
    node(int a,int b,int c){x=a;y=b;val=c;}
}g[5000];
bool cmp(node xx,node yy)
{
    return xx.val<yy.val;
}
int pre[N];
int finds(int x)
{
    return x==pre[x]?x:pre[x]=finds(pre[x]);
}
bool bing(int x,int y)
{
    x=finds(x);
    y=finds(y);
    if(x!=y) {pre[x]=y;return 1;}
    return 0;
}
int main()
{
    int i,j,t,tt=0;
    int n,m;
    while(~scanf("%d",&n),n)
    {
        for(i=0;i<=n;i++) pre[i]=i;
        m=(n-1)*n/2;
        for(i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            g[i]=(node(a,b,c));
        }
        sort(g,g+m,cmp);
        int ans=0;n--;
        for(i=0;i<m,n;i++)
            if(bing(g[i].x,g[i].y)) ans+=g[i].val,n--;
        printf("%d\n",ans);
    }
}

Prim:
从任一节点出发，不断扩展
– 使用数据结构：堆
– 时间复杂度：O(ElogV) 或 O(VlogV+E)(斐波那契堆）
– 适用于密集图
– 若不用堆则时间复杂度为O(V2)

未优化

#include<bits/stdc++.h>
using namespace std;
const int N=1e2+7;
const int inf=0x3f3f3f3f;
int mp[N][N],dis[N],used[N];
int n;
void prim()
{
    int i,j,pos,mi,sum=0;
    memset(used,0,sizeof used);
    memset(dis,inf,sizeof dis);
    pos=1;used[1]=1;dis[1]=0;
    for(i=2;i<=n;i++)
    {
        for(j=1;j<=n;j++)
            if(!used[j]&&dis[j]>mp[pos][j])
            dis[j]=mp[pos][j];
        mi=inf;
        for(j=1;j<=n;j++)
            if(!used[j]&&dis[j]<mi)
            mi=dis[pos=j];
        used[pos]=1;
        sum+=mi;
    }
    cout<<sum<<endl;
}
int main()
{
    int i,j,t,tt=0;
    while(cin>>n,n)
    {
        memset(mp,0,sizeof mp);
        for(i=1;i<=n*(n-1)/2;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            mp[a][b]=mp[b][a]=c;
        }
        prim();
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=2*1e2+7;
const int inf=0x3f3f3f3f;
struct node{
    int x,val;
    node(){}
    node(int a,int b){x=a;val=b;}
    bool operator <(const node &xx)const
    {
        return val>xx.val;
    }
};
vector<node> g[N];
int used[N],dis[N],n;
void prim()
{
    int sum=0;
    priority_queue<node> q;
    memset(used,0,sizeof used);
    memset(dis,inf,sizeof dis);
    q.push(node(1,0));
    while(!q.empty())
    {
        node now=q.top();q.pop();
        int x=now.x;
        if(used[x]) continue;
        used[x]=1;
        sum+=now.val;
        for(int i=0;i<g[x].size();i++)
        {
            int xx=g[x][i].x;
            int val=g[x][i].val;
            if(!used[xx]&&dis[xx]>val)
                q.push(node(xx,dis[xx]=val));
        }

    }
    cout<<sum<<endl;
}
int main()
{
    int i,j,t,tt=0;
    while(cin>>n,n)
    {
        memset(g,0,sizeof g);
        for(i=0;i<n*(n-1)/2;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            g[a].push_back(node(b,c));
            g[b].push_back(node(a,c));
        }
        prim();
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=2*1e2+7;
const int inf=0x3f3f3f3f;
struct node{
    int to,val;
    node(){}
    node(int a,int b){to=a;val=b;}
    bool operator <(const node &xx)const
    {
        return val>xx.val;
    }
};
int mp[N][N];
int used[N],dis[N],n;
void prim()
{
    int sum=0;
    priority_queue<node> q;
    memset(used,0,sizeof used);
    memset(dis,inf,sizeof dis);
    q.push(node(1,0));
    while(!q.empty())
    {
        node now=q.top();q.pop();
        int from=now.to;
        if(used[from]) continue; used[from]=1;

        sum+=now.val;
        for(int i=1;i<=n;i++)
        {
            int val=mp[from][i];
            if(inf==val) continue;
            if(!used[i]&&dis[i]>val)
                q.push(node( i,dis[i]=val ));
        }
    }
    cout<<sum<<endl;
}
int main()
{
    int i,j,t,tt=0;
    while(cin>>n,n)
    {
        memset(mp,inf,sizeof mp);
        for(i=0;i<n*(n-1)/2;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            mp[a][b]=mp[b][a]=c;
        }
        prim();
    }
    return 0;
}