MST:Bad Cowtractors(POJ 2377)

　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　坏的牛圈建筑

　　题目大意：就是现在农夫又要牛修建牛栏了，但是农夫想不给钱，于是牛就想设计一个最大的花费的牛圈给他，牛圈的修理费用主要是用在连接牛圈上

　　这一题很简单了，就是找最大生成树，把Kruskal算法改一下符号就好了，把边从大到小排列，然后最后再判断是否联通（只要找到他们的根节点是否相同就可以了！）

　　

#include <iostream>
#include <algorithm>
#include <functional>
#define MAX_N 1005
#define MAX 20005

using namespace std;

typedef int Position;
typedef struct _edge
{
    Position from;
    Position to;
    int cost;
}Edge_Set;
int fcomp(const void *a, const void *b)
{
    return (*(Edge_Set *)b).cost - (*(Edge_Set *)a).cost;
}

static Edge_Set edge[MAX];
static Position Set[MAX_N];

Position Find(Position);
void Union(Position, Position);
void Kruskal(const int, const int);
bool Is_Connected(const int);

int main(void)
{
    int Node_Sum, Path_Sum, cost;
    Position tmp_from, tmp_to;

    while (~scanf("%d%d", &Node_Sum, &Path_Sum))
    {
        for (int i = 0; i < Path_Sum; i++)//读入边
        {
            scanf("%d%d%d", &tmp_from, &tmp_to, &cost);
            edge[i].from = tmp_from; edge[i].to = tmp_to; edge[i].cost = cost;
        }
        qsort(edge, Path_Sum, sizeof(Edge_Set), fcomp);
        Kruskal(Node_Sum, Path_Sum);
    }
    return 0;
}

Position Find(Position x)
{
    if (Set[x] < 0)
        return x;
    else return Set[x] = Find(Set[x]);
}

void Union(Position px, Position py)
{
    if (Set[px] < Set[py])
    {
        Set[px] += Set[py];
        Set[py] = px;
    }
    else
    {
        Set[py] += Set[px];
        Set[px] = py;
    }
}

bool Is_Connected(const int Node_Sum)
{
    Position p_u, p_tmp;
    p_u = Find(1);
    for (int i = 2; i <= Node_Sum; i++)
    {
        p_tmp = Find(i);
        if (p_u != p_tmp)
            return false;
    }
    return true;
}

void Kruskal(const int Node_Sum, const int Path_Sum)
{
    Position px, py, from, to;
    long long ans = 0;

    fill(Set, Set + Node_Sum + 1, -1);
    for (int i = 0; i < Path_Sum; i++)
    {
        from = edge[i].from; to = edge[i].to;
        px = Find(from); py = Find(to);

        if (px != py)
        {
            ans += edge[i].cost;
            Union(px, py);
        }
    }
    if (Is_Connected(Node_Sum))
        printf("%lld
", ans);
    else
        printf("-1
");
}