最小生成树之Prim算法和Kruskal算法

原创 2017年07月20日 15:29:37

一个连通图可能有多棵生成树,而最小生成树是一副连通加权无向图中一颗权值最小的生成树,它可以根据Prim算法和Kruskal算法得出,这两个算法分别从点和边的角度来解决。

Prim算法

  1. 输入:一个加权连通图,其中顶点集合为V,边集合为E;

  2. 初始化:Vn = {x},其中x为集合V中的任一节点(起始点),Enew = {};

  3. 重复下列操作,直到Vn = V:(在集合E中选取权值最小的边(u, v),其中u为集合Vn中的元素,而v则是V中没有加入Vn的顶点(如果存在有多条满足前述条件即具有相同权值的边,则可任意选取其中之一);
    将v加入集合Vn中,将(u, v)加入集合En中;)

  4. 输出:使用集合Vn和En来描述所得到的最小生成树。
以下面这张图作为例子,表格中的Vertex、Kown、Cost、Path分别表示顶点信息、是否访问过,权值,到达路径;
Prim算法
我们随机的选择顶点0作为起点,其执行步骤为:
步骤选中结点
顶点0作为起始点0
根据(6, 7, 8)的方案选中61
根据顶点1能够到达的权值(7, 4, 3)和顶点0能够到达的权值(7, 8)中选择35
根据顶点5能够到达的权值(8)和根据顶点1能够到达的权值(7, 4)和顶点0能够到达的权值(7, 8)中选择46
根据顶点6能够到达的权值(6, 7)和顶点0能够到达的权值(7)中选择62
根据顶点0能够到达的权值(7)和顶点6能够到达的权值(7)中选择74
根据顶点6能够到达的权值(7)选择77
根据顶点7能够到达的权值(2)选择23
全部结点都访问过,退出 

最终得到下面的结果,其中Path中的-1表示其作为起始点;Prim算法

Prim算法实现

根据前面的那幅图来实现,如下:
class MST(object):
    def __init__(self, graph):
        self.graph = graph
        self.N = len(self.graph)
        pass
    def prim(self, start):
        index = start
        cost, path = [0] * self.N, [0] * self.N
        # 初始化起点
        known = [x for x in map(lambda x: True if x == start else False, [x for x in range(self.N)])]
        path[start] = -1
        for i in range(self.N):
            cost[i] = self.graph[start][i]
        # 遍历其余各个结点
        for i in range(1, self.N):
            mi = 1e9
            # 找出相对最小权重的结点
            for j in range(self.N):
                if not known[j] and mi > cost[j]:
                    mi, index = cost[j], j
            # 计算路径值
            for j in range(self.N):
                if self.graph[j][index] == mi:
                    path[index] = j
            known[index] = True
            # 更新index连通其它结点的权重
            for j in range(self.N):
                if not known[j] and cost[j] > self.graph[index][j]:
                    cost[j] = self.graph[index][j]
        print(path)
# 图用临接矩阵表示
MST([
    [1e9, 6, 8, 1e9, 7, 1e9, 1e9, 1e9],
    [6, 1e9, 7, 1e9, 1e9, 3, 4, 1e9],
    [8, 7, 1e9, 1e9, 1e9, 1e9, 6, 1e9],
    [1e9, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, 2],
    [7, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9],
    [1e9, 3, 1e9, 1e9, 1e9, 1e9, 1e9, 9],
    [1e9, 4, 6, 1e9, 1e9, 1e9, 1e9, 7],
    [1e9, 1e9, 1e9, 2, 1e9, 9, 7, 1e9],
]).prim(0)
path结果为:[-1, 0, 6, 7, 0, 1, 1, 6]

Kruskal算法

构造一个只含n个顶点,而边集为空的子图,若将该子图中各个顶点看成是各棵树的根节点,则它是一个含有n棵树的森林 。之后,从图的边集中选取一条权值最小的边,若该边的两个顶点分属不同的树 ,则将其加入子图,也就是这两个顶点分别所在的 两棵树合成一棵树;反之,若该边的两个顶点已落在同一棵树上,则不可取,而应该取下一条权值最小的边再试之。依次类推,直至森林只有一棵树。kruskal算法能够在并查集的基础很快的实现。

以下面这张图作为例子,其中左边的表格是一个并查集,表示可以连通的结点。我们首先要根据权值对每条边进行排序,接着开始处理每一条边的情况。

最终得到下面的结果图:

Kruskal算法实现

因为我们要处理边,所以需要建立边的数据结构,并且要从给定的图中获取每一条边的数据。
class Edge(object):
    def __init__(self, start, end, weight):
        self.start = start
        self.end = end
        self.weight = weight
    def getEdges(self):
        edges = []
        for i in range(self.vertex):
            for j in range(i+1, self.vertex):
                if self.graph[i][j] != 1e9:
                    edge = Edge(i, j, self.graph[i][j])
                    edges.append(edge)
        return edges
