poj 3281 Dining【拆点网络流】

Dining

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 11828		Accepted: 5437

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

3

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份的饮料，但是每头牛都很挑剔，他们只吃自己喜欢的食物，现在要让你给牛分配食物和饮料，（一头牛吃过的食物不可以分给其他牛）问最多能给多少头牛分配他们喜欢的食物和饮料

 

输入：第一行输入n，f，d，表示牛的个数，食物和饮料的数量，   接下来n行，每行前两个数fi，di，分别代表当前行（即第i行为第i头牛）这头牛喜欢吃的食物的类型的数量和喜欢喝的饮料的类型的数量，再接下来fi个数代表第i头牛喜欢吃的食物的编号，接下来di个数代表牛喜欢喝的饮料的编号

 

题解：将牛分为左牛和右牛，设置超级源点和超级汇点   建图的思路：超级源点->食物->左牛->右牛->饮料->超级汇点   每条边的容量为1        不能直接食物指向牛，牛再指向饮料是因为这样的话可能一头牛就不止分配一种食物和饮料了  画个图来解释

1、若直接食物->牛->饮料

          食物             牛                   饮料

如图，例如当1到4这条路走过后 4连上5，当2经过4后4又可以连上6，这就造成了一头牛吃了多种食物和饮料

2、食物->左牛->右牛->饮料

这种情况当左牛选中一个食物之后经过右牛，左右牛之间的路径已经满流不能继续走，就避免了一头牛吃多种食物和饮料的情况

AC代码：

#include<stdio.h>
#include<string.h>
#include<queue>
#include<stack>
#include<algorithm>
#define MAX 1000
#define MAXM 200100
#define INF 0x7fffff
using namespace std;
int n,f,d;
int ans,head[MAX];
int cur[MAX];
int dis[MAX];
int vis[MAX];
int sect;
struct node
{
	int from,to,cap,flow,next;
}edge[MAXM];
void init()
{
	ans=0;
	memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
	edge[ans]={u,v,w,0,head[u]};
	head[u]=ans++;
	edge[ans]={v,u,0,0,head[v]};
	head[v]=ans++;
}
void getmap()
{
	int i,j,a,b,fi,di;
	for(i=1;i<=n;i++)
	{
		scanf("%d%d",&fi,&di);
		while(fi--)
		{
			scanf("%d",&a);
			///xxx//add(0,a,1);//源点连食物
			add(a,f+i,1);//食物连左牛
		}
		add(f+i,n+i+f,1);//左牛连右牛
		while(di--)
		{
			scanf("%d",&b);
			add(n+i+f,2*n+f+b,1);//右牛连饮料
		}
	}
	int db=2*n+f+1,de=2*n+f+d;
	for(i=1;i<=f;i++)
	    add(0,i,1);//源点连食物
	for(i=db;i<=de;i++)
	    add(i,de+1,1);//饮料连超级汇点
	sect=2*n+f+d+1;
}
int bfs(int beg,int end)
{
    int i;
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));
    queue<int>q;
    while(!q.empty())
        q.pop();
    vis[beg]=1;
    dis[beg]=0;
    q.push(beg);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(i=head[u];i!=-1;i=edge[i].next)//遍历所有的与u相连的边
        {
            node E=edge[i];
            if(!vis[E.to]&&E.cap>E.flow)//如果边未被访问且流量未满继续操作
            {
                dis[E.to]=dis[u]+1;//建立层次图
                vis[E.to]=1;//将当前点标记
                if(E.to==end)//如果当前点搜索到终点则停止搜索  返回1表示有从原点到达汇点的路径
                    return 1;
                q.push(E.to);//将当前点入队
            }
        }
    }
    return 0;//返回0表示未找到从源点到汇点的路径
}
int dfs(int x,int a,int end)//把找到的这条边上的所有当前流量加上a（a是这条路径中的最小残余流量）
{
    //int i;
    if(x==end||a==0)//如果搜索到终点或者最小的残余流量为0
        return a;
    int flow=0,f;
    for(int& i=cur[x];i!=-1;i=edge[i].next)//i从上次结束时的弧开始
    {
        node& E=edge[i];
        if(dis[E.to]==dis[x]+1&&(f=dfs(E.to,min(a,E.cap-E.flow),end))>0)//如果
        {//bfs中我们已经建立过层次图，现在如果 dis[E.to]==dis[x]+1表示是我们找到的路径
        //如果dfs>0表明最小的残余流量还有，我们要一直找到最小残余流量为0
            E.flow+=f;//正向边当前流量加上最小的残余流量
            edge[i^1].flow-=f;//反向边
            flow+=f;//总流量加上f
            a-=f;//最小可增流量减去f
            if(a==0)
                break;
        }
    }
    return flow;//所有边加上最小残余流量后的值
}
int Maxflow(int beg,int end)
{
    int flow=0;
    while(bfs(beg,end))//存在最短路径
    {
        memcpy(cur,head,sizeof(head));//复制数组
        flow+=dfs(beg,INF,end);
    }
    return flow;//最大流量
}
int main()
{
    int t;
    while(scanf("%d%d%d",&n,&f,&d)!=EOF)
    {
        init();
        getmap();
        printf("%d\n",Maxflow(0,sect));
    }
    return 0;
}