POJ3723 Conscription 题解

start:

2021-08-04

16:56:50

题目链接：

http://poj.org/problem?id=3723

题目内容：

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算法

题意：需要征募女兵N人，男兵M人。每征募一个人需要10000$。但是如果已经征募的人中有一些关系亲密的人，
那么可以少花一些钱。给出若干男女之间的1~9999之间的亲密关系，
征募某个人的费用是10000-（已经征募的人中和自己的亲密度的最大值）。
要求通过适当的征募顺序使得征募所有人的所需费用最小。


题目分析：

让我们设想一下这样的一个无向图：在征募某个人的时候，如果使用了a和b之间的关系，那么就连一条从a到b的边。

假设这个图中存在圈，那么无论以什么顺序征募这个圈上的所有人，都会产生矛盾。英雌可以知道这个图是一片森林。

反之，如果给了一片森林，那么就可以使用对应的关系确定征募的顺序。

因此，把人看做顶点，把关系看做边，这个问题就可以转化为求解无向图中的最大权森林问题。

最大权森林问题可以通过吧所有的边权取反后用最小生成树求解。

为了规范Kruskal算法，在这里我会写多个函数 先写好框架：

我们使用struct结构体来储存每条边的信息，p[N]是用来储存每个点的父节点的，

第一个输入第一行的t。第二个输入n,m,r，再接下来就是r个边的信息，用struct结构体储存，

并且我们在输入r条边的信息的时候，我们注意，我们每组边的信息，包括edge[i].u,edge[i].v和edge[i].cost，

这三个分别代表女兵的编号，男兵的编号以及亲密值（edge[i].v=edge[i].v+n就是这样来的），

而且本题我们使用的是 Kruskal算法，Kruskal算法是用来计算最小生成树的，

但是我们这里需要最多的亲密度来降低花费，那么我们该怎么处理呢？ 我们可以这样：

将所有的亲密度取反，让 花费-亲密度==>花费+（-亲密度），所以我们可以采取这样的方式，

只要求得 （-亲密度）的最小值，我们就能求出花费的最小值。所以我们得在输入边的信息的时候将所有的边的权重全部取反。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX_E=5e5+5;
const int MAX_N=1e5+5;
struct Edge{
	int u,v,cost;
}edge[MAX_E];
int n,m,r;

int main()
{
   ios::sync_with_stdio(false);
   int t;
   scanf("%d",&t);
   while(t--)
   {
   	    scanf("%d%d%d",&n,&m,&r);
   	    v=n+m;
   	    for(int i=0;i<r;i++)
   	    {
   	    	scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].cost);
   	    	edge[i].v=edge[i].v+n;//女标号0~N-1,男标号N~N+M-1.
   	    	edge[i].cost=-edge[i].cost;
	    }

	}
    return 0;
}

　　

我们处理完基本架构之后：我们需要写一个初始化函数，用来在main函数开始时初始化一些数组。

所以定义初始化函数init(int n)

void init(int n)

{

    for(int i=0;i<n;i++)p[i]=i;

}

　　

这是将所有点的父节点都初始化为它本身（比如1的父节点就是1）。

接着，Kruskal算法需要先将所有的边按权重排序，所以我们得写一个比较函数cmp(const edge& a,const edge&b)

bool cmp(const Edge &a,const Edge &b)
{
	return a.cost<b.cost;
}

　　

写到这里，我们先将其他的函数放一放，是时候写一部分核心函数Kruskal()了

在Kruskal函数中，我们先将所有边按权重排序，所以第一行就是sort();再然后，我们在初始化每个点的父节点，

所以调用init函数，然后定义一个res=0，res将作为返回值返回Kruskal()求出来的最小生成树的权和。

接下来就是Kruskal()的核心思想了，我们按照边从小到大，如果这条边的连个端点不在一个连通块内，

那么就将这条边加入进来，看代码：

int kruskal()
{
	sort(edge,edge+r,cmp);
	init(v);
	int res=0;
	for(int i=0;i<r;i++)
	{
	　　if(same(edge[i].u,edge[i].v)==false)
	　　{
		 unite(edge[i].u,edge[i].v);
		 res=res+edge[i].cost;
	    }
	}
	return res;
}

　　

其中的same()函数和unite()函数接下来介绍，先说明功能：

same(int a,int b)函数是判断a点和b点是否在一个连通块内，而unite(int a,int b)是将点a和点b连到一个连通块中去。

same(itn x,int y)；

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

　　

这里的find函数也是需要我们写的，这里顺便写一下

find(int x):用来寻找点x的最终的父节点（比如说开始的时候1的父节点是1，然后1和3连通，1的最终父节点变成了3）

int find(int x)
{
　　if(p[x]==x)return x;
　　else return p[x]=find(p[x]);
}

　　

unite(int x,int y)：将点x和点y连接到一个连通块内

void unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return ;
	p[x]=y;
}

　　

好！！！
到这里我们六个函数已经全部写完了，接下来就可以拼接起来了、

完整代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX_E=5e5+5;
const int MAX_N=1e5+5;
struct Edge{
	int u,v,cost;
}edge[MAX_E];
int v;
int n,m,r;
int p[MAX_N];

bool cmp(const Edge &a,const Edge &b)
{
	return a.cost<b.cost;
}

void init(int n)
{
	for(int i=0;i<n;i++)p[i]=i;
}

int find(int x)
{
	if(p[x]==x)return x;
	else return p[x]=find(p[x]);
}

void unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return ;
	p[x]=y;
}

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

int kruskal()
{
	sort(edge,edge+r,cmp);
	init(v);
	int res=0;
	for(int i=0;i<r;i++)
	{
		if(same(edge[i].u,edge[i].v)==false)
		{
		 unite(edge[i].u,edge[i].v);
		 res=res+edge[i].cost;
	    }
	}
	return res;
}

int main()
{
   ios::sync_with_stdio(false);
   int t;
   scanf("%d",&t);
   while(t--)
   {
   	    scanf("%d%d%d",&n,&m,&r);
   	    v=n+m;
   	    for(int i=0;i<r;i++)
   	    {
   	    	scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].cost);
   	    	edge[i].v=edge[i].v+n;
   	    	edge[i].cost=-edge[i].cost;
	    }
   	    int ans=(n+m)*10000+kruskal();
   	    printf("%d\n",ans);
	}
    return 0;
}

end:
2021-08-04
21:07:23