🍉1 最小生成树的概念
1.1 连通图 🎈
连通图用于描述图中顶点之间是否存在路径相连。一个无向图中，如果从图中的任意一个顶点出发，都可以通过边的连接到达图中的任意其他顶点，则该图被称为连通图。
连通图的性质：
- 连通图中的任意两个顶点之间都存在一条路径。
- 连通图中的最小生成树是唯一的。
- 连通图中的边数至少为顶点数减一，否则无法保证所有顶点之间都连通。
1.2 生成树🎈
1.3 最⼩⽣成树（最⼩代价树）🎈
对于一个带权连通无向图G=(V,E)，生成树不同，每棵树的权(即树中所有边上的权值之和)也可能不同。
- 最小生成树可能有多个，但边的权值之和总是唯一且最小的。
- 最小生成树的边数 =顶点数 -1。砍掉一条则不连通，增加一条边则会出现回路。
- 如果一个连通图本身就是一棵树，则其最小生成树就是它本身。（①所有顶点之间都是连通的，且没有孤立的顶点。②没有形成环路的边，即不存在回路。③满足上一条）
- 只有连通图才有生成树，非连通图只有生成森林。
1.4 求最小生成树的两种方法🎈
在讨论prime算法和kruskal算法在不同边密度情况下的适用性之前，让我们先了解一下稠密图和稀疏图的概念：
- 稠密图：稠密图是指图中边的数量接近于顶点数量的平方级别的图。在稠密图中，边的数量相对较多，顶点之间的连接比较密集。
- 稀疏图：稀疏图是指图中边的数量远小于顶点数量的平方级别的图。在稀疏图中，边的数量相对较少，顶点之间的连接比较稀疏。
两种具体的算法——prime算法和kruskal算的适用范围↓
- Prim算法
- Kruskal算法
1.5 为什么最小生成树必须要求无向图?🎈
最小生成树（Minimum Spanning Tree）是一个①连通②无向图中的一棵包含图中所有顶点的③树，并且具有④最小总权值。
最小生成树要求树是无向的，因为在无向图中，边是双向的，可以在两个顶点之间双向移动，这样可以确保生成树的连通性和权重最小化。在有向图中，边是单向的，可能会导致生成树不连通或权重计算错误。
🍉 2 Prim算法
prim 算法干的事情是：给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。
prim 算法采用的是一种贪心的策略。
每次将离连通部分的最近的点和点对应的边加入的连通部分，连通部分逐渐扩大，最后将整个图连通起来，并且边长之和最小。
我们将图中各个节点用数字 1 ~ n 编号。
要将所有景点连通起来，并且边长之和最小，步骤如下：
- 用一个 state 数组表示节点是否已经连通。state[i] 为真，表示已经连通，state[i] 为假，表示还没有连通。初始时，state 各个元素为假。即所有点还没有连通。
- 用一个 dist 数组保存各个点到连通部分的最短距离，dist[i] 表示 i 节点到连通部分的最短距离。初始时，dist 数组的各个元素为无穷大。
- 用一个 pre 数组保存节点的是和谁连通的。pre[i] = k 表示节点 i 和节点 k 之间需要有一条边。初始时，pre 的各个元素置为 -1。
从 1 号节点开始扩充连通的部分，所以 1 号节点与连通部分的最短距离为 0，即disti[1] 置为 0。
- 遍历 dist 数组，找到一个还没有连通起来，但是距离连通部分最近的点，假设该节点的编号是 i。i节点就是下一个应该加入连通部分的节点，stata[i] 置为 1。
- 用青色点表示还没有连通起来的点，红色点表示连通起来的点。
- 这里青色点中距离最小的是 dist[1]，因此 state[1] 置为 1。
- 遍历所有与 i 相连但没有加入到连通部分的点 j，如果 j 距离连通部分的距离大于 i j 之间的距离，即 dist[j] > w[i][j]（w[i][j] 为 i j 节点之间的距离），则更新 dist[j] 为 w[i][j]。这时候表示，j 到连通部分的最短方式是和 i 相连，因此，更新pre[j] = i。
- 与节点 1 相连的有 2， 3， 4 号节点。1->2 的距离为 100，小于 dist[2]，dist[2] 更新为 100，pre[2] 更新为1。1->4 的距离为 140，小于 dist[4]，dist[4] 更新为 140，pre[2] 更新为1。1->3 的距离为 150，小于 dist[3]，dist[3] 更新为 150，pre[3] 更新为1。
重复 上面2步骤，直到所有节点的状态都被置为 1.
这里青色点中距离最小的是 dist[2]，因此 state[2] 置为 1
与节点 2 相连的有 5， 4号节点。2->5 的距离为 80，小于 dist[5]，dist[5] 更新为 80，pre[5] 更新为 2。2->4 的距离为 80，小于 dist[4]，dist[4] 更新为 80，pre[4] 更新为2。
选dist[4]，更新dist[3]，dist[5]，pre[3]，pre[5]。
选dist[5]，没有可更新的。
选dist[3]，没有可更新的。
此时 dist 数组中保存了各个节点需要修的路长，加起来就是。pre 数组中保存了需要选择的边。
2.1 伪代码🎈
int dist[n],state[n],pre[n];
dist[1] = 0;
for(i : 1 ~ n)
{
t <- 没有连通起来，但是距离连通部分最近的点;
state[t] = 1;
更新 dist 和 pre;
}2.2 代码🎈
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510;
int g[N][N];//存储图
int dt[N];//存储各个节点到生成树的距离
int st[N];//节点是否被加入到生成树中
int pre[N];//节点的前去节点
int n, m;//n 个节点，m 条边
void prim()
{
memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右）
int res= 0;
dt[1] = 0;//从 1 号节点开始生成
for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树
{
int t = -1;
for(int j = 1; j <= n; j++)//每个节点一次判断
{
if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点
t = j;
}
//2022.6.1 发现测试用例加强后，需要判断孤立点了
//如果孤立点，直返输出不能，然后退出
if(dt[t] == 0x3f3f3f3f) {
cout << "impossible";
return;
}
st[t] = 1;// 选择该点
res += dt[t];
for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离
{
if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。
{
dt[i] = g[t][i];//更新距离
pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t.
}
}
}
cout << res;
}
void getPath()//输出各个边
{
for(int i = n; i > 1; i--)//n 个节点，所以有 n-1 条边。
{
cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。
}
}
int main()
{
memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数
cin >> n >> m;//输入节点数和边数
while(m --)
{
int a, b, w;
cin >> a >> b >> w;//输出边的两个顶点和权重
g[a][b] = g[b][a] = min(g[a][b],w);//存储权重
}
prim();//求最下生成树
//getPath();//输出路径
return 0;
}
上面代码的时间复杂度为 O(n^2)。
与Dijkstra类似，Prim算法也可以用堆优化，优先队列代替堆，优化的Prim算法时间复杂度O(mlogn)。适用于稀疏图，但是稀疏图的时候求最小生成树，Kruskal 算法更加实用。
🍉 3 Kruskal算法
算法思路：
- 将所有边按照权值的大小进行升序排序，然后从小到大一一判断。
- 如果这个边与之前选择的所有边不会组成回路，就选择这条边分；反之，舍去。
- 直到具有 n 个顶点的连通网筛选出来 n-1 条边为止。
- 筛选出来的边和所有的顶点构成此连通网的最小生成树。
判断是否会产生回路的方法为：使用并查集。
- 在初始状态下给各个个顶点在不同的集合中。、
- 遍历过程的每条边，判断这两个顶点的是否在一个集合中。
- 如果边上的这两个顶点在一个集合中，说明两个顶点已经连通，这条边不要。如果不在一个集合中，则要这条边。
举个例子，下图一个连通网，克鲁斯卡尔算法查找图 1 对应的最小生成树，需要经历以下几个步骤：
将连通网中的所有边按照权值大小做升序排序：
从 B-D 边开始挑选，由于尚未选择任何边组成最小生成树，且 B-D 自身不会构成环路，所以 B-D 边可以组成最小生成树。
D-T 边不会和已选 B-D 边构成环路，可以组成最小生成树：
A-C 边不会和已选 B-D、D-T 边构成环路，可以组成最小生成树：
C-D 边不会和已选 A-C、B-D、D-T 边构成环路，可以组成最小生成树：
C-B 边会和已选 C-D、B-D 边构成环路，因此不能组成最小生成树：
B-T 、A-B、S-A 三条边都会和已选 A-C、C-D、B-D、D-T 构成环路，都不能组成最小生成树。而 S-A 不会和已选边构成环路，可以组成最小生成树。
如图下图 所示，对于一个包含 6 个顶点的连通网，我们已经选择了 5 条边，这些边组成的生成树就是最小生成树。
3.1 代码🎈
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010;
int p[N];//保存并查集
struct E{
int a;
int b;
int w;
bool operator < (const E& rhs){//通过边长进行排序
return this->w < rhs.w;
}
}edg[N * 2];
int res = 0;
int n, m;
int cnt = 0;
int find(int a){//并查集找祖宗
if(p[a] != a) p[a] = find(p[a]);
return p[a];
}
void klskr(){
for(int i = 1; i <= m; i++)//依次尝试加入每条边
{
int pa = find(edg[i].a);// a 点所在的集合
int pb = find(edg[i].b);// b 点所在的集合
if(pa != pb){//如果 a b 不在一个集合中
res += edg[i].w;//a b 之间这条边要
p[pa] = pb;// 合并a b
cnt ++; // 保留的边数量+1
}
}
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++) p[i] = i;//初始化并查集
for(int i = 1; i <= m; i++){//读入每条边
int a, b , c;
cin >> a >> b >>c;
edg[i] = {a, b, c};
}
sort(edg + 1, edg + m + 1);//按边长排序
klskr();
//如果保留的边小于点数-1，则不能连通
if(cnt < n - 1) {
cout<< "impossible";
return 0;
}
cout << res;
return 0;
}
