B - 畅通工程 HDU - 1863

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。
Output
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。
Sample Input
3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100

Sample Output
3
?

思路：并查集+最小生成树

//#include<bits/stdc++.h>
#include  <stdio.h>
#include <iostream>
#include<algorithm>
#include      <map>
#include      <set>
#include   <vector>
#include    <queue>
#include    <stack>
#include <stdlib.h>
#include  <cstring>
#include <string.h>
#include   <string>
#include   <math.h>
using namespace std;
typedef long long ll;
#define MAXN 100005
#define INF 0x3f3f3f3f//将近ll类型最大数的一半，而且乘2不会爆ll

struct node
{
    int u, v, len;
} ed[105];

int cmp(node x, node y)//降序排列
{
    return x.len < y.len;
}

int bi[MAXN], sum;

void init(int n)
{
    for(int i=0; i<=n; ++i)//初始化，每个人一个集合
    {
        bi[i] = i;
    }
}

int tofind(int a)//寻找a属于哪一个集合
{
    int r=a;
    if(bi[r] != r)
        r = bi[r];
    return r;
}

void add(int a, int b, int c)//将a与b所属的两大集合合并
{
    int x = tofind(a);
    int y = tofind(b);
    if(x!=y)
    {
        bi[x] = y;
        sum+=c;
    }
}

int main()
{
    int n, m;
    while(scanf("%d %d", &m, &n) && m!=0)
    {
        sum=0;
        init(n);
        for(int i=1; i<=m; ++i)
            scanf("%d %d %d", &ed[i].u, &ed[i].v, &ed[i].len);

        sort(ed, ed+m, cmp);				//为什么不是sort(ed+1, ed+m+1, cmp);
        									//这里是我到现在还不明白的地方，求dalao评论告知。谢谢。QAQ！
        for(int i=1; i<=m; ++i)
        {
           // cout << ed[i].u << ' ' << ed[i].v << ' ' << ed[i].len << '\n';
            add(ed[i].u, ed[i].v, ed[i].len);
        }
        int flag = 0;
        for(int i=1; i<=n; ++i)//如果只有一个集合的话，就输出sum
        {
            if(bi[i] == i)
                flag++;
        }
        if(flag == 1)
            cout << sum << '\n';
        else
            cout << "?" << '\n';
    }
    return 0;
}

最近刚学了克鲁斯卡尔最小生成树，，所以，，回来，，秒了它。。

//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<stack>
#include<string.h>
#include<math.h>
#include<stack>
using namespace std ;
typedef long long ll;
#define MAXN 1005
#define INF 0x3f3f3f3f
#define MALL (BiTnode *)malloc(sizeof(BiTnode));
int ves[MAXN];          //标识各个顶点所属的连通分量。

struct stu              //从u到v有一条权值为len的边
{
    int u, v, lowcoat;
} edge[MAXN];

void init(int n)           //输入m条边之间的关系
{
    memset(ves, 0, sizeof(ves));
    for(int i=1; i<=n; ++i)
    {
        int u, v, len;
        scanf("%d %d %d", &u, &v, &len);

        edge[i].u = u;
        edge[i].v = v;
        edge[i].lowcoat = len;
    }
}

int cmp(stu x, stu y)       //按边的大小降序排列
{
    return x.lowcoat < y.lowcoat;
}

int Kruskal(int n, int m)     //克鲁斯卡尔算法
{
    int x=0, y=0;
    sort(edge, edge+m, cmp);    //先降序，共有m条边关系，固对该m条边排序
    for(int i=1; i<=n; ++i)      //初始化，每个顶点都为一个连通分量（自己是自己的连通分量）
        ves[i] = i;
    for(int i=1; i<=m; ++i)
    {
        int u1 = edge[i].u;     //取最小边
        int v1 = edge[i].v;
        int le = edge[i].lowcoat;

        int u2 = ves[u1];       //取边的始点和终点的连通分量
        int v2 = ves[v1];
        if(u2 != v2)            //判断是否属于同一连通分量
        {
            y+=le;
            x++;
            for(int j=1; j<=n; ++j) //是，输出，并且加到同一连通分量上
            {
                if(ves[j] == v2)
                    ves[j] = u2;
            }
        }
    }
    if(x == n-1)
        return y;
    else
        return -1;
}

int main()
{
    int n, m;               //n个顶点和m条边关系
    while(scanf("%d %d", &m, &n) && m!=0)
    {
        init(m);
        int sum = Kruskal(n, m);
        if(sum != -1)
            cout << sum << '\n';
        else
            cout << '?' << '\n';
    }
    return 0;
}