最小生成树模板

Kruskal

struct edge
{
    int u,v,w;
    edge(int _u=0,int _v=0,int _w=0):u(_u),v(_v),w(_w){}
    bool operator < (edge t) const {return w<t.w;}
}e[M];
int n,m;//n是点数，m是边数，点编号从1开始，边编号从0开始
int par[N];
void Init()
{
    m=0;
}
int Find(int x)
{
    if(par[x]==x) return x;
    else return par[x]=Find(par[x]);
}
ll Kruskal()
{
    for(int i=1;i<=n;i++) par[i]=i;
    sort(e,e+m);
    ll ans=0;
    int cnt=0;
    for(int i=0;i<m;i++)
    {
        int t1=Find(e[i].u);
        int t2=Find(e[i].v);
        if(t1!=t2)
        {
            par[t1]=t2;
            ans+=e[i].w;
            cnt++;
            if(cnt==n-1) break;
        }
    }
    return ans;
}

Prim

邻接矩阵

int n,u,v,w;
int vis[N],dis[N],cost[N][N];
void Init()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            cost[i][j]=inf;
}
ll Prim()
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) dis[i]=inf;
    dis[1]=0;
    ll ans=0;
    while(1)
    {
        int u=-1,v;
        for(v=1;v<=n;v++)
        {
            if(!vis[v]&&(u==-1||dis[u]>dis[v])) u=v;
        }
        if(u==-1) break;
        vis[u]=1;
        ans+=dis[u];
        for(v=1;v<=n;v++) dis[v]=min(dis[v],cost[u][v]);
    }
    return ans;
}

链式前向星+优先队列优化

struct edge
{
    int v,w,nxt;
    edge(int _v=0,int _w=0,int _nxt=0):v(_v),w(_w),nxt(_nxt){}
    bool operator < (edge t) const {return w>t.w;}
}e[M];
int n,m,u,v,w;//n是点数，m是边数，点编号从1开始，边编号从0开始
int head[N],vis[N],dis[N];
priority_queue<edge>q;
void Init()
{
    memset(head,-1,sizeof(head));
    m=0;
}
void Addedge(int u,int v,int w)
{
    e[m].v=v,e[m].w=w,e[m].nxt=head[u],head[u]=m++;
}
ll Prim()
{
    while(!q.empty()) q.pop();
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) dis[i]=inf;
    for(int i=head[1];i!=-1;i=e[i].nxt)
    {
        if(e[i].w<dis[e[i].v])
        {
            dis[e[i].v]=e[i].w;
            q.push(edge(e[i].v,e[i].w,e[i].nxt));
        }
    }
    int cnt=1;vis[1]=1;
    ll ans=0;
    while(!q.empty())
    {
        edge t=q.top();q.pop();
        int v=t.v;
        if(vis[v]) continue;
        vis[v]=1;
        ans+=t.w;
        cnt++;
        if(cnt>n) break;
        for(int i=head[v];i!=-1;i=e[i].nxt)
        {
            if(e[i].w<dis[e[i].v]&&!vis[e[i].v])
            {
                dis[e[i].v]=e[i].w;
                q.push(edge(e[i].v,e[i].w,e[i].nxt));
            }
        }
    }
    return ans;
}