Escape(状态压缩+最大流，好题)

Escape

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

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 13201    Accepted Submission(s): 3329

Problem Description

2012 If this is the end of the world how to do? I do not know how. But now scientists have found that some stars, who can live, but some people do not fit to live some of the planet. Now scientists want your help, is to determine what all of people can live in these planets.

 

Input

More set of test data, the beginning of each data is n (1 <= n <= 100000), m (1 <= m <= 10) n indicate there n people on the earth, m representatives m planet, planet and people labels are from 0. Here are n lines, each line represents a suitable living conditions of people, each row has m digits, the ith digits is 1, said that a person is fit to live in the ith-planet, or is 0 for this person is not suitable for living in the ith planet.
The last line has m digits, the ith digit ai indicates the ith planet can contain ai people most..
0 <= ai <= 100000

 

Output

Determine whether all people can live up to these stars
If you can output YES, otherwise output NO.

 

Sample Input

1 1

1

1

 

 

2 2

1 0

1 0

1 1

 

Sample Output

YES

NO

 

Source

2010 ACM-ICPC Multi-University Training Contest（17）——Host by ZSTU

在TLE n次之后，才反应过来，n太大了。。。

百度之后才知道，需要用类似状态压缩的方法

因为m<=10，所以状态数量只有1000左右，把每个会遇到的状态数的数量记录下来，从源点到左边的点拉容量为a[i]的边，左边的点到右边的点拉容量为INF的边，右边的点到汇点拉容量为ci的边

 #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 main(){
     int m,s,t;
     while(~scanf("%d %d",&n,&m)){
         int b,c;
         memset(a,,sizeof(a));
         int Max=;
         isap_init();
         for(int i=;i<=n;i++){
             int tmp=;
             for(int j=;j<=m;j++){
                 scanf("%d",&c);
                 tmp=(tmp<<)|c;
             }
             if(Max<tmp) Max=tmp;
             a[tmp]++;
         }
         s=,t=Max+m+;
         for(int i=;i<=m;i++){
             scanf("%d",&c);
             add(Max+i,t,c);
         }
         for(int i=;i<=Max;i++){
             if(a[i]>){
                 add(s,i,a[i]);
                 int k=m,p=i;
                 while(k&&p){
                     int tmp=p%;
                     p/=;
                     if(tmp>) add(i,Max+k,INF);
                     k--;
                 }
             }
         }
         int tmp=n;
         n=Max+m+;
         int ans=isap(s,t);
         if(ans==tmp) puts("YES");
         else puts("NO");
     }
 }