暑假acwing算法总结15：最小生成树

• 1、稠密图的prim算法：

• 思路：就是Dijstra，只不过每次更新的时候将d[j]更新成到集合的距离，其他思想一样先找到没有在集合之中离集合最近的点，将其的权值加加，然后用该最短点更新所有点，并把它标记为在集合中

#include<iostream>
#include<cstring>

using namespace std;
int n,m;
const int N=510,M=1e5+10;
int g[N][N];
int d[M];
bool st[M];

int prim()
{
    int res=0;
    memset(d,0x3f,sizeof d);
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!st[j]&&(t==-1||d[t]>d[j]))
                t=j;

        if(i&&d[t]==0x3f3f3f3f)return 0x3f3f3f3f;
        
        if(i)res+=d[t];
        //先加加答案再更新长度，否则要是有自环，当前距离会被更新，但是生成树中不能有自环会错误
        for(int j=1;j<=n;j++)
            d[j]=min(d[j],g[t][j]);
        st[t]=true;
    }
    return res;
}

int main()
{
    memset(g,0x3f,sizeof g);
    cin>>n>>m;
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(c,g[a][b]);
    }
    int t=prim();
    if(t==0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<t<<endl;
    return 0;
}

• 2、堆优化版的prim算法

• 又是贼像堆优化的Dijstra但是由于Kruskal算法的存在，显的堆优化的prim有些o_o …Kruskal明显更优，堆优化Prim又臭又长，还容易MLE直接不考虑

#include <cstring>
#include <iostream>
#include <queue>
using namespace std;

const int N=2e5+10,INF = 0x3f3f3f3f;
typedef pair<int,int> PII;
int h[N],e[N],w[N],ne[N],idx;
bool st[N];
int n,m;

void add(int a,int b,int c) 
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int Prim()
{
    int res=0,cnt=0;
    priority_queue<PII,vector<PII>,greater<PII>>q;
    q.push({0,1});
    while(!q.empty())
    {
        auto t=q.top();
        q.pop();
        int ver=t.second,dst=t.first;
        if (st[ver])continue;
        st[ver]=true,res+=dst,++cnt;

        for (int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if (!st[j]) 
            {
                q.push({w[i],j});
            }
        }
    }
    if (cnt!=n) return INF;
    return res;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for (int i=0;i<m;++i)
    {
        int a,b,w;
        cin>>a>>b>>w;
        add(a,b,w);
        add(b,a,w);
    }
    int t = Prim();
    if (t==INF)cout<<"impossible"<<endl;
    else cout<<t<<endl; 
    return 0;
}

• 3、稀疏图的Kruskal算法

• 先存边，再排序再用并查集判断加边，要是能加上，即不在一个集合则加边并把他们放到一个集合，在同一个集合则不考虑

#include<iostream>
#include<algorithm>

using namespace std;
const int N=1e5+10;
int n,m;

int f[N];
int d[N*2];
struct node
{
    int x,y,w;
}e[N*4];
bool cmp(node a,node b)
{
    return a.w<b.w;
}
int find(int u)
{
    if(u!=f[u])f[u]=find(f[u]);
    return f[u];
}

int main()
{
    cin>>n>>m;
    int cnt=-1;
    for(int i=1;i<=n;i++)
    f[i]=i;
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        e[++cnt].x=a,e[cnt].y=b,e[cnt].w=c;
        e[++cnt].x=b,e[cnt].y=a,e[cnt].w=c;
    }
    sort(e,e+cnt+1,cmp);
    int res=0;
    int coubt=0;
    for(int i=0;i<=cnt;i++)
    {
        int x=find(e[i].x);
        int y=find(e[i].y);
        if(x!=y)
        {
            f[x]=y;
            res+=e[i].w;
            coubt++;
        }
    }
    if(coubt==n-1)
    cout<<res<<endl;
    else puts("impossible");
    return 0;
}

• 2021-07-18写于南宁