UVALive-3268 Jamie's Contact Groups （最大流，网络流建模）

# include<iostream>
# include<cstdio>
# include<cmath>
# include<string>
# include<vector>
# include<list>
# include<set>
# include<map>
# include<queue>
# include<cstring>
# include<algorithm>
using namespace std;

# define LL long long
# define REP(i,s,n) for(int i=s;i<n;++i)
# define CL(a,b) memset(a,b,sizeof(a))
# define CLL(a,b,n) fill(a,a+n,b)

const double inf=1e30;
const int INF=1<<30;
const int N=1505;

struct Edge
{
    int fr,to,cap,fw;
    Edge(int _fr,int _to,int _cap,int _fw):fr(_fr),to(_to),cap(_cap),fw(_fw){}
};
vector<Edge>edges,tedges;
vector<int>G[N];
int cur[N],vis[N],d[N],mark[505];

void init(int n)
{
    edges.clear();
    REP(i,0,n) G[i].clear();
}

void addEdge(int u,int v,int cap)
{
    edges.push_back(Edge(u,v,cap,0));
    edges.push_back(Edge(v,u,0,0));
    int m=edges.size();
    G[u].push_back(m-2);
    G[v].push_back(m-1);
}

bool BFS(int s,int t)
{
    CL(vis,0);
    vis[s]=1;
    d[s]=0;
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        REP(i,0,G[u].size()){
            Edge &e=edges[G[u][i]];
            if(!vis[e.to]&&e.cap>e.fw){
                d[e.to]=d[u]+1;
                vis[e.to]=1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}

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

int Dinic(int s,int t)
{
    int flow=0;
    while(BFS(s,t)){
        CL(cur,0);
        flow+=DFS(s,t,INF);
    }
    return flow;
}

bool read(int &x)
{
    x=0;
    char c;
    while(c=getchar()){
        if(c==‘ ‘) return true;
        else if(c==‘\n‘) return false;
        else x=x*10+c-‘0‘;
    }
}

bool judge()
{
    REP(i,0,G[0].size())
        if(edges[G[0][i]].cap>0&&edges[G[0][i]].cap!=edges[G[0][i]].fw) return false;
    return true;
}

int main()
{
    int n,m;
    char name[20];
    while(scanf("%d%d",&n,&m)&&(n+m))
    {
        init(n+m+2);
        CL(mark,0);
        REP(i,1,n+1){
            cin>>name;
            addEdge(0,m+i,1);
            int a;
            getchar();
            while(read(a)){
                ++mark[a];
                addEdge(m+i,a+1,1);
            }
            addEdge(m+i,a+1,1);
            ++mark[a];
        }

        int cnt=edges.size();
        tedges.clear();
        REP(i,0,cnt) tedges.push_back(edges[i]);

        int l=0,r=0;
        REP(i,0,m) r=max(r,mark[i]);
        while(l<r){
            int mid=l+(r-l)/2;
            init(n+m+2);
            REP(i,0,cnt) addEdge(tedges[i].fr,tedges[i].to,tedges[i].cap);
            REP(i,0,m) if(mark[i])
                addEdge(i+1,n+m+1,min(mid,mark[i]));
            Dinic(0,n+m+1);
            if(judge()) r=mid;
            else l=mid+1;
        }
        printf("%d\n",l);
    }
    return 0;
}