HDU 4292 Food（最小割，人数拆点）

Food

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

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 

题意：有N个人，F种食品，D种饮料，接下来一行表示F种食品的数量，再下一行D种饮料的数量，接下来的N行F列表示N个人对F种食品的可以接受情况：Y为可接受，N为不可接受。再接下来N行D列表示N个人对D种饮料可以接受的情况，Y与N和上面的代表相同。问最多能满足多少人，一人任意一种可接受的一个食品和一杯饮料。

解题：源点vs与每种食品建边，边权为当前食品的数量；每种饮料与汇点相连，边权为饮料的数量；N 个人点拆成一条有向边（两点先命名为左点与右点），边权为1 。每个人： 左点与能接受的食品种类点相连，边权为1；右点与能接受的饮料品种点相连，边权为1。最后跑一次最大流，最大流值就是最多能满足的人数。

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
#define captype int

const int MAXN = 1010;   //点的总数
const int MAXM = 400010;    //边的总数
const int INF = 1<<30;
struct EDG{
    int to,next;
    captype cap;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每种距离(或可认为是高度)点的个数
int dis[MAXN];  //每个点到终点eNode 的最短距离
int cur[MAXN];  //cur[u] 表示从u点出发可流经 cur[u] 号边
int pre[MAXN];

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void addEdg(int u,int v,captype c,captype rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c;  head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; head[v]=eid++;
}
captype maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
    memset(gap,0,sizeof(gap));
    memset(dis,0,sizeof(dis));
    memcpy(cur,head,sizeof(head));
    pre[sNode] = -1;
    gap[0]=n;
    captype ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判断从sNode点有没有流向下一个相邻的点
        if(u==eNode){   //找到一条可增流的路
            captype Min=INF ;
            int inser;
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to])    //从这条可增流的路找到最多可增的流量Min
            if(Min>edg[i].cap){
                Min=edg[i].cap;
                inser=i;
            }
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
                edg[i].cap-=Min;
                edg[i^1].cap+=Min;  //可回流的边的流量
            }
            ans+=Min;
            u=edg[inser^1].to;
            continue;
        }
        bool flag = false;  //判断能否从u点出发可往相邻点流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag){
            u=v;
            continue;
        }
        //如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
                                        //因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
        dis[u]=Mind+1;//如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[pre[u]^1].to;  //退一条边
    }
    return ans;
}

int main()
{
    int N,D,F,vs , vt ;
    char str[500];
    while(scanf("%d%d%d",&N,&F,&D)>0){
        init();
        int num;
        vs=0; vt=D+F+N*2+1;
        for(int i=1; i<=F; i++){
            scanf("%d",&num);
            addEdg( vs , i , num);
        }
        for(int i=1; i<=D; i++){
            scanf("%d",&num);
            addEdg( i+F+N*2 , vt , num);
        }
        for(int i=1; i<=N; i++){
            scanf("%s",str);
            addEdg(i+F , i+F+N , 1);
            for(int j=1; j<=F; j++)
                if(str[j-1]=='Y')
                  addEdg(j , i+F , 1);
        }
        for(int i=1; i<=N; i++){
            scanf("%s",str);
            for(int j=1; j<=D; j++)
                if(str[j-1]=='Y')
                  addEdg( i+F+N , j+F+N*2 , 1);
        }
        int ans = maxFlow_sap( vs , vt , vt+1);
        printf("%d\n",ans);
    }
}