最小生成树 - prim算法

最新推荐文章于 2024-08-12 19:29:12 发布

钟子悦

最新推荐文章于 2024-08-12 19:29:12 发布

阅读量618

点赞数

分类专栏： ACM - 最小生成树文章标签： prim 算法离散数学

ACM - 最小生成树专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Prim算法

1.概览

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。

2.算法简单描述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：V_new = {x}，其中x为集合V中的任一节点（起始点），E_new = {},为空；

3).重复下列操作，直到V_new = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合V_new中的元素，而v不在V_new集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合V_new中，将<u, v>边加入集合E_new中；

4).输出：使用集合V_new和E_new来描述所得到的最小生成树。

下面对算法的图例描述

说明	不可选	可选	已选（V_new）
此为原始的加权连通图。每条边一侧的数字代表其权值。	-	-	-
顶点D被任意选为起始点。顶点A、B、E和F通过单条边与D相连。A是距离D最近的顶点，因此将A及对应边AD以高亮表示。	C, G	A, B, E, F	D
下一个顶点为距离D或A最近的顶点。B距D为9，距A为7，E为15，F为6。因此，F距D或A最近，因此将顶点F与相应边DF以高亮表示。	C, G	B, E, F	A, D
算法继续重复上面的步骤。距离A为7的顶点B被高亮表示。	C	B, E, G	A, D, F
在当前情况下，可以在C、E与G间进行选择。C距B为8，E距B为7，G距F为11。E最近，因此将顶点E与相应边BE高亮表示。	无	C, E, G	A, D, F, B
这里，可供选择的顶点只有C和G。C距E为5，G距E为9，故选取C，并与边EC一同高亮表示。	无	C, G	A, D, F, B, E
顶点G是唯一剩下的顶点，它距F为11，距E为9，E最近，故高亮表示G及相应边EG。	无	G	A, D, F, B, E, C
现在，所有顶点均已被选取，图中绿色部分即为连通图的最小生成树。在此例中，最小生成树的权值之和为39。	无	无	A, D, F, B, E, C, G

3.简单证明prim算法

反证法：假设prim生成的不是最小生成树

1).设prim生成的树为G₀

2).假设存在G_min使得cost(G_min)<cost(G₀) 则在G_min中存在<u,v>不属于G₀

3).将<u,v>加入G₀中可得一个环，且<u,v>不是该环的最长边(这是因为<u,v>∈G_min)

4).这与prim每次生成最短边矛盾

5).故假设不成立，命题得证.

4.算法代码实现

#include<iostream>
#include<vector>
#include<cstring>
#define INF 0x3f3f3f3f
using namespace std;

const int MAX = 10;
int n ,k;
struct Edge{
	int k;
	int w;
	Edge(int kk, int ww)
		:k(kk), w(ww){
		}
	Edge(){
	};
};

vector<Edge> G[MAX];

int dist[MAX];
int addvnew[MAX];
//int adjecent[MAX];
 
/*
7 11
1 2 7
1 4 5
2 3 8
2 4 9
2 5 7
3 5 5
4 5 15
4 6 6
5 6 8
5 7 9
6 7 11
*/

int prim(int s)
{
	int sum = 0;
	for(int i = 0; i < MAX; ++i){
		dist[i] = INF;
		addvnew[i] = 0;
	}
	for(int i = 0;i < G[s].size(); ++i){
		dist[G[s][i].k] = G[s][i].w;
	}
	
	addvnew[s] = 1;
//	adjecent[s] = s;
	
	for(int i = 1;i <= n ; ++i){
		if(i != s){
			int min = INF;
			int v = -1;
			for(int j = 1; j <= n; ++j){
				if(!addvnew[j] && dist[j] < min){
					min = dist[j];
					v = j;
				}
			}
			
			if(v != -1){
				//cout << adjecent[v] << v << dist[v] << "\n";
				addvnew[v] = 1;
				
				sum += dist[v];
				
				for(int j = 0;j < G[v].size(); ++j){
					if(!addvnew[G[v][j].k] && G[v][j].w < dist[G[v][j].k]){
						dist[G[v][j].k] = G[v][j].w ;
					//	adjecent[G[v][j].k] = v;
					}
				}
			} 
		}
	}
	
	cout << "minmum sum:" << sum << "\n";
	
} 
int main()
{

	cin >> n >> k;
	int a, b, w;
	while(k--){
		cin >> a >> b >> w;
		G[a].push_back(Edge(b,w));
		G[b].push_back(Edge(a,w));
	}
	prim(4);
	
	
}