晚餐(题解)

题目描述

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

输入格式

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

输出格式

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

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,3} 中选
牛 2: 食品从 {2,3}, 饮料从 {1,2} 中选
牛 3: 食品从 {1,3}, 饮料从 {1,2} 中选
牛 4: 食品从 {1,3}, 饮料从 {3} 中选
output
3
输出解释:

一个方案是:
Cow 1: 不吃
Cow 2: 食品 #2, 饮料 #2
Cow 3: 食品 #1, 饮料 #1
Cow 4: 食品 #3, 饮料 #3
用鸽笼定理可以推出没有更好的解 (一共只有3总食品和饮料).当然,别的数据会更难.

Solution

由于有 N 只奶牛、F 种食物和 D 种饮料，因此我们可以将这些东西抽象成图 中的点。为了方便，我们将食物放在左边，奶牛放在中间，饮料放在右边。沿用
前面的建模方式，由于食物和饮料的使用限制，我们从源点向每种食物连一条边， 从每种饮料向汇点连一条边，容量都为 1。而每只奶牛都有喜欢的食物和饮料， 因此将每只奶牛喜欢的食物连到这只奶牛，从这只奶牛连到每种它喜欢的饮料。
但这样是否就对了呢？实际还是有问题的，因为经过每只奶牛的食物可能超 过一种，这就意味着每只奶牛可能会吃超过一组的食物和饮料，而这在题目中是 不允许的。
怎 么 解 决 这 个 问 题 呢 ？ 我 们 又 回 到 了 流 的 基 本 性 质 ： 容 量 限 制

$f (u, v)≤c(u, v)$。因此我们将每只奶牛拆成两个点，同一只奶牛的两个点之间连 边，容量为 1。这样我们就能保证通过每只奶牛的流量为 1 了。每个流对应每种方案，最大流即为最佳方案。

可见最大流模型的一般建模思路是运用流的容量限制，使得题目中的约束得
以满足，有时还需使用一些特殊的方法（如上题中的拆点）来满足题目的特别约 束。

代码：

//By Bibi
///                 .-~~~~~~~~~-._       _.-~~~~~~~~~-.
///             __.'              ~.   .~              `.__
///           .'//                  \./                  \\`.
///        .'//                     |                     \\`.
///       .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
///     .'//.-"                 `-.  |  .-'                 "-.\\`.
///   .'//______.============-..   \ | /   ..-============.______\\`.
/// .'______________________________\|/______________________________`.
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define dep(i,a,b) for(int i=a;i>=b;--i)
using namespace std;
const int MAXN=30010;
const int INF=0x7fffffff;
int read(){
    int sum=0,flag=1;
    char c;
    for(;c<'0'||c>'9';c=getchar())if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())sum=(sum<<1)+(sum<<3)+c-'0';
    return sum*flag;
}
bool check=true;
int deep[MAXN];
int fd,ans;
int link[MAXN],tot=1;
struct edge{
    int y,v,next;
}e[MAXN<<1];
int head,tail,q[MAXN];
int n,f,d;
void insert(int x,int y,int v){
    e[++tot].y=y;e[tot].v=v;e[tot].next=link[x];link[x]=tot;
    e[++tot].y=x;e[tot].v=0;e[tot].next=link[y];link[y]=tot;
}
void init(){
     n=read();f=read();d=read();
     int sum=2+n+n+f+d;
     rep(i,1,n){
        insert(f+i+1,f+n+i+1,1);
        int x=read(),y=read();
        rep(j,1,x){
            int t=read();
            insert(t+1,f+i+1,1);
        }
        rep(j,1,y){
            int t=read();
            insert(f+n+i+1,f+n+n+t+1,1);
        }
     }
     rep(i,1,f) insert(1,i+1,1);
     rep(i,1,d) insert(f+n+n+i+1,sum,1);
     n=sum;
}
void bfs(){
    memset(deep,-1,sizeof(deep));
    head=tail=0;
    q[++tail]=1;deep[1]=0;
    while(head<tail){
        int k=q[++head];
        for(int i=link[k];i;i=e[i].next)
            if(e[i].v&&deep[e[i].y]<0){
                deep[e[i].y]=deep[k]+1;
                q[++tail]=e[i].y;
            }
    }
    if(deep[n]!=-1) check=true;
}
int dfs(int k,int l){
    if(k==n) return l;
    int maxl=0;
    for(int i=link[k];i&&maxl<l;i=e[i].next){
        int y=e[i].y;
        if(deep[y]==deep[k]+1&&e[i].v){
            if(fd=dfs(y,min(e[i].v,l-maxl))){
                maxl+=fd;
                e[i].v-=fd;
                e[i^1].v+=fd;
            }
        }
    }
    if(!maxl) deep[k]=-1;
    return maxl;
}
void dinic(){
    while(check){
        check=false;
        bfs();
        if(!check) break;
        while(fd=dfs(1,INF)) ans+=fd;
    }
}
int main(){
    init();
    dinic();
    printf("%d\n",ans );
    return 0;
}