最小生成树模板【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=;
 const int M=2e5+;
 int n,m,tot=,num=;
 LL ans=;
 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=;i<=n;i++)f[i]=i;
     sort(G,G+tot);
     for(int i=;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-)
     {
         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==)continue;
         G[tot].u=a;
         G[tot].v=b;
         G[tot].w=v;
         tot++;
     }
     kruskal();
     return ;
 }

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=;i<V;i++)
     {
         mincost[i]=INF;
         vis[i]=;
     }
     mincost[]=; // 默认选第一个顶点为起始点
     int res=;

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

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