POJ 3128 Dining-最大流

最新推荐文章于 2020-01-02 21:39:10 发布

cinyaaaa

最新推荐文章于 2020-01-02 21:39:10 发布

阅读量675

点赞数 1

分类专栏：网络流文章标签：最大流 ACM POJ 3281 Dining 拆点

本文链接：https://blog.csdn.net/cxy450019566/article/details/38360763

版权

网络流专栏收录该内容

4 篇文章 0 订阅

订阅专栏

原题地址：http://poj.org/problem?id=3281

Dining

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 9051		Accepted: 4170

Description

Cows are such finicky eaters. Each cow has a preference for certain foods and drinks, and she will consume no others.

Farmer John has cooked fabulous meals for his cows, but he forgot to check his menu against their preferences. Although he might not be able to stuff everybody, he wants to give a complete meal of both food and drink to as many cows as possible.

Farmer John has cooked F (1 ≤ F ≤ 100) types of foods and prepared D (1 ≤ D ≤ 100) types of drinks. Each of his N (1 ≤ N ≤ 100) cows has decided whether she is willing to eat a particular food or drink a particular drink. Farmer John must assign a food type and a drink type to each cow to maximize the number of cows who get both.

Each dish or drink can only be consumed by one cow (i.e., once food type 2 is assigned to a cow, no other cow can be assigned food type 2).

Input

Line 1: Three space-separated integers: N, F, and D
Lines 2.. N+1: Each line i starts with a two integers F_i and D_i, the number of dishes that cow i likes and the number of drinks that cow i likes. The next F_i integers denote the dishes that cow i will eat, and the D_i integers following that denote the drinks that cow i will drink.

Output

Line 1: A single integer that is the maximum number of cows that can be fed both food and drink that conform to their wishes

Sample Input

4 3 3
2 2 1 2 3 1
2 2 2 3 1 2
2 2 1 3 1 2
2 1 1 3 3

Sample Output

Hint

One way to satisfy three cows is:
Cow 1: no meal
Cow 2: Food #2, Drink #2
Cow 3: Food #1, Drink #1
Cow 4: Food #3, Drink #3
The pigeon-hole principle tells us we can do no better since there are only three kinds of food or drink. Other test data sets are more challenging, of course.

题意：有N头牛，F种食物，D种饮料，第i头牛喜欢Fi种食物，Di种饮料，已知一头牛最多能吃一种食物和一种饮料，每种饮料或食物最多能被一头牛吃，求以上条件下，最多能有多少头牛能吃到他所喜爱的食物和饮料。

题解：用最大流的思路，构图是难点，一头牛只能吃一种食物和一种饮料，并且一种食物只能被一头牛吃，饮料也一样，怎样来构图呢？

首先，很容易想到的思路是”源点—牛—食物—饮料-汇点“这样的构图法，但这样的话，牛流出的流量必须是2，可能出现分别流给2种食物或2种饮料，在食物—饮料—汇点的每条线上设立容量为1也是不行的，因为可能牛喜欢多种饮料。“源点-牛—饮料—食物—汇点”构图也是一样的道理。

第二种容易想到的思路是“源点—食物—牛—饮料—汇点”，而同样是由于牛可以喜欢多种食物和饮料，可能就会出现一头牛吃掉多种食物和饮料对的情况，怎么来限制牛只吃一种食物和一种饮料呢？

这道题的考察点，最大流的端点限制问题，可以理解为牛这个端点只能通过1，所以用拆点的方法，对于每头牛，都建立“牛—牛‘ ”的路径，容量为一，就可以保障从每头牛流出和流进的流量是1了。即建立”源点—牛—牛’—食物—饮料—汇点“的图。再用dinic算法求最大流就可以了。

AC代码：

#include"iostream"
#include "stdio.h"
#include "queue"
using namespace std;
#define N 1000
#define M 10000
#define INF 1000000000

int nc,nf,nd,nn;
int head[N], cur[N], d[N], st[M], s, e, no, n;
struct point{
	int u, v, flow, next;
	point(){};
	point(int x, int y, int z, int w):u(x), v(y), next(z), flow(w){};
}p[M];

void add(int x, int y, int z){
	p[no] = point(x, y, head[x], z);	head[x] = no++;
	p[no] = point(y, x, head[y], 0);	head[y] = no++;
}
void init(){
	memset(head, -1, sizeof(head));
	no = 0;
}

bool bfs(){
	int i, x, y;
	queue
   
   
    
    q;
	memset(d, -1, sizeof(d));
	d[s] = 0;	q.push(s);
	while(!q.empty()){
		x = q.front();	q.pop();
		for(i = head[x]; i != -1; i = p[i].next){
			if(p[i].flow && d[y = p[i].v] < 0){
				d[y] = d[x] + 1;
				if(y == e)	return true;
				q.push(y);
			}
		}
	}
	return false;
}

int dinic(){
	int i, loc, top, x = s, nowflow, maxflow = 0;
	while(bfs()){
		for(i = s; i <= e; i++)	cur[i] = head[i];
		top = 0;
		while(true){
			if(x == e){
				nowflow = INF;
				for(i = 0; i < top; i ++){
					if(nowflow > p[st[i]].flow){
						nowflow = p[st[i]].flow;
						loc = i;
					}
				}
				for(i = 0; i < top; i++){
					p[st[i]].flow -= nowflow;
					p[st[i]^1].flow += nowflow;
				}
				maxflow += nowflow;
				top = loc;	x = p[st[top]].u;
			}
			for(i = cur[x]; i != -1; i = p[i].next)
				if(p[i].flow && d[p[i].v] == d[x] + 1) break;
			cur[x] = i;
			if(i != -1){
				st[top ++] = i;
				x = p[i].v;
			}
			else {
				if(!top)	break;
				d[x] = -1;
				x = p[st[--top]].u;
			}
		}
	}
	return maxflow;
}


int main()
{
	scanf("%d%d%d",&nc,&nf,&nd);
	init();
	int nlf,nld,ifo,ido;
	for(int i=1;i<=nc;i++)
	{
		add(i+100,i+200,1);
		scanf("%d%d",&nlf,&nld);
		for(int j=0;j