【UVA10079 训练指南】收集者的难题【最大流】

题意：

  Bob和他的朋友从糖果包装里手机贴纸。这些朋友每人手里都有一些（可能有重复的）贴纸，并且只跟别人交换他所没有的贴纸，贴纸总是一对一交换。

 Bob比这些朋友更聪明，因为他意识到只跟别人交换自己没有的贴纸并不总是最优的。在某些情况下，换来一张重复的贴纸更划算。

 假设Bob的朋友只和Bob交换（他们之间不交换），并且这些朋友只会出让手里的重复贴纸来交换他们没有的不同贴纸。你的任务是帮助Bob算出他最终可以得到的不同贴纸的最大数量。

分析：

  建n-1个点（除Bob以外的每个人）和m个点（每个物品）从s向每个物品连边，容量为拥有该物品的数量。如果某人已经至少拥有两个物品j，那么就从i向j连边，容量为拥有的物品数-1；如果没有物品j，就从j向i连边。

 

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

using namespace std;
const int maxn=1000+10;
const int maxm=30;
const int INF=2147000000;
struct Dinic{
    int head[maxn],Next[maxn],to[maxn],cap[maxn],flow[maxn];
    int sz,n,m,s,t;
    bool vis[maxn];
    int cur[maxn],d[maxn];
    void init(int n){
        this->n=n;
        memset(head,-1,sizeof(head));
        this->sz=-1;
    }
    void add_edge(int a,int b,int c){
        ++sz;
        to[sz]=b;
        cap[sz]=c;flow[sz]=0;
        Next[sz]=head[a];head[a]=sz;
        ++sz;
        to[sz]=a;
        cap[sz]=c;flow[sz]=c;
        Next[sz]=head[b];head[b]=sz;
    }
    bool BFS(){
        memset(vis,0,sizeof(vis));
        queue<int>Q;
        vis[s]=1;
        d[s]=0;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(!vis[v]&&cap[i]>flow[i]){
                    vis[v]=1;
                    d[v]=d[u]+1;
                    Q.push(v);
                }
            }
        }
        return vis[t];
   }
    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int Flow=0,f;
        for(int& i=cur[x];i!=-1;i=Next[i]){
            int v=to[i];
            if(d[v]==d[x]+1&&(f=DFS(v,min(a,cap[i]-flow[i])))>0){
                Flow+=f;
                flow[i]+=f;
                flow[i^1]-=f;
                a-=f;
                if(a==0)break;
            }
        }
        return Flow;
    }
    int Maxflow(int s,int t){
        this->s=s,this->t=t;
        int Flow=0;
        while(BFS()){
            for(int i=0;i<=n;i++)
             cur[i]=head[i];

            Flow+=DFS(s,INF);
        }
        return Flow;
    }
}dinic;
int n,m,T,kase;
int main(){
    kase=0;
    scanf("%d",&T);
    for(int t=1;t<=T;t++){
        ++kase;
        scanf("%d%d",&n,&m);
        dinic.init(n+m+2);
        int a[maxm];
        dinic.s=0;dinic.t=n+m+1;
        for(int i=1;i<=n;i++){
            int num;
            scanf("%d",&num);
            memset(a,0,sizeof(a));
            for(int j=1;j<=num;j++){
                int aa;
                scanf("%d",&aa);
                a[aa]++;
            }
            if(i==1){
                for(int j=1;j<=m;j++){
                    if(a[j])
                    dinic.add_edge(0,n+j,a[j]);
                }
            }else{
                for(int j=1;j<=m;j++){
                    if(a[j]>=2){
                        dinic.add_edge(i,n+j,a[j]-1);
                    }
                    if(a[j]==0){
                        dinic.add_edge(n+j,i,1);
                    }
                }
            }
        }
        for(int i=1;i<=m;i++)
            dinic.add_edge(i+n,dinic.t,1);
        int ans=dinic.Maxflow(0,dinic.t);
        printf("Case #%d: %d
",kase,ans);
    }
return 0;
}