UVA 10779 Collectors Problem（建模，最大流）

题目：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1720

题目大意：n个人，你是其中之一，现在你有一些卡片，别人也有一些卡片（都可能有重复），你要集卡片，那么就会去别人交换卡片。交换的规则是这样的：（1）卡片都是1换1。（2）其他这n-1个人，他们只会与你交换那些他们有多（>=2张）的卡片而且要是交换回来的卡片是他们没有的。（3）除了你之外的这n-1个人，他们之间不会交换卡片。问你最多能集齐多少张卡片。

解题思路：用m个节点表示m个物品，然后用 n-1 个节点表示除了你之外的人，再增加一个源点s和汇点t。从s连边到m个物品，cap为初始时你拥有的量，再从这m个物品连边到t，cap = 1。下面就是交换的问题。每个人都会与你交换他没有的卡片且交换来他们当前没有的卡片，那么就是对于每个人，连边到 物品，如果这个人拥有的物品数 >=2 ，cap 为 这个数目-1，因为它自己还要留一张，再连边从物品到这个人，如果这个人没有这个物品，即数目为0，cap 为 1，因为只能给他一次。然后就是求最大流了。

        网络流都是神建模啊，自己是没想出来，看了书，又感觉么，挺简单的。。 自己想得到和看了别人再想到，档次可差的不是一点点。。

代码如下：

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int INF = 0x0fffffff;
const int N = 11;
const int M = 33;
const int MAXN = N+M;
const int MAXM = (N+M)*(N+M);

struct Edge
{
    int s,t,flow,cap,next;
}edge[MAXM];

int tot,head[MAXN];

void edge_init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int s,int t,int cap)
{
    edge[tot].s = s;
    edge[tot].t = t;
    edge[tot].cap = cap;
    edge[tot].flow = 0;
    edge[tot].next = head[s];
    head[s] = tot++;

    edge[tot].s = t;
    edge[tot].t = s;
    edge[tot].cap = 0;
    edge[tot].flow = 0;
    edge[tot].next = head[t];
    head[t] = tot++;
}

struct Isap
{
    int n,s,t;
    bool vis[MAXN];
    int hh[MAXN];
    int dis[MAXN],pre[MAXN],num[MAXN];

    void init(int n)
    {
        this->n = n;
    }

    void bfs()
    {
        queue<int> q;
        memset(vis,0,sizeof(vis));
        q.push(t);
        vis[t] = 1;
        dis[t] = 0;
        while(!q.empty())
        {
            int x = q.front();
            q.pop();
            for(int i = head[x];i != -1;i = edge[i].next)
            {
               Edge& e = edge[i^1];
               int to = e.s;
               if(!vis[to] && e.cap > e.flow)
               {
                   vis[to] = 1;
                   dis[to] = dis[x]+1;
                   q.push(to);
               }
            }
        }
    }

    int augment()
    {
        int x = t,a = INF;
        while(x != s)
        {
            Edge& e = edge[pre[x]];
            a = min(a,e.cap-e.flow);
            x = e.s;
        }
        x = t;
        while(x != s)
        {
            edge[pre[x]].flow += a;
            edge[pre[x]^1].flow -= a;
            x = edge[pre[x]].s;
        }
        return a;
    }

    int max_flow(int s,int t,int limit)
    {
        this->s = s;
        this->t = t;
        for(int i = 0;i < n;i++) hh[i] = head[i];
        bfs();
        memset(num,0,sizeof(num));
        for(int i = 0;i < n;i++) num[dis[i]]++;
        int x = s;
        int flow = 0;
        while(dis[s] < n)
        {
            if(x == t)
            {
                flow += augment();
                if(flow >= limit) break;
                x = s;
            }
            int ok = 0;
            for(int i = hh[x];i != -1;i = edge[i].next)
            {
                int to = edge[i].t;
                if(dis[x] == dis[to]+1 && edge[i].cap > edge[i].flow)
                {
                    ok = 1;
                    hh[x] = i;
                    pre[to] = i;
                    x = to;
                    break;
                }
            }
            if(!ok)
            {
                int m = n-1;
                for(int i = head[x];i != -1;i = edge[i].next)
                {
                    int to = edge[i].t;
                    if(edge[i].cap > edge[i].flow)
                        m = min(m,dis[to]);
                }
                if(--num[dis[x]] == 0) break;
                num[dis[x] = m+1]++;
                hh[x] = head[x];
                if(x != s) x = edge[pre[x]].s;
            }
        }
        return flow;
    }
}sol;

struct Person
{
    int num[M];
}person[N];

int get_int()
{
    int x;
    scanf("%d",&x);return --x;
}

int nn;
int id[3][33];

void get_id_init()
{
    nn = 0;
    memset(id,0,sizeof(id));
}

int get_id(int i,int j)
{
    if(id[i][j]) return id[i][j];
    else return id[i][j] = nn++;
}

int main()
{
    int cas = 0;
    int _;
    scanf("%d",&_);
    while(_--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i = 0;i < n;i++)
        {
            int k;
            scanf("%d",&k);
            memset(person[i].num,0,sizeof(person[i].num));
            while(k--)
            {

                person[i].num[get_int()]++;
            }
        }
        edge_init();
        get_id_init();
        int s = get_id(0,0);
        int t = get_id(0,1);
        for(int i = 0;i < m;i++)
        {
            add_edge(s,get_id(1,i),person[0].num[i]);
            add_edge(get_id(1,i),t,1);
        }
        for(int i = 1;i < n;i++)
        {
            for(int j = 0;j < m;j++)
            {
                if(person[i].num[j] >= 2)
                {
                    add_edge(get_id(2,i),get_id(1,j),person[i].num[j]-1);
                }
                else if(person[i].num[j] == 0)
                {
                    add_edge(get_id(1,j),get_id(2,i),1);
                }
            }
        }
        sol.init(nn);
        printf("Case #%d: %d\n",++cas,sol.max_flow(s,t,INF));
    }
    return 0;
}

/*
2
2 5
6 1 1 1 1 1 1
3 1 2 2
3 5
4 1 2 1 1
3 2 2 2
5 1 3 4 4 3
*/