[笔记]Kruskal和Prim算法的比较

公式如果有滚动条影响阅读的话，右键公式>Math Settings>Math Renderer>SVG即可。

---

最小生成树及两个算法的简介

生成树即在一张图上找到连接所有顶点的一棵树，显然如果点数为$n$，这棵生成树的边数就是$n-1$。

最小生成树（Minimum Spanning Tree）就是这张图上边权之和最小的生成树。

常用的两个最小生成树算法有两个：Kruskal和Prim。两个算法都是基于贪心的思想，理解起来也十分简单，下面把边权具象为边的长度来理解。

Kruskal算法的思想是：将所有边长度从小到大排序，依次遍历，如果加入这条边不会形成环，就直接加入。当边数$=$点数$-1$时，完成最小生成树。

（该算法因需要判断成环，所以需要并查集的参与，如果不会可以去搜索更多信息）

Prim算法的思想是：随便选一个点开始，向周围找一个距离最近的点，形成一个整体，接着找这个整体与周围距离最近的点，加入这个整体，重复上述步骤直到所有点被加入。

推荐参考此视频，下面的代码与视频内容较为贴合，结合理解更好（特别是Prim算法的一堆数组）。

代码

Kruskal

#include<iostream>
#include<queue>
#include<algorithm>
#define MAXN 1010
#define MAXM 1010
using namespace std;
struct edge{
    int u,v,w;
}edges[MAXM];
bool cmp(edge a,edge b){
    return a.w<b.w;
}
int n,m,fa[MAXN],sum;
int find(int x){
    if(fa[x]==x) return x;
    return fa[x]=find(fa[x]);
}
queue<int> path;
int main(){
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>edges[i].u>>edges[i].v>>edges[i].w;
    }
    for(int i=0;i<n;i++) fa[i]=i;
    sort(edges,edges+m,cmp);
    int cnt=0;
    for(int i=0;i<m;i++){
        int u=find(edges[i].u),v=find(edges[i].v);
        if(u==v) continue;
        fa[u]=v;
        cnt++;
        sum+=edges[i].w;
        path.push(i);
        if(cnt>=n-1) break;
    }
    cout<<sum<<"\n";
    //记录边来存图，所以此处只输出边的编号
    while(!path.empty()){
        cout<<path.front()<<" ";
        path.pop();
    }
    return 0;
}

Prim

#include<iostream>
#include<cstring>
#define MAXN 1010
using namespace std;
int map[MAXN][MAXN],mindist[MAXN],parent[MAXN];
bool selected[MAXN];
int n,m,sum;
int main(){
    memset(mindist,127,sizeof mindist);//INF
    int maxx=mindist[0];
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int u,v,w;
        cin>>u>>v>>w;
        map[u][v]=map[v][u]=w;
    }
    int current=0;
    for(int i=0;i<n-1;i++){
        selected[current]=1;//1.Update 
        for(int j=0;j<n;j++){
            if(!selected[j]&&map[current][j]){
                if(map[current][j]<mindist[j]){
                    mindist[j]=map[current][j],parent[j]=current;
                }
            }
        }
        int minn=maxx,minpos=-1;//2.Scan
        for(int j=0;j<n;j++){
            if(!selected[j]&&mindist[j]<minn){
                minn=mindist[j],minpos=j;
            }
        }
        sum+=minn,current=minpos;//3.Add
    }
    cout<<sum<<endl;
    //用了邻接矩阵存，所以此处只输出节点编号
    for(int i=1;i<n;i++){
        cout<<i<<" => "<<parent[i]<<"\n";
    }
    return 0;
}

附视频中的图例

Input:
9 14
0 1 4
0 7 8
1 7 11
1 2 8
7 8 7
6 7 1
2 8 2
6 8 6
2 5 4
5 6 2
2 3 7
3 5 14
3 4 9
4 5 10
Output:
37

比较

我们可以发现，Prim算法每次都要遍历一遍所有点，找出与已确定区间相连的边，无论两点之间有无边，我们都需要每轮遍历一次。所以Prim算法的时间复杂度是$O(n^2)$，适用于点少边多的图（稠密图），存储方式也一般使用邻接矩阵；

而Kruskal算法与点无关，整个过程就是按边的权值排序，依次选择，所以与点的数量无关。故时间复杂度是$O(mlogm)$，适用于点多边少的图（稀疏图）。存图只需要把边记录下来即可，不过需要用并查集维护一下点。