hdu4292 Food 最大流

　　You, a part-time dining service worker in your college’s dining hall, are now confused with a new problem: serve as many people as possible.
　　The issue comes up as people in your college are more and more difficult to serve with meal: They eat only some certain kinds of food and drink, and with requirement unsatisfied, go away directly.
　　You have prepared F (1 <= F <= 200) kinds of food and D (1 <= D <= 200) kinds of drink. Each kind of food or drink has certain amount, that is, how many people could this food or drink serve. Besides, You know there’re N (1 <= N <= 200) people and you too can tell people’s personal preference for food and drink.
　　Back to your goal: to serve as many people as possible. So you must decide a plan where some people are served while requirements of the rest of them are unmet. You should notice that, when one’s requirement is unmet, he/she would just go away, refusing any service.

题意：有若干人，他们各自有喜欢的食物和饮料，只有当获得一种他们喜欢的食物和一种他们喜欢的饮料，才算获得了服务。饮料和食物都有总数，所以只能服务一部分人。问最多能服务多少人。

分开建边，先超级源点和食物建边，流量是食物的数量。再是食物到人，流量1，再人到饮料，流量1，再饮料到超级汇点，流量是饮料的数量，这样就可以由人节点来控制一条增广路流量一定是1，即满足一个人的需求。

 #include<stdio.h>
 #include<string.h>
 #include<vector>
 #include<queue>
 #include<algorithm>
 using namespace std;
 const int maxm=;
 const int INF=0x3f3f3f3f;

 struct edge{
     int from,to,f;
     edge(int a,int b,int c):from(a),to(b),f(c){}
 };

 struct dinic{
     int s,t,m;
     vector<edge>e;
     vector<int>g[maxm];
     bool vis[maxm];
     int cur[maxm],d[maxm];

     void init(int n){
         for(int i=;i<=n;i++)g[i].clear();
         e.clear();
     }

     void add(int a,int b,int c){
         e.push_back(edge(a,b,c));
         e.push_back(edge(b,a,));
         m=e.size();
         g[a].push_back(m-);
         g[b].push_back(m-);
     }

     bool bfs(){
         memset(vis,,sizeof(vis));
         queue<int>q;
         q.push(s);
         vis[s]=;
         d[s]=;
         while(!q.empty()){
             int u=q.front();
             q.pop();
             for(int i=;i<g[u].size();i++){
                 edge tmp=e[g[u][i]];
                 if(!vis[tmp.to]&&tmp.f>){
                     d[tmp.to]=d[u]+;
                     vis[tmp.to]=;
                     q.push(tmp.to);
                 }
             }
         }
         return vis[t];
     }

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

     int mf(int s,int t){
         this->s=s;
         this->t=t;
         int flow=;
         while(bfs()){
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 };

 char ss[];

 int main(){
     int n,f,d;
     while(scanf("%d%d%d",&n,&f,&d)!=EOF){
         int i,j;
         dinic D;
         D.init(f+*n+d+);
         for(i=f+;i<=f+n;i++){
             D.add(i,i+n,);
         }
         for(i=;i<=f;i++){
             int a;
             scanf("%d",&a);
             D.add(,i,a);
         }
         for(i=;i<=d;i++){
             int a;
             scanf("%d",&a);
             D.add(f+*n+i,f+*n+d+,a);
         }
         for(i=;i<=n;i++){
             scanf("%s",ss+);
             for(j=;j<=f;j++){
                 if(ss[j]=='Y')D.add(j,f+i,);
             }
         }
         for(i=;i<=n;i++){
             scanf("%s",ss+);
             for(j=;j<=d;j++){
                 if(ss[j]=='Y')D.add(f+n+i,f+*n+j,);
             }
         }
         printf("%d\n",D.mf(,f+*n+d+));
     }
     return ;
 }