Hdu 3605 Escape (最大流 + 缩点)

题目链接：

　　Hdu 3605  Escape

题目描述：

　　有n个人要迁移到m个星球，每个星球有最大容量，每个人有喜欢的星球，问是否所有的人都能迁移成功？

解题思路：

　　正常情况下建图，不会爆内存，但是TLE还是稳稳的。以前只遇到过网络流拆点建图，这个正好是缩点建图。吼吼吼~~~，建图的方式还是值得学习的。

　　因为星球数目最多十个，那么无论有多少个人，其不同选择也就2^10种咯。把不同的选择作为节点，节点就从10^5减少到了2^10，整整缩小了一个数量级呢。建立源点和汇点，源点和选择链接，边权为这种选择的出现次数；每种选择再与可到达的星球相连，边权为INF；星球与汇点相连，边权为星球的最大容量。然后跑最大流，判断是否满流即可。

 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #pragma comment (linker, "/STACK:1024000000,1024000000")
 using namespace std;

 const int maxn = ;
 const int INF = 0x3f3f3f3f;

 struct node
 {
     int to, next, w;
 } edge[maxn**+];
 int head[maxn+], Layer[maxn+], Hash[maxn+], tot;

 void Add (int from, int to, int w)
 {
     edge[tot].to = to;
     edge[tot].w = w;
     edge[tot].next = head[from];
     head[from] = tot ++;
 }

 int Scan ()
 {
     int res;
     char ch;
     res = ;

     while ((ch=getchar())<'' || ch>'');

     if (ch>='' && ch<='')
         res = ch - '';

     return res;
 }

 bool CountLayer (int s, int e)
 {
     memset (Layer, , sizeof(Layer));
     queue <int> Q;
     Q.push (s);
     Layer[s] = ;
     while (!Q.empty())
     {
         int u = Q.front();
         Q.pop();
         for (int i=head[u]; i!=-; i=edge[i].next)
         {
             int v = edge[i].to;
             if (edge[i].w && !Layer[v])
             {
                 Layer[v] = Layer[u] + ;
                 Q.push (v);
                 if (v == e)
                     return true;
             }
         }
     }
     return false;
 }

 int Dfs (int u, int e, int maxflow)
 {
     if (u == e)
         return maxflow;

     int uflow = ;
     for (int i=head[u]; i!=-; i=edge[i].next)
     {
         int v = edge[i].to;
         if (!edge[i].w || Layer[v] != Layer[u]+)
             continue;

         int flow = min (maxflow-uflow, edge[i].w);
         flow = Dfs (v, e, flow);
         uflow += flow;
         edge[i].w -= flow;
         edge[i^].w += flow;
         if (maxflow == uflow)
             break;
     }
     if (uflow == )
         Layer[u] = ;
     return uflow;
 }

 int Dinic (int s, int e)
 {
     int maxflow = ;
     while (CountLayer (s, e))
         maxflow += Dfs (s, e, INF);
     return maxflow;
 }

 int main ()
 {
     int n, m, s, e, num;
     while (scanf ("%d %d ", &n, &m) != EOF)
     {
         memset (head, -, sizeof(head));
         memset (Hash, , sizeof(Hash));
         tot = s = ;
         e = (<<) + m + ;
         for (int i=; i<=n; i++)
         {
             int y, x = ;
             for (int j=; j<=m; j++)
             {
                 int y = Scan();
                 x = x* + y;
             }
             Hash[x] ++;
         }

         for (int i=; i<maxn; i++)
         {
             Add (s, i+, Hash[i]);
             Add (i+, s, );
             for (int j=; j<=m; j++)
                 if (i & <<(j-))
                 {
                     Add (i+, maxn+j, INF);
                     Add (maxn+j, i+, );
                 }
         }

         for (int i=; i<=m; i++)
         {
             scanf ("%d", &num);
             Add (maxn+i, e, num);
             Add (e, maxn+i, );
         }

         int ans = Dinic (s, e);
         printf ("%s\n", ans == n ? "YES" : "NO");
     }
     return ;
 }