kruskal算法(最小生成树)_c语言给定一个无向图,使用kruskal算法求最小生成树

生成树

定义： 设G =<V， E> 是无向连通图，T是G的生成子图，并且T是树，则称T是G的生成树。
比如对于图(a) ，图(b)就是它的生成树之一。

得到生成树有两种方法，一个叫破圈法，还有一个叫避圈法，其中避圈法和今天的krushal算法我觉得很像。
先说破圈法，人如其名，在给出的图中，见到一个圈就给它去掉一条边，使其不再连通，一直到没有圈为止。因为生成树有很多，所以不同的选择会得到不同的生成树。这个方法对于人类来说太简单了，一眼就能看出来有没有圈，但是对于计算机来说可不简单。因此我们来看看避圈法。
事物都是具有两面性的，既然我们能从找到圈来解决问题，也就能从避开圈来解决问题。对于给定的图，不断的选则边，并且保证没有回路形成直到所有顶点都被选择到。因此它也是人如其名，它是专门躲避回路也就是圆圈。

我们来看一下避圈法的过程。就拿上面的图a来说，红色的线代表选择了它。

这样就形成了一个生成树。

最小生成树

回到我们今天的正题，最小生成树，上面说生成树有许多，但从含义上面来看他们并没有什么区别，但是实际生活中，不同的生成树往往代表不同的含义。比如图之间的边现在有了权重代表距离，问你至少需要多场的电线才能使得每个顶点都能通上电？这就是今天的最小生成树问题。
先看破圈法，因为它是人类容易理解的。当图有了权重后，找到一个圈后就不能在随便选取一条边删除了，而是应该把权重最大的边删除。基于贪心的思想，当形成生成树后，所有权重相对大的都已经被删除掉了。剩下的都是相对小的，因此能够保证这是一颗最小生成树。最小生成树只能保证总权重是相同的，但是不能保证其树长得一模一样。虽然破圈法能够解决最小生成树问题，但上面我说了，这个方法只适用于人来，并不适用于计算机。因此还得是避圈法。
避圈法的做法是把所有的边先进行一边排序，然后从小到大选取，直到所有的点都被加进来。
举个?，比如下图：

排序后得到：2，3，4，4，5，6，7，8

先选取权重最小的边2，把和它相连的两个点加进来。得到：

然后选择3，加入后不能形成回路，把它加进来：

找到4，发现有两个4，先处理那个都行，我们先处理左边的，加入后不能形成回路，加进来：

对于另一个4，加上它后不能形成回路，所以加进来

然后是权重为5的边，加入后形成回路，所以抛弃它，然后到权重为6的边，加入后无法形成回路，加进来：

到此，所有的顶点都加进来了，这就是最小生成树了。

上面判断能不能产生回路我们肉眼一眼就看出来了，怎么让计算机知道这个事情呢?观察可以发现，只要当两个顶点之间是有路可以互相到达的时候，就不需要连边了，因为连上后一定形成回路。判断两个顶点是不是属于一个图是什么算法？没错，就是并查集。
所以，kruskal算法即克鲁斯卡算法，是一种基于贪心和并查集的算法。从加权连通图中选取n-1
条边。第一次从权值中选取权值最小的边，判断是否属于一棵树，如果不属于一棵树就合并
两棵树。

输入：
11
1 2 7
2 3 8
1 4 5
4 2 9
2 5 7
3 5 5
4 5 15
4 6 6
6 5 8
6 7 11
5 7 9

输出：39

#include <iostream>
#include <algorithm>

using namespace std;

//父节点 
int f[10010];

struct node
{
	int a, b, price;
};

struct node a[10010];

bool cmp(node x, node y)
{
	return x.price < y.price;
}

void init(int n)
{
	for (int i=1; i<=n; i++)
	{
		//rank[i] = 0;
		f[i] = i;
	}
}

//查找根节点、并且压缩路径 
int find(int x)
{
	int root = x;
	
	while (root != f[root])
	{
		root = f[root];
	}
	
	while (x!=root)
	{
		int t = f[x];
		f[t] = root;
		x = t;
	}

	return root;
}

void unite(int x, int y)
{
	int tx = find(x);
	int ty = find(y);
	
	f[tx] = ty;
}

int kruskal(int n)
{
	sort(a+1, a+n+1, cmp);
	
	int Edge = 0, res = 0;
	
	for (int i=1; i<=n && Edge!=n-1; i++)
	{
		//不属于一棵树 
		if (find(a[i].a) != find(a[i].b))
		{
			unite(a[i].a, a[i].b);
			res+=a[i].price;
			Edge++;
		}
	}
	
	//加入的边小于n-1， 说明无向图不是连通的，没有最小生成树 
/*	if (Edge < n-1)
	{
		res = -1;
	}
*/	
	return res; 
}

int main()
{
	int n;
	
	cin >> n;
	
	init(n);
	
	for (int i=1; i<=n; i++)
	{
		cin >> a[i].a >> a[i].b >> a[i].price;
	}
	
	cout << kruskal(n) << endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100