POJ2377 Bad Cowtractors【Kruskal算法+并查集+最大生成树】

Bad Cowtractors

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 17907		Accepted: 7237

Description

Bessie has been hired to build a cheap internet network among Farmer John's N (2 <= N <= 1,000) barns that are conveniently numbered 1..N. FJ has already done some surveying, and found M (1 <= M <= 20,000) possible connection routes between pairs of barns. Each possible connection route has an associated cost C (1 <= C <= 100,000). Farmer John wants to spend the least amount on connecting the network; he doesn't even want to pay Bessie.  

Realizing Farmer John will not pay her, Bessie decides to do the worst job possible. She must decide on a set of connections to install so that (i) the total cost of these connections is as large as possible, (ii) all the barns are connected together (so that it is possible to reach any barn from any other barn via a path of installed connections), and (iii) so that there are no cycles among the connections (which Farmer John would easily be able to detect). Conditions (ii) and (iii) ensure that the final set of connections will look like a "tree".

Input

* Line 1: Two space-separated integers: N and M  

* Lines 2..M+1: Each line contains three space-separated integers A, B, and C that describe a connection route between barns A and B of cost C.

Output

* Line 1: A single integer, containing the price of the most expensive tree connecting all the barns. If it is not possible to connect all the barns, output -1.

Sample Input

5 8
1 2 3
1 3 7
2 3 10
2 4 4
2 5 8
3 4 6
3 5 2
4 5 17

Sample Output

42

Hint

OUTPUT DETAILS:  

The most expensive tree has cost 17 + 8 + 10 + 7 = 42. It uses the following connections: 4 to 5, 2 to 5, 2 to 3, and 1 to 3.

Source

USACO 2004 December Silver

问题链接：POJ2377 Bad Cowtractors

问题描述：（略）

问题分析：

  这是一个最小生成树的为问题，解决的算法有Kruskal（克鲁斯卡尔）算法和Prim（普里姆） 算法。

  这个题关键的地方是求最大生成树！

程序说明：

  本程序使用Kruskal算法实现。有关最小生成树的问题,使用克鲁斯卡尔算法更具有优势，只需要对所有的边进行排序后处理一遍即可。程序中使用了并查集，用来判定加入一条边后会不会产生循环。程序中，图采用边列表的方式存储，排序一下就好了。

  排序的时候，边的权要从大到小！函数cmp()比较运算符略有不同。

AC的C++语言程序如下：

/* POJ2377 Bad Cowtractors */

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

using namespace std;

const int N = 1000;
const int M = 20000;

int f[N + 1];

void UFInit(int n)
{
    for(int i = 1; i <=n; i++)
        f[i] = i;
}

int Find(int a) {
    return a == f[a] ? a : f[a] = Find(f[a]);
}

bool Union(int a, int b)
{
    a = Find(a);
    b = Find(b);
    if (a != b) {
        f[a] = b;
        return true;
    } else
        return false;
}

struct Edge {
    int u, v, w;
} edges[M];

bool cmp(Edge a, Edge b)
{
    return a.w > b.w;
}

int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m)) {
        UFInit(n);

        for(int i = 0; i < m; i++)
            scanf("%d%d%d", &edges[i].u, &edges[i].v, &edges[i].w);

        // Kruscal算法
       int ans = 0, cnt = 0;
       sort(edges, edges + m, cmp);
       for(int i = 0; i < m; i++) {
           if(Union(edges[i].u, edges[i].v)) {
               ans += edges[i].w;
               if(++cnt == n - 1)
                   break;
           }
       }

       printf("%d\n", (cnt == n - 1) ? ans : -1);
    }

    return 0;
}