Food（最大流）

Food

http://acm.hdu.edu.cn/showproblem.php?pid=4292

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 8111    Accepted Submission(s): 2686

Problem Description

　　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.

 

Input

　　There are several test cases.
　　For each test case, the first line contains three numbers: N,F,D, denoting the number of people, food, and drink.
　　The second line contains F integers, the ith number of which denotes amount of representative food.
　　The third line contains D integers, the ith number of which denotes amount of representative drink.
　　Following is N line, each consisting of a string of length F. e jth character in the ith one of these lines denotes whether people i would accept food j. “Y” for yes and “N” for no.
　　Following is N line, each consisting of a string of length D. e jth character in the ith one of these lines denotes whether people i would accept drink j. “Y” for yes and “N” for no.
　　Please process until EOF (End Of File).

 

Output

　　For each test case, please print a single line with one integer, the maximum number of people to be satisfied.

 

Sample Input

4 3 3
1 1 1
1 1 1
YYN
NYY
YNY
YNY
YNY
YYN
YYN
NNY

 

Sample Output

3

 

Source

2012 ACM/ICPC Asia Regional Chengdu Online

感觉和这题思路差不多：https://www.cnblogs.com/Fighting-sh/p/9818674.html

 #include<iostream>
 #include<cstring>
 #include<string>
 #include<cmath>
 #include<cstdio>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #define maxn 200005
 #define MAXN 200005
 #define mem(a,b) memset(a,b,sizeof(a))
 const int N=;
 const int M=;
 const int INF=0x3f3f3f3f;
 using namespace std;
 int n;
 struct Edge{
     int v,next;
     int cap,flow;
 }edge[MAXN*];//注意这里要开的够大。。不然WA在这里真的想骂人。。问题是还不报RE。。
 int cur[MAXN],pre[MAXN],gap[MAXN],path[MAXN],dep[MAXN];
 int cnt=;//实际存储总边数
 void isap_init()
 {
     cnt=;
     memset(pre,-,sizeof(pre));
 }
 void isap_add(int u,int v,int w)//加边
 {
     edge[cnt].v=v;
     edge[cnt].cap=w;
     edge[cnt].flow=;
     edge[cnt].next=pre[u];
     pre[u]=cnt++;
 }
 void add(int u,int v,int w){
     isap_add(u,v,w);
     isap_add(v,u,);
 }
 bool bfs(int s,int t)//其实这个bfs可以融合到下面的迭代里，但是好像是时间要长
 {
     memset(dep,-,sizeof(dep));
     memset(gap,,sizeof(gap));
     gap[]=;
     dep[t]=;
     queue<int>q;
     while(!q.empty())
     q.pop();
     q.push(t);//从汇点开始反向建层次图
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         for(int i=pre[u];i!=-;i=edge[i].next)
         {
             int v=edge[i].v;
             if(dep[v]==-&&edge[i^].cap>edge[i^].flow)//注意是从汇点反向bfs，但应该判断正向弧的余量
             {
                 dep[v]=dep[u]+;
                 gap[dep[v]]++;
                 q.push(v);
                 //if(v==sp)//感觉这两句优化加了一般没错，但是有的题可能会错，所以还是注释出来，到时候视情况而定
                 //break;
             }
         }
     }
     return dep[s]!=-;
 }
 int isap(int s,int t)
 {
     if(!bfs(s,t))
     return ;
     memcpy(cur,pre,sizeof(pre));
     //for(int i=1;i<=n;i++)
     //cout<<"cur "<<cur[i]<<endl;
     int u=s;
     path[u]=-;
     int ans=;
     while(dep[s]<n)//迭代寻找增广路,n为节点数
     {
         if(u==t)
         {
             int f=INF;
             for(int i=path[u];i!=-;i=path[edge[i^].v])//修改找到的增广路
                 f=min(f,edge[i].cap-edge[i].flow);
             for(int i=path[u];i!=-;i=path[edge[i^].v])
             {
                 edge[i].flow+=f;
                 edge[i^].flow-=f;
             }
             ans+=f;
             u=s;
             continue;
         }
         bool flag=false;
         int v;
         for(int i=cur[u];i!=-;i=edge[i].next)
         {
             v=edge[i].v;
             if(dep[v]+==dep[u]&&edge[i].cap-edge[i].flow)
             {
                 cur[u]=path[v]=i;//当前弧优化
                 flag=true;
                 break;
             }
         }
         if(flag)
         {
             u=v;
             continue;
         }
         int x=n;
         if(!(--gap[dep[u]]))return ans;//gap优化
         for(int i=pre[u];i!=-;i=edge[i].next)
         {
             if(edge[i].cap-edge[i].flow&&dep[edge[i].v]<x)
             {
                 x=dep[edge[i].v];
                 cur[u]=i;//常数优化
             }
         }
         dep[u]=x+;
         gap[dep[u]]++;
         if(u!=s)//当前点没有增广路则后退一个点
         u=edge[path[u]^].v;
      }
      return ans;
 }

 int a[maxn];
 int F[maxn],D[maxn];
 string mp[];

 int main(){
     std::ios::sync_with_stdio(false);
     int m,s,t;
     int f,d;
     while(cin>>n>>f>>d){
         for(int i=;i<=f;i++) cin>>F[i];
         for(int i=;i<=d;i++) cin>>D[i];
         for(int i=;i<=*n;i++) cin>>mp[i];
         isap_init();
         s=,t=n+n+f+d+;
         for(int i=;i<=n;i++){
             for(int j=;j<f;j++){
                 if(mp[i][j]=='Y'){
                     add(j+,f+i,);
                 }
             }
         }
         for(int i=;i<=n;i++){
             for(int j=;j<d;j++){
                 if(mp[i+n][j]=='Y'){
                     add(f+n+i,f+n+n+j+,);
                 }
             }
         }
         for(int i=;i<=n;i++) add(f+i,f+n+i,);
         for(int i=;i<=f;i++) add(s,i,F[i]);
         for(int i=;i<=d;i++) add(f+n+n+i,t,D[i]);
         n=n+n+f+d+;
         cout<<isap(s,t)<<endl;
     }
 }