TZOJ 1705 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).

输入

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.

输出

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

样例输入

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

样例输出

3

提示

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个喜欢的饮料，每种食物每瓶饮料只能供一头牛，问最多几头牛能感到满足（即又有喜欢的食物也有喜欢的饮料）

题解

首先食物连源点S流量1，饮料连汇点T流量1，食物连喜欢的牛流量1，饮料也连喜欢的牛流量1

这时候有个问题就是牛只能流出最多1的流量和饮料匹配，所以我们可以把牛拆成左牛和右牛，这样保证从牛最多流出1的流量

那么食物连左牛流量1，左牛连右牛流量1，右牛连饮料流量1

建完图，跑最大流算法即可

代码

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+5;
const int M=2e5+5;
int n,m,S,T;
int deep[N],q[400000];
int FIR[N],TO[M],CAP[M],COST[M],NEXT[M],tote;

void add(int u,int v,int cap)
{
    TO[tote]=v;
    CAP[tote]=cap;
    NEXT[tote]=FIR[u];
    FIR[u]=tote++;

    TO[tote]=u;
    CAP[tote]=0;
    NEXT[tote]=FIR[v];
    FIR[v]=tote++;
}
bool bfs()
{
    memset(deep,0,sizeof deep);
    deep[S]=1;q[1]=S;
    int head=0,tail=1;
    while(head!=tail)
    {
        int u=q[++head];
        for(int v=FIR[u];v!=-1;v=NEXT[v])
        {
            if(CAP[v]&&!deep[TO[v]])
            {
                deep[TO[v]]=deep[u]+1;
                q[++tail]=TO[v];
            }
        }
    }
    return deep[T];
}
int dfs(int u,int fl)
{
    if(u==T)return fl;
    int f=0;
    for(int v=FIR[u];v!=-1&&fl;v=NEXT[v])
    {
        if(CAP[v]&&deep[TO[v]]==deep[u]+1)
        {
            int Min=dfs(TO[v],min(fl,CAP[v]));
            CAP[v]-=Min;CAP[v^1]+=Min;
            fl-=Min;f+=Min;
        }
    }
    if(!f)deep[u]=-2;
    return f;
}
int maxflow()
{
    int ans=0;
    while(bfs())
        ans+=dfs(S,1<<30);
    return ans;
}
void init()
{
    tote=0;
    memset(FIR,-1,sizeof FIR);
}
int main()
{
    int v,cow,F,D,food,drink;
    init();
    cin>>cow>>F>>D;
    S=F+2*cow+D+1,T=S+1;
    for(int i=1;i<=F;i++)
        add(S,i,1);
    for(int i=F+2*cow+1;i<=F+2*cow+D;i++)
        add(i,T,1);
    for(int i=F+1;i<=F+cow;i++)
    {
        add(i,cow+i,1);
        cin>>food>>drink;
        while(food--)cin>>v,add(v,i,1);
        while(drink--)cin>>v,add(cow+i,F+2*cow+v,1);
    }
    cout<<maxflow();
    return 0;
}