最小生成树模板【kruskal & prim】

CDOJ 1966 Kruskal 解法

时间复杂度O(mlogm) m为边数，这里主要是边排序占时间，后面并查集还好

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;

const int N=2002;
const int M=2e5+2;
int n,m,tot=0,num=0;
LL ans=0;
int f[N];
struct Node
{
    int u,v;
    LL w;
    bool operator < (const Node & b)
    {
        return w < b.w;
    }

}G[M];

int find(int x)
{
    return x==f[x]?x:f[x]=find(f[x]);
}

int unite(int x,int y)
{
    x=find(x);
    y=find(y);
    if(x!=y)f[x]=y;
}

void kruskal()
{
    for(int i=1;i<=n;i++)f[i]=i;
    sort(G,G+tot);
    for(int i=0;i<tot;i++)
    {
        int u=find(G[i].u);
        int v=find(G[i].v);
        if(u!=v)
        {
            unite(u,v);
            ans+=G[i].w;
            num++;
        }
    }
    if(num==n-1)
    {
        cout<<"yes"<<endl;
        cout<<ans<<endl;
    }
    else
        cout<<"no"<<endl;
}

int main()
{

    cin>>n>>m;

    while(m--)
    {
        int a,b,v,p;
        cin>>a>>b>>v>>p;
        if(p==0)continue;
        G[tot].u=a;
        G[tot].v=b;
        G[tot].w=v;
        tot++;
    }
    kruskal();
    return 0;
}

prim模板：主要用于稠密图，尤其是完全图的最小生成树

时间复杂度为O(n^2)，如果用最小堆优化，为O(mlogn) [实际为O((m+n)logn)，假设m边数>=n顶点数，从而简写]  算法分为两部分，一个找当前最小值，一个根据当前点的临边更新数组。logn获取最小值并从堆中删除，后用logn执行一条边的更新

int cost[N][N]; // 表示e=(u,v)的权值，不存在情况为INF
int mincost[N]; // 从集合x出发的边到每个顶点的最小权值
bool vis[N];    // 集合x内的顶点
int V;　　　　　　// 顶点数

int prim()
{
    for(int i=0;i<V;i++)
    {
        mincost[i]=INF;
        vis[i]=0;
    }
    mincost[0]=0; // 默认选第一个顶点为起始点
    int res=0;

    while(true)
    {
        int v=-1;
        for(int u=0;u<V;u++)
            if(!vis[u]&&(v==-1||mincost[u]<mincost[v]))v=u;

        if(v==-1)break;
        vis[v]=1;
        res+=mincost[v];
        for(int u=0;u<V;u++)
        {
            if(mincost[u]>cost[v][u])
                mincost[u]=cost[v][u];
        }
    }
    return res;
}