POJ 3723 征兵问题（最小生成树算法的应用）

Conscription

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 15923		Accepted: 5510

Description

Windy has a country, and he wants to build an army to protect his country. He has picked up N girls and M boys and wants to collect them to be his soldiers. To collect a soldier without any privilege, he must pay 10000 RMB. There are some relationships between girls and boys and Windy can use these relationships to reduce his cost. If girl x and boy y have a relationship d and one of them has been collected, Windy can collect the other one with 10000-d RMB. Now given all the relationships between girls and boys, your assignment is to find the least amount of money Windy has to pay. Notice that only one relationship can be used when collecting one soldier.

Input

The first line of input is the number of test case.
The first line of each test case contains three integers, N, M and R.
Then R lines followed, each contains three integers x_i, y_i and d_i.
There is a blank line before each test case.

1 ≤ N, M ≤ 10000
0 ≤ R ≤ 50,000
0 ≤ x_i < N
0 ≤ y_i < M
0 < d_i < 10000

Output

For each test case output the answer in a single line.

Sample Input

2

5 5 8
4 3 6831
1 3 4583
0 0 6592
0 1 3063
3 3 4975
1 3 2049
4 2 2104
2 2 781

5 5 10
2 4 9820
3 2 6236
3 1 8864
2 4 8326
2 0 5156
2 0 1463
4 1 2439
0 4 4373
3 4 8889
2 4 3133

Sample Output

71071
54223

解题思路：

表面上看，出题者其实设置了一个看似“二分图”的陷阱，其实这道题真正想考的是最小生成树算法的应用。

利用kruskal算法，将征募士兵的顺序理解成最小生成树算法中添加边的顺序，问题迎刃而解。

参考程序源代码：

#include<stdio.h>
#include<algorithm>
#include<bits/algorithmfwd.h>
#include<iostream>
using namespace std;
const int MAX_E=50005;//最多的边数(关系）
const int MAX_N=20005;//最大的士兵数量
int N,M,R;
struct edge{int u,v,cost;};


bool comp(const edge& e1,const edge& e2)
{
    return e1.cost<e2.cost;
}


edge es[MAX_E];
int V,E;


//下面是自定义好的并查集的实现
int par[MAX_N];//父亲
int rank[MAX_N];//树的高度
void init(int n)
{
    for(int i=0;i<n;i++)
    {
        par[i]=i;
        rank[i]=0;
    }
}


int find(int x)//查询树的根
{
    if(par[x]==x)
    {
        return x;
    }
    else
    {
        return par[x]=find(par[x]);//递归查找
    }
}




void unite(int x,int y)//合并x和y所在的集合
{
    x=find(x);
    y=find(y);
    if(x==y)return;
    if(rank[x]<rank[y])
    {
        par[x]=y;//如果x的高度小于y的高度,则x插到y的下层(减少树的退化)
    }
    else
    {
        par[y]=x;//否则,y插入到x的下层
        if(rank[x]==rank[y])rank[x]++;
    }
}




bool same(int x,int y)
{
    return find(x)==find(y);
}


int kruskal()
{
    sort(es,es+E,comp);//按照边的权值从小到大排序,接下来就可以用贪心思想
    init(V);
    int res=0;
    for(int i=0;i<E;i++)
    {
        edge e=es[i];
        if(!same(e.u,e.v))
        {
            unite(e.u,e.v);//如果该边的两端不连通就合并它们
            res+=e.cost;
        }
    }
    return res;
}


int x[MAX_E];int y[MAX_E];int d[MAX_E];
void solve()
{
    V=N+M;
    E=R;
    for(int i=0;i<R;i++)
    {
        es[i]=(edge){x[i],N+y[i],-d[i]};//用到了转化的思想,取相反数将最大生成树问题转化为最小生成树问题
    }
    printf("%d ",10000*(N+M)+kruskal());//输出最少的征募费用
}


int main()
{
    //freopen("C://Users/Administrator/Desktop/in.txt","r",stdin);
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d%d",&N,&M,&R);
        for(int i=0;i<R;i++)scanf("%d%d%d",&x[i],&y[i],&d[i]);
        solve();
    }
    return 0;
}