HDU 1233 还是畅通工程 最小生成树Kruskal算法和prim算法

题目的链接如下：
http://acm.hdu.edu.cn/showproblem.php?pid=1233

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 40074 Accepted Submission(s): 18225

Problem Description
某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

Output
对每个测试用例，在1行里输出最小的公路总长度。

Sample Input
3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0

Sample Output
3
5

Hint
Hint

Huge input, scanf is recommended.

第一种 kruskal算法：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<iostream>
#include<cstdio>
/*
int find_root(int x)//三种找根节点的办法
{
    if(father[x] == x)
        return x;
    else return find_root(father[x]);
}
int Find(int x)//递归版本
{

    if(father[x] != x)
        father[x] = Find(father[x]);
    return father[x];
}*/

using namespace std;
const int maxn =5000+10;
int n,len;
int ans=0;

int father[120];

struct node{
    int a,b,len;
};
node edge[maxn];
int cmp(const node& a, const node& b){
    return a.len<b.len;
}
//  路径压缩即可

void makeSet(){
    for(int i=1;i<=110;i++){
        father[i] = i;
    }
}

int Find(int x){//迭代版本
    int tempRoot;
    int root = x;
    while(root != father[root]) //找到根节点。
        root = father[root];
    while(x != root){
        tempRoot = father[x]; //x的父节点用临时变量存一下。
        father[x] = root; //x的父节点设置成根 （x 压缩到根节点了）
        x = tempRoot;   //x 赋值为 x的父节点(之前存过的);
    }
    return root; // 最后返回根节点
}

void Union(int x,int y){
    int xroot = Find(x);
    int yroot = Find(y);
    if(xroot == yroot) return;
    else{
        father[xroot]=yroot;
    }
}

void Kruskal(){
    ans=0;
    for(int i=0;i<len;i++){
        if(Find(edge[i].a) != Find(edge[i].b)){//判断是否成环，不成环则将两个并到一个集合，就是避圈法。
            Union(edge[i].a,edge[i].b);
            ans+=edge[i].len;
        }
    }
}

int main(){
    while(scanf("%d",&n)!=EOF&&n){
        len=n*(n-1)/2;
        for(int i=0;i<len;i++){
            scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].len);
        }
        sort(edge,edge+len,cmp);
        makeSet();
        Kruskal();
        printf("%d\n",ans);
    }
    return 0;
}

第二种prim算法：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 10000 + 50;
const int INF = 1e9;
int mindist[maxn];
bool intree[maxn];
int n;
struct node{
    int v;
    int len;
    node(int a = 0, int b = 0):v(a), len(b){}
};
vector<node> G[maxn];

int prim(int s)
{
    int ans = 0;
    int vex, add_node, temp_min;

    memset(intree, 0, sizeof(intree));//把最小生成树清空
    intree[s] = true;//第一个点加入树

    for(int i = 0 ; i < G[s].size() ; i++){//与第一个点相连的点，直接赋值即可，因为刚开始所有的mindist都是INF
        vex = G[s][i].v;
        mindist[vex] = G[s][i].len;
    }
    for(int node_num = 1 ; node_num <= n-1 ; node_num++){//除了第一个点总共选出n-1个点
        temp_min = INF;
        for(int i = 1 ; i <= n ; i++){//选出当前点最小的mindist
            if(intree[i] == false && mindist[i] < temp_min){
                temp_min = mindist[i];//把当前的最小值赋值成这个点到原始点的距离；
                add_node = i;//把这个点标记成要添加到树里面的点；
            }
        }
        intree[add_node] = true;//把选中的点加入最小生成树
        ans += temp_min;
        for(int i = 0 ; i < G[add_node].size() ; i++){//每选一个新的点更新mindist
            vex = G[add_node][i].v;
            if(intree[vex] == false && G[add_node][i].len < mindist[vex])
                mindist[vex] = G[add_node][i].len;
        }
    }
    return ans;
}
int main()
{
    int  t, len, v;
    while(cin >> n){
        for(int i = 0 ; i < maxn ; i++){
            mindist[i] = INF;
            G[i].clear();
            intree[i] = false;
        }
        if(n == 0) break;
        for(int i = 1 ; i <= n * (n-1) / 2; i++){
            cin >> t >> v >> len;
            G[t].push_back(node(v,len));//注意这是无向图，要push_back两次；
            G[v].push_back(node(t,len));
        }
        int res = prim(1);//从任意点开始，这里我从第一个
        cout << res << endl;
    }
    return 0;
}