hdu1233 还是畅通工程（两种基本最小生成树算法）

http://acm.hdu.edu.cn/showproblem.php?pid=1233

题意：中文题。

思路：最小生成树入门题。入门教程(算是看了一点)，还是挑战上面的思路清晰点。

Prim：设T为最小生成树的集合，然后贪心选取未访问节点与本集合的最小花费，不断重复直到找到最小生成树。方式和Dijkstra相似，第一个for查找起点离未访问节点花费最小的点，第二个for以上面找出花费最小的节点为起点更新其对其他未访问节点的最小花费。思路上感觉自己的理解还有些欠缺，啥时候理解了书上的证明过程再来详叙。

Kruskal：这种办法比较精妙，把所有的边都用结构体存起来，然后用结构体从小到大查看一遍，如果不产生圈，就把这条边加入到生成树中。那么问题就转化为怎样判环，如果这个边的两个节点在同一个连通分量，那么连接这个边就会组成环。判断是否在同一个连通分量用并查集高效处理，不为环就加入到生成树。

通常最小生成树为无向图，Prim中由于存边方式是邻接矩阵，而且中间的找点操作具有方向性，所以必须建双边，还要判重。而Kruskal中仅仅是对边排序然后进行集合操作，不涉及对边方向的操作，所以不用邻接矩阵和邻接表存，只是普通的存边，那么只要连上一个方向的边也可以。

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>

using namespace std;

typedef long long LL;

const int N = 505;
const int INF = 0x3f3f3f3f;

int mincost[N], G[N][N], pre[N], n, ednum, sum;
bool vis[N];

struct node
{
    int u, v, w;
}edge[N*N];

bool cmp(node x, node y)
{
    if(x.w<y.w) return true;
    else return false;
}

void prim()
{
    for(int i = 1; i <= n; i++)
        mincost[i] = G[1][i];//从起点到各个点的花费
    memset(vis, false, sizeof(vis));
    mincost[1] = 0;
    vis[1] = true;
    for(int i = 2; i <= n; i++)//起点已访问过。遍历n-1个节点
    {
        int k = -1, minpath = INF;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (k==-1 || mincost[j]<minpath))//寻找起点离未访问节点花费最小的点
            {
                k = j;
                minpath = mincost[j];
            }
        }
        if(k == -1) break;//已经遍历所有的点
        vis[k] = true;
        sum+=minpath;
        for(int j = 1; j <= n; j++)//以上面找出花费最小的节点为起点更新其对其他未访问节点的最小花费
        {
            if(!vis[j]) mincost[j] = min(mincost[j], G[k][j]);
        }
    }
}

int Find(int x)
{
    int r = x;
    while(r != pre[r])
        r = pre[r];
    int i = x, j;
    while(pre[i] != r)
    {
        j = pre[i];
        pre[i] = r;
        i = j;
    }
    return r;
}

void Union(int p1, int p2, int w)
{
    int x = Find(p1);
    int y = Find(p2);
    if(x != y)
    {
        pre[x] = y;
        sum+=w;
    }
}

void kruskal()
{
    for(int i = 1; i <= n; i++)
        pre[i] = i;
    sort(edge+1, edge+1+ednum, cmp);
    for(int i = 1; i <= ednum; i++)
    {
        Union(edge[i].u, edge[i].v, edge[i].w);
    }
}


int main()
{
  //  freopen("in.txt", "r", stdin);
    int u, v, w;
    while(~scanf("%d", &n))
    {
        if(n == 0) break;
        ednum = n*(n-1)/2;
        sum = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                if(i == j) G[i][j] = 0;
                else G[i][j] = INF;
            }
        for(int i = 1; i <= ednum; i++)
        {
            scanf("%d%d%d", &u, &v, &w);
            if(w<G[u][v]) G[u][v] = G[v][u] = w;
            edge[i] = (struct node){u, v, w};
        }
       // prim();
        kruskal();
        printf("%d\n", sum);
    }
    return 0;
}