【最大流】Escape

https://www.bnuoj.com/v3/contest_show.php?cid=9149#problem/F

【题意】

给定n个人和m个星球，每个人可以匹配某些星球，每个星球有一定的容量限制，问能不能找出一种人和星球匹配的可行方案。

【思路】

裸的最大流。但人最多有1e5个，直接跑最大流会超时。但星球只有10个，所以一定有某些人对星球的选择是一模一样的，那么我们就可以状压缩点，缩到最多2^10=1024个。

【Accepted】

 #include<iostream>
 #include<cstdio>
 #include<string>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 using namespace std;
 const int maxn=1e5+;
 const int maxm=1e6;
 const int inf=0x3f3f3f3f;

 struct Edge
 {
     int to,next,cap,flow;
 }edge[maxm];
 int tol;
 int head[maxn];
 int gap[maxn],dep[maxn],pre[maxn],cur[maxn];
 int num[];
 void init()
 {
     tol=;
     memset(head,-,sizeof(head));
     memset(num,,sizeof(num));
 }

 void addedge(int u,int v,int w,int rw=)
 {
     edge[tol].to=v;
     edge[tol].cap=w;
     edge[tol].next=head[u];
     edge[tol].flow=;
     head[u]=tol++;
     edge[tol].to=u;
     edge[tol].cap=rw;
     edge[tol].next=head[v];
     edge[tol].flow=;
     head[v]=tol++;
 }

 int sap(int start,int end,int N)
 {
     memset(gap,,sizeof(gap));
     memset(dep,,sizeof(dep));
     memcpy(cur,head,sizeof(head));
     int u=start;
     pre[u]=-;
     gap[]=N;
     int ans=;
     while(dep[start]<N)
     {
         if(u==end)
         {
             int Min=inf;
             for(int i=pre[u];i!=-;i=pre[edge[i^].to])
             {
                 if(Min>edge[i].cap-edge[i].flow)
                 {
                     Min=edge[i].cap-edge[i].flow;
                 }
             }
             for(int i=pre[u];i!=-;i=pre[edge[i^].to])
             {
                 edge[i].flow+=Min;
                 edge[i^].flow-=Min;
             }
             u=start;
             ans+=Min;
             continue;
         }
         bool flag=false;
         int v;
         for(int i=cur[u];i!=-;i=edge[i].next)
         {
             v=edge[i].to;
             if(edge[i].cap-edge[i].flow&&dep[v]+==dep[u])
             {
                 flag=true;
                 cur[u]=pre[v]=i;
                 break;
             }
         }
         if(flag)
         {
             u=v;
             continue;
         }
         int Min=N;
         for(int i=head[u];i!=-;i=edge[i].next)
         {
             if(edge[i].cap-edge[i].flow&&dep[edge[i].to]<Min)
             {
                 Min=dep[edge[i].to];
                 cur[u]=i;
             }
         }
         gap[dep[u]]--;
         if(!gap[dep[u]])
         {
             return ans;
         }
         dep[u]=Min+;
         gap[dep[u]]++;
         if(u!=start)
         {
             u=edge[pre[u]^].to;
         }
     }
     return ans;
 }
 int a[maxn];
 int n,m;
 int bit[];

 int main()
 {
     bit[]=;
     for(int i=;i<=;i++)
     {
         bit[i]=bit[i-]*;
     }
     while(~scanf("%d%d",&n,&m))
     {
         init();
         int x;
         for(int i=;i<=n;i++)
         {
             int temp=;
             for(int k=;k<m;k++)
             {
                 scanf("%d",&x);
                 if(x==)
                 {
                     temp+=bit[k];
                 }
             }
             num[temp]++;
         }
         int people=-inf;
         for(int i=;i>=;i--)
         {
             if(num[i])
             {
                 people=i;
                 break;
             }
         }
         int planet=people+;
         for(int i=;i<=;i++)
         {
             if(num[i]==)
             {
                 continue;
             }
             addedge(,i,num[i]);
             for(int k=;k<m;k++)
             {
                 if(i&(<<k))
                 {
                     addedge(i,planet+k,num[i]);
                 }
             }
         }
         for(int i=planet;i<planet+m;i++)
         {
             scanf("%d",&a[i]);
             addedge(i,planet+m,a[i]);
         }

         if(num[])
         {
             puts("NO");
             continue;
         }
         int res=sap(,planet+m,planet+m+);
         if(res==n)
         {
             puts("YES");
         }
         else
         {
             puts("NO");
         }
         getchar();
     }
     return ;
 }