POJ 3281 Dining（最大流 - EK算法）

Dining

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 Fi and Di, the number of dishes
that cow i likes and the number of drinks that cow i likes. The next
Fi integers denote the dishes that cow i will eat, and the Di 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种食物（食物序号为1~f，每种食物各1个），d种饮料（饮料编号为1 ~d，每种饮料各一瓶）。然后接下来的1 ~n行，第一行表示的是第一头牛的数据，第一个数为f1,第二个数为d1，f1表示的是这头牛喜欢吃的食物有f1种，d1表示喜欢喝的饮料有d1种，然后接下来f1个数，每个数表示这头牛喜欢吃的食物的序号，然后接下来d1个数，每个数表示这头牛喜欢喝的饮料数。一头牛只有吃到自己喜欢吃的食物同时喝到自己喜欢喝的饮料，这头牛就会感到满意，题目问你最多使多少头牛满意

思路：

这道题用最大流就可以解决，主要难想的点是建图问题，你可以这样建图
超级源点 - 食物 - 牛 - 牛 - 饮料 - 超级汇点
在建图的过程中把每次相连的点值为1，因为每种食物和饮料就只有一个，这样建完图后套一下 EK 的版子就直接能过了

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=505;
int v[maxn][maxn];
int pre[maxn];
int flow[maxn];
int n,f,d;
queue<int>q;
int bfs(int began ,int endd)
{
    while(!q.empty())q.pop();
    flow[began]=99999999;
    for(int a=0;a<=endd;a++)
    {
        pre[a]=-1;
    }
    pre[began]=0;
    q.push(began);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        if(u==endd)break;
        for(int i=0;i<=endd;i++)
        {
            if(i!=began&&pre[i]==-1&&v[u][i])
            {
                pre[i]=u;
                flow[i]=min(flow[u],v[u][i]);
                q.push(i);
            }
        }
    }
    if(pre[endd]==-1)
    {
        return -1;
    }
    return flow[endd];
}
int ek(int began,int endd)
{
   int maxflow=0;
   int step,now,p;
   while(step=bfs(began,endd)!=-1)
   {
       maxflow+=step;
       now=endd;
       while(now!=began)
       {
           p=pre[now];
           v[p][now]-=step;
           v[now][p]+=step;
           now=p;
       }
   }
   return maxflow;
}
int main()
{
    while(scanf("%d%d%d",&n,&f,&d)!=EOF)
    {
        memset(v,0,sizeof(v));
        for(int a=1;a<=f;a++)v[0][a]=1; //超级源点到牛
        for(int a=1;a<=n;a++)v[f+2*a-1][f+2*a]=1; //牛到牛
        for(int a=f+2*n+1;a<=f+2*n+d;a++)v[a][f+2*n+d+1]=1; //饮料到超级汇点
        for(int a=1;a<=n;a++)
        {
           int f1,d1;
           int x;
           scanf("%d%d",&f1,&d1);
           for(int i=1;i<=f1;i++)
           {
               scanf("%d",&x);
               v[x][f+2*a-1]=1;  //食物到牛
           }
           for(int i=1;i<=d1;i++)
           {
               scanf("%d",&x);
               v[f+2*a][f+2*n+x]=1; //牛到饮料
           }
        }
        printf("%d\n",ek(0,2*n+f+d+1));
    }
    return 0;
}