poj 3281

终于在有模版 有算法书的情况下 倒腾了半天 a了人生中第一道最大流

题意：

有n头牛，f种食物， d种饮料，每头牛都有自己喜欢的饮料和食物，问最多能让几头牛同时得到喜欢的食物和饮料.

关键是建图 增加一个超级汇源 s  一个超级汇点t

然后 s 与食物连边 饮料与t 连边  为了防止一头牛不会被多组食物分配 所以将牛拆开

然后就是  s  -  食物 - 牛 -  牛 - 饮料 - t

然后就是套最大流模版 

#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
#include <vector>
#include <string>
#include <iterator>
#include <cmath>
#include <deque>
#include <stack>
#include <cctype>
#include <iomanip>
using namespace std;

typedef long long ll;
typedef long double ld;

const int N = 1100;
const int INF = 0xfffffff;

#define INFL 0x7fffffffffffffffLL
#define met(a, b) memset(a, b, sizeof(a))

struct edge{int from, to, cap, flow;};
vector <edge> edges; //边表
vector <int> G[N]; //邻接表 G[i][j] 结点i的第j条边在e数组中的序号
bool vis[N]; // bfs使用
int d[N]; // 从起点到i的距离
int cur[N]; //当前弧下标
bool liked[N][N], likef[N][N];

void addedge (int from, int to, int cap)
{
    edges.push_back((edge){from, to, cap, 0});
    edges.push_back((edge){to, from, 0, 0});
    int tm = edges.size();
    G[from].push_back(tm-2);
    G[to].push_back(tm-1);
}
bool bfs (int s, int t)
{
    met (vis, false);
    queue <int> que;
    que.push (s);
    d[s] = 0;
    vis[s] = true;
    while (que.size())
    {
        int x = que.front(); que.pop();
        for (int i=0; i<G[x].size(); i++)
        {
            edge &e = edges[G[x][i]];
            if (!vis[e.to] && e.cap > e.flow)
            {
                vis[e.to] = 1;
                d[e.to] = d[x] + 1;
                que.push(e.to);
            }
        }
    }
    return vis[t];
}

int dfs (int x, int t, int a)
{
    if (x == t || a == 0) return a;
    int flow = 0, f;
    for (int &i=cur[x]; i<G[x].size(); i++)
    {
        edge &e = edges[G[x][i]];
        if (d[x] + 1 == d[e.to] && (f = dfs(e.to, t, min(a, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[x][i] ^ 1].flow -= f;
            flow += f;
            a -= f;
            if (a == 0) break;
        }
    }
    return flow;
}

int maxflow (int s, int t)
{
    int flow = 0;
    while (bfs(s, t))
    {
        met (cur, 0);
        flow += dfs(s, t, INF);
    }
    return flow;
}

void solve (int n1, int f1, int d1)
{
    // 0 ~ n1-1 食物一侧的牛
    // n1 ~ 2*n1-1:饮料一侧的牛
    // 2*n1 ~ 2*n1+f-1 食物
    //2*n1+f ~ 2*n1+f+d-1 饮料
    int s = n1 * 2 + f1 + d1, t = s + 1;
    for (int i=0; i<f1; i++) //s 与 食物
        addedge(s, n1*2+i, 1);

    for (int i=0; i<d1; i++) //饮料 和 t
        addedge(n1*2+f1+i, t, 1);

    for (int i=0; i<n1; i++) //食物和左侧的牛
    {
        addedge(i, n1+i, 1);
        for (int j=0; j<f1; j++)
        {
            if (likef[i][j])
                addedge(n1*2+j, i, 1);
        }
        for (int j=0; j<d1; j++)
        {
            if (liked[i][j])
                addedge(n1+i, n1*2+f1+j, 1);
        }
    }
    cout << maxflow (s, t) << endl;
}

int main ()
{
    int n1, d1, f1;
    while (cin >> n1 >> f1 >> d1)
    {
        int x, y, tx, ty;
        met (liked, false);
        met (likef, false);
        met (G, 0);
        edges.clear();

        for (int i=0; i<n1; i++)
        {
            cin >> x >> y;
            while (x--)
            {
                cin >> tx;
                likef[i][tx-1] = true;
            }
            while (y--)
            {
                cin >> ty;
                liked[i][ty-1] = true;
            }
        }
        solve (n1, f1, d1);
    }
    return 0;
}