【ACM之路】6.最小生成树 - Kruskal算法

介绍：

       Kruskal算法是最小生成树算法，它适合于 边少的稀疏图 。

思想：

       首先按照边的权值，从小到大排序，每次从剩余的边中选择 “权值最小的  且边的两个顶点不在同一个集合内的边”。 （就是不产生回路的边），加入到生成树中，直到加入了n-1条边为止。

前置知识：

     ①. 并查集。     ②. 快速排序

题目举例：

      一共有6个城市，9条路，路径标在边上。求连接这6个城市最少需要多长？

思路：

    1.首先从小到大，列出路径的大小。

      

     2. 根据路径大小，由小到大划线。

         1,2,3,4这4步还好可以理解，但是第五步，如果选择 2->3 就会有回路，这条路多余，如果选择 4->5 也会有回路，多余，那么这两条路虽然近，但是都不能选，只好选择 3 - > 4这条路。这时就提出了一个问题，如何判断能不能选择这条路呢，这里就用到了并查集的相关知识，比如刚开始，1和2号的 f 数组不相同，（这里的 f 即他们的领导是谁，）故可以合并，他们成为一体，3号和一号不同连为一体，同理，4,5,6号相同，到了2,3号时，2号和3号的领导一样，故他们是一体，合并就有多余路径，故不选，4,5号同理。因此，到了3号和4号时，他们的领导不同，不是一体，故可以合并。

       待3号和4号合并后，共有5条路径了，根据原理，至少有n-1条路径，故结束，得出答案。生成树最少的路径值在合并当中不停加起来，1+2+3+4+9 = 19.

 

详细代码： 

( 温馨提示 ： 虽然代码看起来很长，但是只要懂了 并查集 和 快排 的原理，在你眼中，主函数只有5行：

①。输入信息。②。初始化。③。快排 。④。Kruskal算法 。⑤。输出。

#include <stdio.h>
#include <stdlib.h>
struct edge
{
	int u;
	int v;
	int w;
};//为了方便排序，这里创建了一个结构体用来存储边的关系

struct edge e[10];	//数组大小根据实际情况来设置，要比m的最大值大1
int n,m;
int f[7] = {0},sum = 0,count = 0;	//并查集要用到的一些变量
//f数组大小根据实际情况来设置，要比n的最大值大1

void quicksort(int left,int right)
{

    if(left>right)return;   //*******我忘了加这句话，结果造成了栈溢出，因为他无限递归下去了。

	struct edge t,temp;
    int i,j;
	temp = e[left];	//temp是基准数
	i = left;
	j = right;
	while(i < j)
	{
		while(e[j].w >= temp.w && i<j )j--;
		while(e[i].w <= temp.w && i<j )i++;
		if(i<j)
			{t = e[j];e[j] = e[i];e[i] = t;}
	}

	/*基准位归位*/
	e[left] = e[i];
	e[i] = temp;

	quicksort(left,i-1);
	quicksort(i+1,right);


}

int getf(int m)
{
	if(m==f[m])
		return m;
	else
	{
		f[m] = getf(f[m]);
		return f[m];
	}
}

int merge(int u,int v)
{
	int t1,t2;
	t1 = getf(u);
	t2 = getf(v);
	if(t1!=t2)
	{
		f[t2] = t1;
		return 1;
	}
	return 0;
}


int main()
{
	int i;
	scanf("%d%d",&n,&m);
	for(i=1;i<=m;i++)
		scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);

	quicksort(1,m);
    
    /*初始化并查集*/
	for(i=1;i<=n;i++)
        f[i] = i;

	/*kruskal核心代码*/
	for(i=1;i<=m;i++)
	{
		if(merge(e[i].u,e[i].v))
		{
			count++;
			sum += e[i].w;
		}
		if(count == n-1)
			break;
	}
	printf("%d",sum);

	return 0;
}

测试用例：

6 9
2 4 11
3 5 13
4 6 3
5 6 4
2 3 6
4 5 7
1 2 1
3 4 9
1 3 2

Output

19

其他例题：HDU1233

 

方法二。直接用stl快排。

快排操作。（e，e+m条路线+1）

sort(e,e+m+1);

#include <iostream>
#include <algorithm>
using namespace std;

struct edge
{
    int u;
    int v;
    int w;
    bool operator < (const edge &e2) const {    //这个写法比较标准，c++可过，原来我写的不标准，g++能过c++过不了。
        return w < e2.w;
    }
};

struct edge e[10];
int f[10];
int n,m;

int getf(int m)
{
    if (m==f[m])
        return m;
    else
    {
        f[m] = getf(f[m]);
        return f[m];
    }
}
int merge(int m,int n)
{
    int u = getf(m);
    int v = getf(n);
    if(u!=v){
        f[u] = v;
        return 1;
    }
    return 0;
}

int main()
{

    int count = 0;
    int sum = 0;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        f[i] = i;
    for (int i = 1; i <= m; i++)
    {
        cin >> e[i].u >> e[i].v >> e[i].w;
    }
    sort(e + 1, e + m + 1);
    for(int i = 1;i <= m;i++)
    {
        if (merge(e[i].u, e[i].v)){
            count++;
            sum += e[i].w;
        }
        if (count == n-1)
            break;
    }
    cout << sum << endl;
    return 0;
}