---

---

最小生成树概述

---

$Prim$ 算法 - 稠密图 - $O(n^2)$

思路概述

跟 $Dijkstra$ 算法很相近，都是每个点轮一遍然后贪心找最小值，同样，$Prim$ 也可以用堆优化，但是不如 $Kruskal$ 算法，所以不用。

• 用到三个数组：g[][]邻接矩阵存边，st[]用于标记那些节点在生成树中，dist[]存储每个节点到生成树的最小距离。
• 首先，初始化每个点到生成树的距离，在一开始，除了根节点是 $0$，其他都是 $INF$;
• 然后每个点轮一遍（因为生成树要每个点都在）
  • 再次遍历，寻找到生成树最小的边连接的点，如果遍历完了发现最小值是 $INF$，说明这个图不联通，没有最小生成树。
  • 将这个点更新到生成树里去，累计生成树的边长，然后用这个点的值再更新一遍dist[]数组。

---

时间复杂度分析

外层循环 $n$ 次，内层是 $2n$ 次，所以是 $O(n\cdot 2n)$，也就是$$O(n^2)$$

---

AcWing 858. Prim算法求最小生成树

题目链接：https://www.acwing.com/activity/content/problem/content/924/。

CODE

#include <iostream>  // 引入输入输出流库
#include <cstring>   // 引入字符串处理库
#include <algorithm> // 引入算法库

using namespace std; // 使用标准命名空间

const int N = 520, INF = 0x3f3f3f3f; // 定义常量N和INF
int g[N][N]; // 定义邻接矩阵g
int dist[N]; // 定义距离数组dist
bool st[N];  // 定义状态数组st
int n, m;    // 定义顶点数n和边数m

int prim(){  	// 定义prim算法函数
    memset(dist, 0x3f, sizeof dist); 	// 初始化dist数组
    dist[1] = 0; 	// 将起点的距离设为0
    
    int res = 0; 	// 初始化结果res
    for(int i = 0; i < n; ++i){ 	// 遍历所有顶点
        int t = -1; 	// 初始化t
        
        for(int j = 1; j <= n; ++j) 	// 遍历所有顶点
            if(!st[j] && (t == -1 || dist[t] > dist[j])) // 找到未被访问且距离最小的顶点
                t = j;
        
        if(dist[t] == INF) return INF; 	// 如果找不到顶点，返回INF
        
        res += dist[t]; 	// 更新结果
        st[t] = true; 		// 标记顶点t已被访问
        
        for(int j = 1; j <= n; ++j) dist[j] = min(dist[j], g[j][t]); 	// 更新距离
    }

    return res; 	// 返回结果
}

int main() 		// 主函数
{
    memset(g, 0x3f, sizeof g); 	// 初始化邻接矩阵g
    
    cin >> n >> m; 		// 输入顶点数和边数
    
    while (m -- ){ 		// 遍历所有边
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c); 	// 输入边的两个顶点和权值
        
        g[a][b] = g[b][a] = min(g[a][b], c); // 更新邻接矩阵
    }
    
    int t = prim(); 	// 调用prim算法
    
    if(t == INF) puts("impossible"); 	// 如果返回INF，输出"impossible"
    else printf("%d\n", t); 			// 否则输出结果
}

---

---

$Kruskal$ 算法 - 稀疏图 - $O(mlogm)$

思路解析

• 首先，将所有边按权值排序，这一步是 $Kruskal$ 的瓶颈，复杂度是$O(m\cdot logm)$
• 接着初始化并查集，再把排序好的边轮一遍。
  • 如果边的两个点的根节点不是同一个（两个节点没有全在树中），那就将两个点连起来，然后节点数和权重累积。
• 最后判断，如果生成树的边不是 $n-1$ 条的话，说明图不联通，没有最小生成树。

---

时间复杂度分析

由上知排序瓶颈复杂度，然后是后面遍历每一条边的复杂度 $O(m)$，最后累计就是$$O(mlogm)$$
但是由于排序的常数很小，所以实际运行时间比公式算出来要少的多。

---

AcWing 859. Kruskal算法求最小生成树

题目链接：https://www.acwing.com/activity/content/problem/content/925/

CODE

#include <iostream>  // 引入输入输出流库
#include <cstring>   // 引入字符串处理库
#include <algorithm> // 引入算法库

using namespace std; // 使用标准命名空间

const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f; 	// 定义常量N、M和INF
int n, m; 	// 定义顶点数n和边数m
int p[N]; 	// 定义并查集数组p

struct edge{ 	// 定义边的结构体
    int a, b, w;
}edges[M];

int find(int x){ 	// 定义并查集的查找函数
    if(x != p[x]) p[x] = find(p[x]);
    return p[x];
}

bool cmp(edge a, edge b){ 	// 定义比较函数，用于排序
    return a.w < b.w;
}

int kruskal(){ // 定义kruskal算法函数
    sort(edges, edges + m, cmp); 	// 对所有边按权值进行排序
    
    for(int i = 1; i <= n; ++i) p[i] = i; 	// 初始化并查集
    
    int res = 0, cnt = 0; 	// 初始化结果res和计数器cnt
    for(int i = 0; i < m; ++i){ 	// 遍历所有边
        int a = find(edges[i].a), b = find(edges[i].b), w = edges[i].w; 
        // 找到边的两个顶点的根节点和权值
        
        if(a != b){ 	// 如果两个顶点不在同一个集合中
            p[a] = b; 	// 合并两个集合
            cnt++; 		// 计数器加1
            res += w; 	// 更新结果
        }
    }
    
    if(cnt < n - 1) return INF; 	// 如果生成树的边数小于n-1，返回INF
    else return res; 	// 否则返回结果
}

int main() // 主函数
{
    cin >> n >> m; 	// 输入顶点数和边数
    
    for(int i = 0; i < m; ++i){ 	// 遍历所有边
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w); 	// 输入边的两个顶点和权值
        
        edges[i] = {a, b, w}; 	// 存储边
    }
    
    int t = kruskal(); 	// 调用kruskal算法
    
    if(t == INF) puts("impossible"); 	// 如果返回INF，输出"impossible"
    else printf("%d\n", t); 	// 否则输出结果
}