BZOJ 1711 [Usaco2007 Open]Dining吃饭

1711: [Usaco2007 Open]Dining吃饭

Description

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

Input

* 第一行: 三个数: N, F, 和 D

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

Output

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

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

输入解释:

牛 1: 食品从 {1,2}, 饮料从 {1,2} 中选
牛 2: 食品从 {2,3}, 饮料从 {1,2} 中选
牛 3: 食品从 {1,3}, 饮料从 {1,2} 中选
牛 4: 食品从 {1,3}, 饮料从 {3} 中选

Sample Output

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

---

　　虽说是典型水题，但第一次提交时居然WA了。且让我们娓娓道来。

　　源点s到f种食物连一条容量为1的边，d种饮料到汇点t连一条容量为1的边。然后牛与对应的食物和饮料连边。

　　但是！牛是要拆的，因为牛也有专一性。最后，此题数据太水。

Accepted

2428 kb

8 ms

/**************************************************************
    Problem: 1711
    User: Doggu
    Language: C++
    Result: Accepted
    Time:8 ms
    Memory:2428 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <algorithm>
template<class T>inline void readin(T &res) {
    static char ch;T flag=1;
    while((ch=getchar())<'0'||ch>'9')if(ch=='-')flag=-1;
    res=ch-48;while((ch=getchar())>='0'&&ch<='9')res=(res<<1)+(res<<3)+ch-48;res*=flag;
}
 
const int N = 1000;
const int M = 100000;
struct Edge {int v,upre,cap,flow;}g[M];
int head[N], ne=-1;
inline void adde(int u,int v,int cap) {
    g[++ne]=(Edge){v,head[u],cap,0};head[u]=ne;
    g[++ne]=(Edge){u,head[v],0,0};head[v]=ne;
}
 
#include <queue>
std::queue<int> q;
int n, f, dr, s, t, d[N], cur[N];
bool BFS() {
    while(!q.empty()) q.pop();
    memset(d,0,sizeof(d));
    q.push(s);d[s]=1;
    while(!q.empty()) {
        int u=q.front();q.pop();
        for( int i = head[u]; i != -1; i = g[i].upre ) {
            int v=g[i].v;
            if(!d[v]&&g[i].cap>g[i].flow) q.push(v), d[v]=d[u]+1;
        }
    }
    return d[t];
}
int DFS(int u,int a) {
    if(u==t||a==0) return a;
    int flow=0, f;
    for( int &i = cur[u]; i != -1; i = g[i].upre ) {
        int v=g[i].v;
        if(d[v]==d[u]+1&&(f=DFS(v,std::min(a,g[i].cap-g[i].flow)))>0) {
            flow+=f;a-=f;
            g[i].flow+=f;g[i^1].flow-=f;
            if(a==0) break;
        }
    }
    if(flow==0) d[u]=0;
    return flow;
}
void maxflow() {
    int flow=0;
    while(BFS()) {
        memcpy(cur,head,sizeof(head));
        flow+=DFS(s,0x3f3f3f3f);
    }
    printf("%d\n",flow);
}
 
int main() {
    memset(head,-1,sizeof(head));
    readin(n);readin(f);readin(dr);s=0;t=f+n*2+dr+1;
    for( int i = 1; i <= f; i++ ) adde(s,i,1);
    for( int i = 1; i <= n; i++ ) adde(f+i,f+n+i,1);
    for( int i = 1; i <= dr; i++ ) adde(f+n*2+i,t,1);
    for( int i = 1, a, b, c; i <= n; i++ ) {
        readin(a);readin(b);
        for( int j = 1; j <= a; j++ ) {
            readin(c);
            adde(c,f+i,1);
        }
        for( int j = 1; j <= b; j++ ) {
            readin(c);
            adde(f+n+i,f+n*2+c,1);
        }
    }
    maxflow();
    return 0;
}