第57天，图论07，两个最小生成树算法的讲解💪(ง •_•)ง💪，编程语言：C++
目录
题目：53. 寻宝（第七期模拟笔试） (kamacoder.com)
prim算法精讲
拓展
总结：
kruskal算法精讲
拓展
总结
题目：53. 寻宝（第七期模拟笔试） (kamacoder.com)
本题是标准的最小生成树的题目。生成树是指包含图的全部顶点的一个极小连通子图。而最小生成树，就是在图的边有权值的情况下，权值相加和最小的生成树。（最小生成树的边是顶点数 - 1；最小生成树可能有多个，但边的权值之和总是唯一且最小的）
以本题的示例为例，有7个顶点，因此我们应该找到 7 - 1 = 6 条边把这7个点连接在一起，并使得所得的权值是最小的。
解决最小生成树问题的方法主要有两种：1.Prim算法；2.Kruskal算法
prim算法精讲
文档讲解：代码随想录prim算法精讲
prim算法采用了贪心的策略，从一个节点出发，每次寻找距离最小的节点，并逐渐加入最小生成树当中。
prim算法的核心三步，也称之为prim三部曲：
- 第一步，选距离生成树最近节点（距离值最小）
- 第二步，最近节点加入生成树
- 第三步，更新非生成树节点到生成树的距离（即更新minDist数组）
minDist数组用来记录每一个节点距离最小生成树的最近距离。 理解这一点非常重要，这也是 prim算法最核心要点所在。
1. 初始状态：minDist数组里的数值初始化为最大数，因为本题 节点距离不会超过10000，所以 初始化最大数为 10001就可以。这是默认每个节点距离最小生成树是最大的，这样后面我们才便于更新。
2.开始构造最小生成树：一句prim三部曲进行分析
① 第一步，选距离生成树最近节点：选择距离最小生成树最近的节点，加入到最小生成树，刚开始还没有最小生成树，所以随便选一个节点加入就好。（因为最后每个节点都会到最小生成树里面）
② 第二步，最近节点加入生成树：假设节点1已经是最小生成树里面的节点了。
③第三步，更新非生成树节点到生成树的距离，也就是更新minDist数组：我们通过遍历生成树中的节点，然得到非生成树到节点的距离。例如通过节点1我们知道：节点2 与 节点1 的距离为1，比原先的 距离值10001小，所以更新minDist[2]；节点3 和 节点1 的距离为1，比原先的 距离值10001小，所以更新minDist[3]；节点5 和 节点1 的距离为2，比原先的 距离值10001小，所以更新minDist[5]。最后可以得到：
同时需要标记minDist数组里更新的权值，是哪两个节点之间的权值，例如 minDist[2] =1 ，这个 1 是 节点1 与 节点2 之间的连线，清楚这一点对最后我们记录最小生成树的权值总和很重要。
3.进行prim三部曲循环：
① 第一步，选距离生成树最近节点：选取一个距离最小生成树（节点1）最近的非生成树里的节点，节点2，3，5 距离 最小生成树（节点1）最近，选节点 2（其实选节点3或者节点2都可以，距离一样的）加入最小生成树。
② 第二步，最近节点加入生成树：此时节点1 和节点2，已经算最小生成树的节点。
③第三步，更新非生成树节点到生成树的距离，也就是更新minDist数组：
- 节点3 和 节点2 的距离为2，和原先的距离值1 小，所以不用更新。
- 节点4 和 节点2 的距离为2，比原先的距离值10001小，所以更新minDist[4]。
- 节点5 和 节点2 的距离为10001（不连接），所以不用更新。
- 节点6 和 节点2 的距离为1，比原先的距离值10001小，所以更新minDist[6]。
之后不断重复这个过程，最后我们就可以得到：
最后得到了一个最小生成树，绿色的边将所有节点链接到一起，并且保证权值是最小的，因为我们满足在更新minDist数组的时候，都是选距离最小生成树最近的点加入到树中。最后我们要求最小生成树里边的权值总和，就是把最后的minD
最后根据以上的过程，我们可以写出代码：
#include <iostream>
#include <vector>
#include <climits> //这个头文件包含了各种类型的最大值和最小值，例如：INT_MAX
using namespace std;
int main() {
int v, e;
cin >> v >> e;
//采用邻接表的方式保存图，一般空位置我们会选择0来作为权值，
//但本题由于我们需要比较出最小值，因此空位置我们选取10001便于进行遍历
int s, t, k;
vector<vector<int>> grid(v + 1, vector<int>(v + 1, 10001));
while(e--) {
cin >> s >> t >> k;
//因为是无向图，两边都得给予赋值
grid[s][t] = k; // k 为权值
grid[t][s] = k;
}
vector<int> minDist(v + 1, 10001); //minDist数组，记录每个节点到最小生成树的距离
vector<bool> isInTree(v + 1, false); //记录当前点是否在最小生成树内
for(int i = 1; i < v; i++) { //注意要从节点1开始，且只需要遍历V-1次就能覆盖所有节点，加上v的话，最后一次是多余的不会改变minDist里面的值
//1.prim第一步，选取距离生成树最近的点
int cur = 0; //确定选取的点
int maxDist = INT_MAX; //记录当前距离的最小值
for(int j = 1; j <= v; j++) {
if(!isInTree[j] && minDist[j] < maxDist) { //如果当前点没有加入最小生成树，且距离最近
cur = j;
maxDist = minDist[j];
}
}
//2.prim第二步，将节点加入到最小生成树当中
isInTree[cur] = true;
//3.prim第三步，依据节点cur，更新minDist数组
for(int k = 1; k <= v; k++) {
if(!isInTree[k] && grid[cur][k] < minDist[k]) { //这里要注意，已经加入了最小生成树的点，就不能更改下标值了
minDist[k] = grid[cur][k];
}
}
}
//统计结果，统计minDist数组
int result = 0;
for(int i = 2; i <= v; i++) { //不记录节点1，因为根据我们的代码逻辑，第一个选择的点是节点1，且节点1下面的权值是没有改过的，是10001
result += minDist[i];
}
cout << result << endl;
return 0;
}拓展
上面我们求出了最小生成树边的权值之和。但如果需要我们打印出最小生成树的每条边，或者要把这个最小生成树画出来，应该怎么做。
显然我们需要把最小生成树的每条边记录下来。那我们就需要解决两个问题：1.使用什么结构来记录边；2.如果进行边的记录。
对于第一个问题，我们只需要记录两个节点即可，两个节点连成一条边。因此我们可以采用一维数组进行纪录，parent[节点编号] = 节点编号，这样就把一条边记录下来，假如节点非常多，编号很大，也可以考虑使用map进行记录。
我们使用一维数组记录其实有向边，但这里我们不需要关注对向
vector<int> parent(v + 1, -1);接下来就是对于第二个问题的办法。依据prim算法三部曲，我们可以发现，我们只有在第三步更新了minDist数组，也就是说在第三步我们才去更新了边的权值，因此我们也可以在这一步更新parent数组。
for (int j = 1; j <= v; j++) {
if (!isInTree[j] && grid[cur][j] < minDist[j]) {
minDist[j] = grid[cur][j];
parent[j] = cur; // 记录最小生成树的边 （注意数组指向的顺序很重要）
}
}注意这个地方代码的指向非常重要，是parent[j] = cur，而不是parent[cur] = j，因为cur是已经确定加入了最小生成树的点，同时我们是依据cur进行节点的遍历的，我们更新的边的权值，也是非最小生成树的点到最小生成树的距离，而不是找cur到它们的最小距离。如果这样运行下去只会不断更改parent[cur]的值而已，最后也只表示了cur和最后一个节点相连，和我们的需求是违背的。
当然我们也可以采用二维数组来记录，那么就不会出现上述情况了， ，例如 parent[节点编号A][节点编号B] = 1 ，parent[节点编号B][节点编号A] = 1，来表示 节点A与 节点B相连，这么做的话，就是多开辟的内存空间。
#include<iostream>
#include<vector>
#include <climits>
using namespace std;
int main() {
int v, e;
int x, y, k;
cin >> v >> e;
vector<vector<int>> grid(v + 1, vector<int>(v + 1, 10001));
while (e--) {
cin >> x >> y >> k;
grid[x][y] = k;
grid[y][x] = k;
}
vector<int> minDist(v + 1, 10001);
vector<bool> isInTree(v + 1, false);
//加上初始化
vector<int> parent(v + 1, -1);
for (int i = 1; i < v; i++) {
int cur = -1;
int minVal = INT_MAX;
for (int j = 1; j <= v; j++) {
if (!isInTree[j] && minDist[j] < minVal) {
minVal = minDist[j];
cur = j;
}
}
isInTree[cur] = true;
for (int j = 1; j <= v; j++) {
if (!isInTree[j] && grid[cur][j] < minDist[j]) {
minDist[j] = grid[cur][j];
parent[j] = cur; // 记录边
}
}
}
// 输出 最小生成树边的链接情况
for (int i = 1; i <= v; i++) {
cout << i << "->" << parent[i] << endl;
}
}
//运行结果
1->-1
2->1
3->1
4->3
5->4
6->2
7->5 
总结：
我们首先需要牢记prim算法三部曲：
- 第一步，选距离生成树最近节点
- 第二步，最近节点加入生成树
- 第三步，更新非生成树节点到生成树的距离（即更新minDist数组）
这是prim算法的主要框架。其次要明白minDist数组是prim算法的灵魂，它帮助prim算法完成最重要的一步，就是找到距离最小生成树最近的点。
同时我们还拓展了parent数组，来记录最小生成树的每一条边！！并且，因为使用一维数组，数组的下标和数组如何赋值很重要，一定不要搞反，导致结果被覆盖。
kruskal算法精讲
文档讲解：代码随想录kruskal算法精讲
接下来我们来了解解决最小生成树的第二种算法kruskal算法。
与prim算法从节点出发相比，kruskal算法同样采用了贪心算法的逻辑，它的贪心逻辑是每次选取权值最小的边，属于是从边出发的算法。（prim 算法是维护节点的集合，而 Kruskal 是维护边的集合）
kruskal的思路：
- 将边的权值排序，因为要优先选最小的边加入到生成树里
- 遍历排序后的边：①如果边首尾的两个节点在同一个集合，说明如果连上这条边图中会出现环。②如果边首尾的两个节点不在同一个集合，加入到最小生成树，并把两个节点加入同一个集合。
依据上述逻辑，我们以示例为例查看解题过程：
将边按权值小到大进行排列，排列后的顺序应该为： [(1,2) (4,5) (1,3) (2,6) (3,4) (6,7) (5,7) (1,5) (3,2) (2,4) (5,6)]。权值相同的边，先后顺序对解题结果没有影响。
开始从头遍历排序后的边：
选边(1,2)，节点1 和 节点2 不在同一个集合，所以生成树可以添加边(1,2)，并将节点1，节点2放在同一个集合。
选边(4,5)，节点4和节点 5 不在同一个集合，生成树可以添加边(4,5) ，并将节点4，节点5放到同一个集合。
选边(1,3)，节点1 和 节点3 不在同一个集合，生成树添加边(1,3)，并将节点1，节点3 放到同一个集合。
选边(2,6)，节点2 和 节点6 不在同一个集合，生成树添加边(2,6)，并将节点2，节点6 放到同一个集合。
选边(3,4)，节点3 和 节点4 不在同一个集合，生成树添加边(3,4)，并将节点3，节点4 放到同一个集合。
选边(6,7)，节点6 和 节点7 不在同一个集合，生成树添加边(6,7)，并将 节点6，节点7 放到同一个集合。
接着应该是选边(5,7)，但发现5,7在同一个集合，不做计算。然后选边(1,5)两个节点也在同一个集合，不做计算，后面的边也均是如此。最后我们就得到了一个最小生成树。
显然在这个过程中，我们最重要的两个部分就是：1.判断两个节点是否在同一个集合；2.将两个节点加入到一个集合当中。
这就需要我们使用之前的知识并查集来辅助求解。回顾一下，并查集的主要功能就是：将两个元素添加到一个集合中，判断两个元素在不在同一个集合。
最后我们可以得到求解的代码：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// l,r为 边两边的节点，val为边的数值
struct Edge { //使用到结构体来保存边和边的权值
int l, r, val;
};
// 节点数量
int n = 10001;
// 并查集标记节点关系的数组
vector<int> father(n, -1); // 节点编号是从1开始的，n要大一些
// 并查集初始化
void init() {
for (int i = 0; i < n; ++i) {
father[i] = i;
}
}
// 并查集的查找操作
int find(int u) {
return u == father[u] ? u : father[u] = find(father[u]); // 路径压缩
}
// 并查集的加入集合
void join(int u, int v) {
u = find(u); // 寻找u的根
v = find(v); // 寻找v的根
if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
father[v] = u;
}
int main() {
int v, e;
int v1, v2, val;
vector<Edge> edges;
int result_val = 0;
cin >> v >> e;
while (e--) {
cin >> v1 >> v2 >> val;
edges.push_back({v1, v2, val});
}
// 执行Kruskal算法
// 按边的权值对边进行从小到大排序
sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) { //这是c++的一种特殊的函数使用方式
return a.val < b.val;
});
// 并查集初始化
init();
// 从头开始遍历边
for (Edge edge : edges) {
// 并查集，搜出两个节点的祖先
int x = find(edge.l);
int y = find(edge.r);
// 如果祖先不同，则不在同一个集合
if (x != y) {
result_val += edge.val; // 这条边可以作为生成树的边
join(x, y); // 两个节点加入到同一个集合
}
}
cout << result_val << endl;
return 0;
}拓展
同理，如果题目要求把边输出，我们应该怎么操作。
由于kurskal算法，本身就是对边进行操作的算法，因此边的结构是很清晰的，我们只需要把我们加入了最小生成树的边记录下来就可以了。
也就是在最后一步，判断两个节点不在同一个集合的时候，这两个节点的边就加入到最小生成树。
vector<Edge> result; // 存储最小生成树的边
// 如果祖先不同，则不在同一个集合
if (x != y) {
result.push_back(edge); // 记录最小生成树的边
result_val += edge.val; // 这条边可以作为生成树的边
join(x, y); // 两个节点加入到同一个集合
}最后我们再打印输出：
// 打印最小生成树的边
for (Edge edge : result) {
cout << edge.l << " - " << edge.r << " : " << edge.val << endl;
}
//输出结果
1 - 2 : 1
1 - 3 : 1
2 - 6 : 1
3 - 4 : 1
4 - 5 : 1
5 - 7 : 1总结
了解了两种解决最小生成树的方法prim算法和kruskal算法。那么在我们使用的时候如何选择这两种算法呢。
这两种算法的关键区别在于，prim维护的是节点的集合，kruskal维护的是边的集合。一个是对节点进行遍历，一个是对边进行遍历。因此我们可以得出结论如果 一个图中，节点多，但边相对较少，那么使用Kruskal 更优。反之对于边稠密的图则使用prim算法更好。
总结就是：
- 边稠密的图，选择prim算法更好
- 边稀疏的图，选择kruskal算法更好
Prim 算法 时间复杂度为 O(n^2)，其中 n 为节点数量，它的运行效率和图中边树无关。
Kruskal算法 时间复杂度 为 nlogn，其中n 为边的数量。
