最小生成树算法

本文介绍: Pr i mPri mPri m跟Dijks tr aDijks tr aDijk str a 算法很相近，都是每个点轮一遍然后贪心找最小值，同样，PrimPrimPrim也可以用堆优化，但是不如Krusk alKrusk alKrusk al算法，所以不用。g[][]邻接矩阵存边，s t[]用于标记那些节点在生成树中，dist[]存储每个节点到生成树的最小距离。首先，初始化每个点到生成树的距离，在一开始，除了根节点是000，其他都是INFINF。

文章 目录

最小生成树概述
- m
  
  Prim
  
  $P r i m$ 算法 – 稠密图 –
  
  O
  
  (
  
  n
  
  2
  
  )
  
  O(n^2)
  
  $O (n^{2})$
- s
  
  k
  
  a
  
  l
  
  Krus k al
  
  $Kr u s k a l$ 算法 – 稀疏图 –
  
  O
  
  (
  
  m
  
  l
  
  o
  
  g
  
  m
  
  )
  
  O(mlogm)
  
  $O (m l o g m)$

最小 生成树概述

$O(n^2) O(n2)$

思路概述

跟

Dijk stra

$D i jk s t r a$ 算法很相近，都是每个点轮一遍然后贪心找最小值，同样，

Prim

$P r im$ 也可以用堆优化，但是不如

Kruskal

$Kr u s k a l$ 算法，所以不用。

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

时间 复杂度 分析

外层循环

$n$ 次，内层是

$2 n$ 次，所以是

(

⋅

)

O(n·2n)

$O (n \cdot 2 n)$ ，也就是

(

)

O(n^2)

$O (n^{2})$

AcWin g 858. Prim算法求最小生成树

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

最小生成树

CODE

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

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] &amp;&amp; (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", &amp;a, &amp;b, &amp;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("%dn", t); 			// 否则输出结果
}

思路解析

首先，将所有边按权值排序，这一步是
接着初始化并查集，再把排序好的边轮一遍。
- 如果边的两个点的根节点不是同一个（两个节点没有全在树中），那就将两个点连起来，然后节点数和权重累积。
最后判断，如果生成树的边不是

时间 复杂度 分析

由上知排序瓶颈复杂度，然后是后面遍历每一条边的复杂度

(

)

O(m)

$O (m)$ ，最后累计就是

(

)

O(mlogm)

$O (m l o g m)$
但是由于排序的常数很小，所以实际运行时间比公式算出来要少的多。

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

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

kruskal

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", &amp;a, &b, &w); 	// 输入边的两个顶点和权值
        
        edges[i] = {a, b, w}; 	// 存储边
    }
    
    int t = kruskal(); 	// 调用kruskal算法
    
    if(t == INF) puts("impossible"); 	// 如果返回INF，输出"impossible"
    else printf("%dn", t); 	// 否则输出结果
}