最小生成树两种方法基本模版

最小生成树(Kruskal(克鲁斯卡尔)和Prim(普里姆))算法动画演示

Prim算法适用于稠密图
Kruskal适用于稀疏图

prim算法

从顶点开始，优先选择连结 两个顶点集合（已选顶点集合和未选顶点集合）的所有边 中，权值最小的，同时移动该顶点到已选顶点集合
再重复同样步骤

实现过程：不断更新三个列表
1.存储该顶点是否被选取 true：已选顶点集合 false：未选顶点集合
2.某一时刻，连结已选顶点集合 到 该顶点的 所有边中权值最小那条边的权值大小，初始状态都为INF
3.存储最小权值边两端顶点的信息。
两个顶点确定一条边，初始都为-1，表示不存在

选择一个顶点开始，当已选集合中每加入一个新的顶点，更新所有与该顶点相连 顶点的列表信息

因为权值一开始设置为INF
如果某个点与这一点的权制存在，并且小于INF，更新父亲列表，更新权值，

接下来扫描最小权值列表，找到最小值的所对应的顶点
将是否选择改成true，

接着以该顶点为新顶点重复操作

update——scan——add

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<algorithm>

#define ll long long
using namespace std;
//const int mod=;
#define INF 0x3f3f3f3f
const int maxn=10010;

int n,m; //n个点
int mat[maxn][maxn]; //
bool vis[maxn]; //看是否选择过
int d[maxn];    //记录任意一点到这个点的最近距离

int main(void){
    cin >> n;
    //邻接矩阵
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            cin >> mat[i][j];
    
    memset(d,INF,sizeof(d));
    memset(vis,0,sizeof(vis));
    
    int ans = 0;
    d[1] = 0; //从1开始，那么1到已选集合距离为0
    
    for(int i=1; i<=n; i++){
        int end = -1;
        
        for(int j=1; j<=n; j++){        //每次都遍历未选集合内的所有点
            if(!vis[j] && (end == -1||d[j]<d[end])) //总有一个比INF小
                end = j; //d[j]是最优的
        }
        ans += d[end];
        vis[end] = 1;     //用过了，标记到已选集合
        
        for(int j=1; j<=n; j++){
            //加了一个新的点进去，新的已选区域，这个新的点相连的边也加到可选列表内
            if(!vis[j] && mat[end][j]<d[j])
                //end是新加的，比较到j权值，j点之前可能已经添加过，所以比较，选择最小的
                d[j] = mat[end][j];
        }
    }
    cout << ans << endl;
    return 0;
}

Kruskal算法

将权值从小到大排列，每次选最小的，判断当前图内是否成环，成环：丢弃，选下一个
依次，直到选择边的个数为n-1

#include<iostream>
#include<cstdio>
#include<cstring>
#define ll long long
using namespace std;
//const int mod=;
#define INF 0x3f3f3f3f
const int maxn=1e6+10;

int n,m; //n个点m个边
//存边的数据
struct node{
    int from,to,val;
}edge[maxn];

bool cmp(node x,node y){
    return x.val < y.val;
}
int pre[maxn];

//并查集
int find(int x){
    return x == pre[x]?x:pre[x] = find(pre[x]);
}
void Union(int x,int y){
    pre[find(x)] = find(y);
}
int main(void){
    cin >> n >> m;
    int ans = 0;
    
    for(int i=0; i<=n; i++)
        pre[i] = i;
    
    for(int i=1; i<=m; i++)
        cin >> edge[i].from >> edge[i].to >> edge[i].val;
    
    sort(edge+1,edge+m+1,cmp);
    
    //扫描所有边
    for(int i=1; i<=m; i++){
        //如果一个是在有效集合，一个在无效集合：不能构成环，就连接起来——并查集
        if(find(edge[i].from) != find(edge[i].to)){
            ans += edge[i].val;
            Union(edge[i].from,edge[i].to);
        }
    }
    
    cout << ans << endl;
    
    return 0;
}