[网络流]poj3281 Dining

题意：

有N头奶牛，D种食物和K种饮料，每头奶牛有自己喜欢的食物和饮料，每种食物和饮料只能被一头奶牛选，一头奶牛只能选一种食物和饮料，求最多会有多少头奶牛既能吃到自己喜欢的食物又能喝到喜欢的饮料。

思路：

这种题目就是赤裸裸的最大流。

建立一个源点，从源点开始，连接每一种食物，容量为1，每种食物连接喜欢这种食物的奶牛，容量为1，每头奶牛连接它喜欢的饮料，所有饮料连接汇点，做一次最大流。

但是要注意一点，如果出现下图的情况，是不符合题意要求的，就错了。

如图，每一条边的容量都是1，

如果直接做最大流，答案是2，但是根据题意，一个奶牛只能选一种食物或饮料，按照这样的图答案应该为1，所以要想一想解决办法。

从每一头奶牛开始，连接上一头被复制的奶牛，容量同样为1，那么，从这个点过来的奶牛就只能有一种食物，流到后面的饮料上是也只会有一个流量，必然满足题意。

因为最大的N、D、F都为100，再加上复制的奶牛，一共有400个点，所以源点为0，汇点为401

所以可以写出下面的代码：

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

using namespace std;

const int MAXN = 500 + 10,
          INF = 0x3f3f3f3f;

struct Edge {
    int from, to, cap, flow;
    Edge(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};

struct EdmondsKarp {
    int n, m;
    vector < Edge > edges;
    vector < int > G[MAXN];
    int a[MAXN];
    int p[MAXN];

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    int Maxflow(int s, int t) {
        int flow = 0;

        for(;;) {
            memset(a, 0, sizeof a);
            queue < int > Q;
            Q.push(s);
            a[s] = INF;

            while(!Q.empty()) {
                int x = Q.front();
                Q.pop();

                for(int i = 0; i < G[x].size(); ++i) {
                    Edge& e = edges[G[x][i]];

                    if(!a[e.to] && e.cap > e.flow) {
                        p[e.to] = G[x][i];
                        a[e.to] = min(a[x], e.cap - e.flow);
                        Q.push(e.to);
                    }
                }

                if(a[t]) {
                    break;
                }
            }

            if(!a[t]) {
                break;
            }

            for(int u = t; u != s; u = edges[p[u]].from) {
                edges[p[u]].flow += a[t];
                edges[p[u] ^ 1].flow -= a[t];
            }

            flow += a[t];
        }

        return flow;
    }
} ek;

int main(void) {
    int n, f, d;
    cin >> n >> f >> d;
	
    const int s = 0,
              t = 401;

    const int _food = 0,
               _cow = 100,
             _drink = 200,
			  _cow2 = 300;

	for(int i = 1; i <= f; ++i) {
		ek.AddEdge(s, i + _food, 1);
	}
	
	for(int i = 1; i <= d; ++i) {
		ek.AddEdge(i + _drink, t, 1);
	}
	
	for(int i = 1; i <= n; ++i) {
		ek.AddEdge(i + _cow, i + _cow2, 1);
	}
	
    for(int i = 1; i <= n; ++i) {
        int Dn, Fn;
        cin >> Fn >> Dn;

        for(int j = 0; j < Fn; ++j) {
            int x;
            cin >> x;

            ek.AddEdge(x + _food, _cow + i, 1);
        }

        for(int j = 0; j < Dn; ++j) {
            int x;
            cin >> x;

            ek.AddEdge(_cow2 + i, x + _drink, 1);
        }
    }

    cout << ek.Maxflow(s, t);

    return 0;
}