CCF CSP——最优灌溉（201412-4）

问题描述
　　雷雷承包了很多片麦田，为了灌溉这些麦田，雷雷在第一个麦田挖了一口很深的水井，所有的麦田都从这口井来引水灌溉。
　　为了灌溉，雷雷需要建立一些水渠，以连接水井和麦田，雷雷也可以利用部分麦田作为“中转站”，利用水渠连接不同的麦田，这样只要一片麦田能被灌溉，则与其连接的麦田也能被灌溉。
　　现在雷雷知道哪些麦田之间可以建设水渠和建设每个水渠所需要的费用（注意不是所有麦田之间都可以建立水渠）。请问灌溉所有麦田最少需要多少费用来修建水渠。
输入格式
　　输入的第一行包含两个正整数n, m，分别表示麦田的片数和雷雷可以建立的水渠的数量。麦田使用1, 2, 3, ……依次标号。
　　接下来m行，每行包含三个整数ai, bi, ci，表示第ai片麦田与第bi片麦田之间可以建立一条水渠，所需要的费用为ci。
输出格式
　　输出一行，包含一个整数，表示灌溉所有麦田所需要的最小费用。
样例输入

4 4
1 2 1
2 3 4
2 4 2
3 4 3

样例输出

6

样例说明
　　建立以下三条水渠：麦田1与麦田2、麦田2与麦田4、麦田4与麦田3。
评测用例规模与约定
　　前20%的评测用例满足：n≤5。
　　前40%的评测用例满足：n≤20。
　　前60%的评测用例满足：n≤100。
　　所有评测用例都满足：1≤n≤1000，1≤m≤100,000，1≤c_i≤10,000。
　
我的思路

最小生成树Kruskal算法
  先将各个边按照长短排序，然后用并查集判断变得两个端点是否在生成树中，若不在，则将两点合并；若在，则不进行处理。
  代码中还可以加入一个判断边数是否等于n-1的判断，以此来跳出循环，加与不加结果都正确。（1879408没加）

我的代码

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int MAXN = 1000 + 10;

struct Edge{//边的各信息
    int from;
    int to;
    int length;
    Edge(){}
    Edge(int f,int t,int l):from(f),to(t),length(l){}
};

int father[MAXN];//记录父节点
int height[MAXN];//记录顶点的高度
vector<Edge>vs; //记录各边的信息

bool Compare(Edge a,Edge b){
    return a.length < b.length;
}

void init(int n){
    for(int i=1;i<=n;i++){
        father[i]=i;
        height[i]=0;
    }
}

int Find(int x){
    int answer;
    if(father[x]==x){
        answer = father[x];
    }else{
        answer = Find(father[x]);
    }
    return answer;
}

void Union(int x,int y){
    x=Find(x);
    y=Find(y);
    if(x==y){
        return ;
    }else{//高度低的合并到高度高的上边，可以使生成树的高度最小
        if(height[x]>height[y]){
            father[y]=x;
        }else if(height[y]>height[x]){
            father[x]=y;
        }else{
            father[y]=x;
            height[x]++;
        }
    }
}

int main(){
    int n,m,a,b,c;
    long long answer = 0;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>a>>b>>c;
        vs.push_back(Edge(a,b,c));
    }
    init(n);
    sort(vs.begin(),vs.end(),Compare);
    for(int i=0;i<vs.size();i++){
        Edge current = vs[i];
        if(Find(current.from) != Find(current.to)){
            Union(current.from,current.to);
            answer += current.length;
        }
    }
    cout<<answer;
    return 0;
}