餐饮（网络流之拆点）

奶牛们在吃饭方面十分挑剔。

每头奶牛都有自己喜欢的食物和饮料，并且不会食用其他不喜欢的食物和饮料。

农夫约翰为他的奶牛们做了美味的饭菜，但他忘了对照他们的喜好来检查菜单。

虽然他可能无法令所有奶牛满意，但他想给尽可能多的奶牛提供一顿完整的用餐----既有食物可吃，也有饮料可喝。

农夫约翰一共烹制了 $F$ 种食物，并提供了 $D$ 种饮料。

约翰共有 $N$ 头奶牛，其中第 $i$ 头奶牛有 $F_i$ 种喜欢的食物以及 $D_i$ 种喜欢的饮料。

约翰需要给每头奶牛分配一种食物和一种饮料，并使得有吃有喝的奶牛数量尽可能大。

每种食物或饮料都只有一份，所以只能分配给一头奶牛食用。

输入格式

第一行包含三个整数 $N,F,D$。

接下来 $N$ 行，其中第 $i$ 行描述第 $i$ 头奶牛的饮食喜好，首先包含两个整数 $F_i$ 和 $D_i$，表示其喜欢的食物和饮料数量，然后包含 $F_i$ 个整数表示其喜欢的食物的种类编号，最后包含 $D_i$ 个整数表示其喜欢的饮料的种类编号。

食物编号从 $1$ 到 $F$，饮料编号从 $1$ 到 $D$。

输出格式

输出一个整数，表示能够有吃有喝的奶牛的最大数量。<

数据范围

$1\le N,F,D\le 100$,
$1\le F_i\le F$,
$1\le D_i\le D$

输入样例：

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

样例解释

一种使得三头奶牛满意的可行方法是：

奶牛 $1$：没饭。
奶牛 $2$：食物 $2$，饮料 $2$。
奶牛 $3$：食物 $1$，饮料 $1$。
奶牛 $4$：食物 $3$，饮料 $3$。

思路

本道题是匹配的题目，有点像二分图匹配，但这道题我们可以看作是三分图匹配。

如果我们按照如上图所示建图的话（类比二分图的建图方式），我们会发现，一头牛会被多个食品匹配，且一头牛又会匹配多个饮料，因此无法做到一一对应。

针对这个问题，我们可以用拆点，拆成入点和出点。

我们就这样，此时从入点向出点连权重为 $1$ 的边，就能保证一头牛吃一个食品和饮料。

规律：当边有限制的时候，我们把容量放在边上，当点有限制的时候，我们把它拆成入点和出点（对这个点的限制放在入点和出点间的边上）。

为什么是正确的呢？我们可以很轻松的证明构造图上的一组可行流（从源点到汇点）是一组匹配。

经验：个人感觉最大流当每个边的容量为 $1$ 的时候，最大流就是最大匹配数量。如果不为1的话，最大流就是最大的可行流（能从源点走向汇点的最大的）的集合。

上图为点的编号。

要特别注意这个编号。

AC 代码

//类似三分图，但我们要拆点

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 410,M = (410*3+10000*2)*2+10,INT = 1e8;

int e[M],ne[M],f[M],h[N],idx;
int cur[N],d[N];
int n,F,D,S,T;

void add(int a,int b,int c){
    e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
}

bool bfs(){
    queue<int>q;
    
    q.push(S);
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

int find(int u,int lim){
    if(u==T)return lim;
    
    int flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]){
            int t=find(ver,min(f[i],lim-flow));
            if(!t)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic(){
    int r=0,flow;
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r;
}

int main(){
    cin>>n>>F>>D;
    
    S=0,T=n*2+F+D+1;
    
    memset(h,-1,sizeof h);
    
    for(int i=1;i<=F;i++){
        add(S,2*n+i,1);
    }
    
    for(int i=1;i<=D;i++){
        add(2*n+F+i,T,1);
    }
    
    for(int i=1;i<=n;i++){
        add(i,i+n,1);
        
        int a,b,t;
        cin>>a>>b;
        
        while(a--){
            cin>>t;
            add(2*n+t,i,1);
        }
        
        while(b--){
            cin>>t;
            add(i+n,2*n+F+t,1);
        }
    }
    
    cout<<dinic();
    
    return 0;
    
}