bzoj1711【Usaco2007 Open】Dingin 吃饭

1711: [Usaco2007 Open]Dingin吃饭

Time Limit: 5 Sec  Memory Limit: 64 MB

Submit: 670  Solved: 343

[Submit][Status][Discuss]

Description

农夫JOHN为牛们做了很好的食品,但是牛吃饭很挑食. 每一头牛只喜欢吃一些食品和饮料而别的一概不吃.虽然他不一定能把所有牛喂饱,他还是想让尽可能多的牛吃到他们喜欢的食品和饮料. 农夫JOHN做了F (1 <= F <= 100) 种食品并准备了D (1 <= D <= 100) 种饮料. 他的N (1 <= N <= 100)头牛都以决定了是否愿意吃某种食物和喝某种饮料.
农夫JOHN想给每一头牛一种食品和一种饮料,使得尽可能多的牛得到喜欢的食物和饮料. 每一件食物和饮料只能由一头牛来用. 例如如果食物2被一头牛吃掉了,没有别的牛能吃食物2.

Input

* 第一行: 三个数: N, F, 和 D

* 第2..N+1行: 每一行由两个数开始F_i 和 D_i, 分别是第i 头牛可以吃的食品数和可以喝的饮料数.下F_i个整数是第i头牛可以吃的食品号,再下面的D_i个整数是第i头牛可以喝的饮料号码.

Output

* 第一行: 一个整数,最多可以喂饱的牛数.

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

输入解释:

牛 1: 食品从 {1,2}, 饮料从 {1,2} 中选

牛 2: 食品从 {2,3}, 饮料从 {1,2} 中选

牛 3: 食品从 {1,3}, 饮料从 {1,2} 中选

牛 4: 食品从 {1,3}, 饮料从 {3} 中选

Sample Output

3

输出解释:

一个方案是:

Cow 1: 不吃

Cow 2: 食品 #2, 饮料 #2

Cow 3: 食品 #1, 饮料 #1

Cow 4: 食品 #3, 饮料 #3

用鸽笼定理可以推出没有更好的解 (一共只有3总食品和饮料).当然,别的数据会更难.

HINT

Source

Gold

最大流。

一开始的想法是把牛放左端，食物和饮料放右端，但是发现怎么搞也搞不出来。后来看了题解才发现是自己想错了。感觉这道题的方法还是比较巧妙的。

首先我们把食物放左端，牛放中间，饮料放右端。这样一说大家是不是豁然开朗啊！

然后把牛拆成两个点i1和i2。对于每头牛，从喜欢的食物到i1、i1到i2、i2到喜欢的饮料分别连边，容量都为1。再从源点到所有食物、所有饮料到汇点连边，容量同样为1。

最后跑一次最大流。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<queue>
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define LL long long
#define pa pair<int,int>
#define MAXN 500
#define MAXM 100000
#define INF 1000000000
using namespace std;
int n,nf,nd,fi,di,s,t,x,cnt=1,ans=0;
int head[MAXN],cur[MAXN],dis[MAXN];
struct edge_type
{
	int next,to,v;
}e[MAXM];
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
inline void add_edge(int x,int y,int v)
{
	e[++cnt]=(edge_type){head[x],y,v};head[x]=cnt;
	e[++cnt]=(edge_type){head[y],x,0};head[y]=cnt;
}
inline bool bfs()
{
	queue<int>q;
	memset(dis,-1,sizeof(dis));
	dis[s]=0;q.push(s);
	while (!q.empty())
	{
		int tmp=q.front();q.pop();
		if (tmp==t) return true;
		for(int i=head[tmp];i;i=e[i].next) if (e[i].v&&dis[e[i].to]==-1)
		{
			dis[e[i].to]=dis[tmp]+1;
			q.push(e[i].to);
		}
	}
	return false;
}
inline int dfs(int x,int f)
{
	if (x==t) return f;
	int tmp,sum=0;
	for(int &i=cur[x];i;i=e[i].next)
	{
		int y=e[i].to;
		if (e[i].v&&dis[y]==dis[x]+1)
		{
			tmp=dfs(y,min(f-sum,e[i].v));
			e[i].v-=tmp;e[i^1].v+=tmp;sum+=tmp;
			if (sum==f) return sum;
		}
	}
	if (!sum) dis[x]=-1;
	return sum;
}
inline void dinic()
{
	while(bfs())
	{
		F(i,1,t) cur[i]=head[i];
		ans+=dfs(s,INF);
	}
}
int main()
{
	memset(head,0,sizeof(head));
	n=read();nf=read();nd=read();
	s=401;t=402;
	F(i,1,n) add_edge(i+100,i+200,1);
	F(i,1,nf) add_edge(s,i,1);
	F(i,1,nd) add_edge(i+300,t,1);
	F(i,1,n)
	{
		fi=read();di=read();
		F(j,1,fi){x=read();add_edge(x,i+100,1);}
		F(j,1,di){x=read();add_edge(i+200,x+300,1);}
	}
	dinic();
	printf("%d\n",ans);
}