接下来就是kruskal函数:
def kruskal(self):
	union = dict.fromkeys([i for i in range(self.vertex)], -1)  # 辅助数组,判断两个结点是否连通
	self.edges = self.getEdges()
	self.edges.sort(key=lambda x: x.weight)
	res = []
	def getend(start):
		while union[start] >= 0:
			start = union[start]
		return start
	for edge in self.edges:
		# 找到连通线路的最后一个结点
		n1 = getend(edge.start)
		n2 = getend(edge.end)
		# 如果为共同的终点则不处理
		if n1 != n2:
			print('{}----->{}'.format(n1, n2))
			(n1, n2) = (n2, n1) if union[n1] < union[n2] else (n1, n2)
			union[n2] += union[n1]
			union[n1] = n2
			res.append(edge)
	print(union.values())
其中union打印出来的结果和图中是一致的,为[3, 3, 5, 6, 6, 6, -8, 3]。

版权声明:本文为博主原创文章,未经博主允许不得转载。

最小生成树(Prim算法和Kruskal算法)—理解与论证

向世界分享科学之美,让科学流行起来          对于一个给定的连通无向图G=(V,E),其最小生成树被定义如下:取边集E中的子集E‘构成连通树,同时满足,其中表示边(集...
  • MathThinker
  • MathThinker
  • 2015年08月23日 17:16
  • 1992

最小生成树Prim与Kruskal算法的比较

最小生成树是图论问题中很基本的一个操作。常用的算法有Prim和Kruskal两种算法。本文对这两种算法稍作区别与讨论。Prim算法是依赖于点的算法。它的基本原理是从当前点寻找一个离自己(集合)最近的点...
  • Mollnn
  • Mollnn
  • 2016年09月19日 21:48
  • 3758

【最小生成树】Prim算法和Kruskal算法的区别对比

Prim算法和Kruskal算法都是从连通图中找出最小生成树的经典算法。从策略上来说,Prim算法是直接查找,多次寻找邻边的权重最小值,而Kruskal是需要先对权重排序后查找的。 所以说,Kr...
  • liuchuo
  • liuchuo
  • 2016年12月21日 21:59
  • 1667

Prim算法和Kruskal算法的基本思想和实现

这两个都是求最小生成树的算法,个人更喜欢Kruskal算法。Prim算法基本思想有两个集合,A是空集,B集合里有现在图中的所有边。 将B中任意一点加入A集合,在这个点的所用通路中选择一个权值最小的边...
  • SCaryon
  • SCaryon
  • 2017年06月28日 22:14
  • 924

数学建模(14)——MATLAB实现最小生成树(Prim与Kruskal算法)

Prim算法 连通赋权图如上 邻接矩阵如下 0 50 60 0 0 0 0 0 0 0 65 40 ...
  • longxinghaofeng
  • longxinghaofeng
  • 2017年09月06日 21:14
  • 920

最小生成树的两种算法:Prim和Kruskal算法

越来越明白了一个道理:你写不出代码的原因只有一个,那就是你没有彻底理解这个算法的思想!! 以前写过最小生成树,但是,水了几道题后,过了一段时间,就会忘却,一点也写不出来了。也许原因只有一个,那就是我没...
  • I_am_a_winer
  • I_am_a_winer
  • 2015年04月25日 22:42
  • 1529

Prim算法 Kruskal算法 简述

Prim算法和Kruskal算法,都是用来找出图中最小生成树的算法,两个算法有些小差别。 Prim算法 又称普里姆算法,以图上的顶点为出发点,逐次选择到最小生成树顶点集距离最短的顶点为最小生成...
  • jerry81333
  • jerry81333
  • 2017年01月25日 06:28
  • 742

图 之 MST(最小生成树 — kruskal算法 )并查集实现

#并查集的优化: (1)       Find_Set(x)时,路径压缩寻找祖先时,我们一般采用递归查找,但是当元素很多亦或是整棵树变为一条链时,每次Find_Set(x)都是O(n)的复杂度。为...
  • PeersLee
  • PeersLee
  • 2015年12月26日 17:41
  • 1778

[C++]最小生成树--Prim算法&Kruskal算法

最小生成树–Prim算法&Kruskal算法 一个有 n 个结点的连通图的生成树是原图的极小连通子图,且包含原图中的所有 n 个结点,并且有保持图连通的最少的边。最小生成树可以用kruskal(克...
  • stary_yan
  • stary_yan
  • 2016年05月16日 20:24
  • 8021

图论中最小生成树构造算法之Prim算法和Kruskal算法

图是 由顶点的有穷非空集合和点之间边的集合构成: G={V,E},V是顶点集合,E是顶点之间边的集合。根基顶点之间边有无方向性可分为:有向图和无向图: 在图中,当对边赋予有意义数值时候,成为网图。...
  • yanerhao
  • yanerhao
  • 2015年06月25日 16:24
  • 2542
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:最小生成树之Prim算法和Kruskal算法
举报原因:
原因补充:

(最多只允许输入30个字)