奶牛的聚会（最大流）

题面

题目描述
N（3<=N<=200）头奶牛要办一个新年晚会。每头牛都会烧几道菜。一共有D(5<=D<=100)道不同的菜肴。每道菜都可以用一个1到D之间的数来表示。 晚会的主办者希望能尽量多的菜肴被带到晚会，但是每道菜的数目又给出了限制。每头奶牛可以带K(1<=K<=5)道菜，但是必须是各不相同的（例如，一头牛不能带三块馅饼，但是可以带上一块馅饼，一份面包，和一些美味的桔子酱苜蓿）。那么，究竟有多少菜可以被带来晚会呢？
输入格式
第一行包括三个整数N,K和D。 第二行有D个非负整数，表示每种菜可以带到晚会上的数目限制。 第三行到第N+2行，每行包括一个整数Z，表示一头牛可以准备的菜的道数；之后Z个整数，表示菜的标号，首先是第一种菜，然后是第二种菜，以此类推。
输出格式
仅一行一个整数，表示可以带到晚会上的最多的菜的数目。

题解

稍加建图就能做的最大流问题，属于信心题。
我们观察题中的限制条件

1. 奶牛能带的菜数
2. 奶牛会的菜
3. 每道菜的数量
4. 每头奶牛只能带不同的菜（不能带两盘以上同一道菜）

所以我们对于每个奶牛和每道菜都建立结点。再建立一个超级源点S，和一个超级汇点T。
从S连向每一头奶牛容量为K的边，代表每头奶牛能带多少菜。
每头奶牛对自己会的菜连一条容量为1的，代表着头奶牛最多只能做一道这样的菜。
每道菜对T连一条容量为d的边（d代表该菜最多能被所有奶牛带几道）。
然后跑dinic最大流就行了。

code

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int num=0;char c=' ';bool flag=true;
    for(;c>'9'||c<'0';c=getchar())
        if(c=='-')
            flag=false;
    for(;c>='0'&&c<='9';num=(num<<3)+(num<<1)+c-48,c=getchar());
    return flag ? num : -num;
}
namespace graph{
    const int maxn=500;
    struct node{
        int y,val,next;
    }a[maxn*maxn];
    int head[maxn],top=0;
    void insert(int x,int y,int v){
        a[top].y=y;
        a[top].val=v;
        a[top].next=head[x];
        head[x]=top++;
    }
    int n,k,d;
    //1~n鏄ザ鐗?
    //n+1~n+d鏄彍
    //婧愮偣0锛屾眹鐐筺+d+1
    int s,t;
    void init(){
        memset(head,-1,sizeof head);
        n=read();
        k=read();
        d=read();
        s=0;t=n+d+1;
        for(int i=1;i<=d;i++){
            int x=read();
            insert(n+i,t,x);
            insert(t,n+i,0);
        }
        for(int i=1;i<=n;i++){
            insert(s,i,k);
            insert(i,s,0);
        }
        for(int i=1;i<=n;i++){
            int z=read();
            for(int j=1;j<=z;j++){
                int x=read();
                insert(i,n+x,1);
                insert(n+x,i,0);
            }
        }
    }
}using namespace graph;

namespace MAX_Flow{
    int vis[maxn],cur[maxn];
    bool bfs(){
        memset(vis,0,sizeof vis);
        queue<int>q;
        q.push(s);
        vis[s]=1;
        while(!q.empty()){
            int u=q.front();
            q.pop();
            for(int i=head[u];i+1;i=a[i].next){
                int v=a[i].y;
                if(vis[v]||a[i].val==0)continue;
                vis[v]=vis[u]+1;
                q.push(v);
                if(v==t)return true;
            }
        }
        return false;
    }
    int dfs(int x,int flow){
        if(x==t)return flow;
        for(int &i=cur[x];i+1;i=a[i].next){
            int y=a[i].y;
            if(vis[y]!=vis[x]+1||a[i].val==0)continue;
            int k=dfs(y,min(flow,a[i].val));
            if(k){
                a[i].val-=k;
                a[i^1].val+=k;
                return k;
            }
        }
        return 0;
    }
}using namespace MAX_Flow;
int main(){
    init();
    int ans=0;
    const int INF=2e9;
    while(bfs()){
        for(int i=s;i<=t;i++)
            cur[i]=head[i];
        while(int flow=dfs(0,INF))
            ans+=flow;
    }
    printf("%d\n",ans);
    return 0;
}