本文出自我的掘金博客, 欢迎大家访问 传送门
最小生成树的最著名的算法有两个, 一个是Prim
算法, 另一个当然就是Kruskal
算法, 接下来, 我将尽我所能的介绍这两个算法, 也算是对自己学习的一个回顾吧
老规矩, 模板题传送门
首先, 介绍我更喜欢的, 也是相对更容易敲代码的Kruskal
算法
按照离散数学的定义
> 基本思想:按照权值从小到大的顺序选择n-1条边,并保证这n-1条边不构成回路。
> 具体做法:首先构造一个只含n个顶点的森林,然后依权值从小到大从连通网中选择边加入到森
林中,并使森林中不产生回路,直至森林变成一棵树为止。
故我们可以提炼出算法的流程如下
1.将边升序排序
2.判断是否能插入此边,插入后做:
1.inc(ans,路径长度)
2.合并连通分支
1.对于排序, 可以借助于库函数sort
2.对于判断是否可以插入的步骤, 我们的想法是借助于并查集, 如果这条边的两个祖先相同, 那么插入这条边显然会构成环, 故跳过
3.算法结束的标志是加入的边的数目为n - 1
算法已经介绍清楚了, 那么下面我们就来考虑一下存储边的数据结构
, 我们选择了如下所示的结构体数组
struct Edge {
int u; //起点
int v; //终点
int w; //权值
} e[100010];
对于并查集的处理就简单的提一下
1. 初始化
void init() {
for (int i = 1; i <= n; i++) {
fa[i] = i;
}
}
2.寻找祖先的函数, 路径压缩算法
int find (int x) {
return fa[x] == x ? fa[x] : fa[x] = find(fa[x]);
}
3.合并操作, 将两个属于不同集合的顶点合并到同一个集合, 即入赘操作
void union_(int x, int y) {
int fx = find(x);
int fy = find(y);
fa[fx] = fy;
}
感觉也没多少东西, 那就直接贴完整AC代码吧
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
int n, cnt, fa[MAXN], sum, ans;
void init() {
for (int i = 1; i <= n; i++) {
fa[i] = i;
}
}
int find (int x) {
return fa[x] == x ? fa[x] : fa[x] = find(fa[x]);
}
void union_(int x, int y) {
int fx = find(x);
int fy = find(y);
fa[fx] = fy;
}
struct Edge {
int u;
int v;
int w;
} e[100010];
bool cmp (Edge a, Edge b) {
return a.w < b.w;
}
//这一题应该采用并查集来判断是否会构成一个环, 然后用一个结构体数组来存储边的信息
int main() {
cin >> n;
init();
int h;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> h;
if (j > i) {
//存一半就可以了
e[++cnt].u = i;
e[cnt].v = j;
e[cnt].w = h;
}
}
}
sort(e + 1, e + 1 + cnt, cmp);
for (int i = 1; i <= cnt; i++) {
int u = e[i].u;
int v = e[i].v;
if (find(u) != find(v)) {
union_(u, v);
sum++;
ans += e[i].w;
if (sum == n - 1) {
break;
}
}
}
cout << ans;
return 0;
}
二, Prime
算法
Prim
算法也是一个贪心算法, 它和Kruskal
算法的区别在于Prim
算法是每次从一个点出发选择当前点的不构成环的最小的边, 而Kruskal
算法是从全局的角度, 从所有的边中选择不构成环的最小的边, 所以Prim
算法相对而言复杂一些
很显然, 每次都要从当前的顶点选择最优的边, 那么这就是一个很耗时的操作, 于是我们可以对这一步进行堆优化(其实就是使用优先队列
)
这个算法的数据结构相对复杂一些, 接下来我来介绍一下
bool vis[MAXN]; //用来判断这个顶点是否访问过
struct Edge {
int u; //起点
int v; //终点
int w; //权值
bool operator <(const struct Edge& n) const {
return w > n.w;
} //重载比较运算符, 用于后面的优先队列
};
vector <Edge> g[MAXN]; //向量数组, 用于存放每一个顶点所连接的边的信息
priority_queue <Edge> edge; //优先队列不解释
1.读取数据
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int w;
cin >> w;
if (w == 0) continue;
g[i].push_back(Edge{i, j, w});
}
}
2.以1为起始点, 将其相连边入队
vis[1] = true;
for (int i = 0; i < g[1].size(); i++) {
edge.push(g[1][i]);
}
3.执行Prim
算法, 直到边数为n - 1
为止
while (cnt < n - 1){
int w = edge.top().w;
int v = edge.top().v;
edge.pop();
if (vis[v]) {
//已经访问过了
continue;
}
vis[v] = true;
ans += w; //ans是结果
cnt++; //cnt是边的计数器
for (int i = 0; i < g[v].size(); i++) {
if (!vis[g[v][i].v]) {
edge.push(g[v][i]);
}
}
}