库鲁斯卡尔算法

//Kruskal 算法的实现
#include <iostream>
#include <string>
#include <iomanip>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std; 


struct node
{
	int u;
	int v;
	int w;
};

int father[101];
int son[101];

int cmp(node a, node b)
{
    return a.w<b.w;
}

int find(int x)
{
	return x==father[x]? x : find(father[x]);
}

bool join(int x, int y) //加入者两个点连成的边 会怎样？
{
    int xx=find(x);
	int yy=find(y);
	if(xx==yy)
		return false; //加入此边 将构成环路  返回false
	else if( son[xx]>=son[yy] )
	{
        father[yy] = xx;
		son[xx] = son[xx]+son[yy];
	}
	else
	{
		father[xx]=yy;
		son[yy] = son[yy]+son[xx];
	}
    return true;
}

int main()
{
	int n, m;
	int i, j;
    int cnt;
	int sum;
    node edge[1000];
	while(cin>>n>>m)
	{
		if(m==0)
		{
			cout<<"0\n";
			continue;
		}

		for(i=0; i<m; i++)
		{
			cin>>edge[i].u>>edge[i].v>>edge[i].w;
		}
        sort(edge, edge+1, cmp );

		for(j=0; j<=n; j++)
		{
			father[j]=j;
			son[j]=j;
		}

		cnt=0;
		sum=0;
		int flag=0;

		for(i=0; i<m; i++)
		{	
			if(join(edge[i].u, edge[i].v))
			{
				cnt++;
				sum+=edge[i].w;
			}
			if(cnt==m-1)
			{
				flag=1;
				break;
			}
		}
		if(flag)
		{
			cout<<sum<<endl;
		}
	}
	return 0;
}


/////////////////////////////////

/*
#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<algorithm>

using namespace std;

#define MAX 1000
int father[MAX], son[MAX];
int v, l;

typedef struct Kruskal //存储边的信息 这样的话结构体根据边值 排序
{ 
	int a;
	int b;
	int value;
};

bool cmp(const Kruskal & a, const Kruskal & b)
{
	return a.value < b.value;
}

int unionsearch(int x) //查找根结点+路径压缩
{
	return x == father[x] ? x : unionsearch(father[x]);
}

bool join(int x, int y) //合并
{
	int root1, root2;
	root1 = unionsearch(x);
	root2 = unionsearch(y);
	if(root1 == root2) //为环
		return false;
	else if(son[root1] >= son[root2])
		{
			father[root2] = root1;
			son[root1] += son[root2];
		}
		else
		{
			father[root1] = root2;
			son[root2] += son[root1];
		}
	return true;
}

int main()
{
	int ncase, ltotal, sum, flag;

	Kruskal edge[MAX];
	scanf("%d", &ncase);

	while(ncase--)
	{
		scanf("%d %d", &v, &l); //v个顶点 l条边

		ltotal = 0, sum = 0, flag = 0;

		for(int i = 1; i <= v; ++i) //初始化 并查集数组初始化
		{
			father[i] = i;
			son[i] = 1;
		}

		for(int i = 1; i <= l ; ++i) //读入点 边 权，存入结构体，等待排序
		{
			scanf("%d %d %d", &edge[i].a, &edge[i].b, &edge[i].value);
		}

		sort(edge + 1, edge + 1 + l, cmp); //按权值由小到大排序

		for(int i = 1; i <= l; ++i) //循环 这l条边（注意已排好序 从权值最小的边开始 ）
		{
			if(join(edge[i].a, edge[i].b) ) //如果加入该条边是合法的
			{
				ltotal++; //边数加1
				sum += edge[i].value; //记录权值之和
				cout<<edge[i].a<<"->"<<edge[i].b<<endl;
			}
			if(ltotal == v - 1) //最小生成树条件：边数=顶点数-1 边的总数可能很多，当已经加入n-1条边后就可以直接跳出了
			{
				flag = 1;
				break;
			}
		}
		if(flag) 
			printf("%d\n", sum);
		else 
			printf("data error.\n");
	}
	return 0;
}

  */