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 = 1024;
const int INF = 0x3f3f3f3f;

struct node
{
    int to, next, w;
} edge[maxn*11*2+100];
int head[maxn+100], Layer[maxn+100], Hash[maxn+100], 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 = 0;

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

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

    return res;
}

bool CountLayer (int s, int e)
{
    memset (Layer, 0, sizeof(Layer));
    queue <int> Q;
    Q.push (s);
    Layer[s] = 1;
    while (!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for (int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v = edge[i].to;
            if (edge[i].w && !Layer[v])
            {
                Layer[v] = Layer[u] + 1;
                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 = 0;
    for (int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if (!edge[i].w || Layer[v] != Layer[u]+1)
            continue;

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

int Dinic (int s, int e)
{
    int maxflow = 0;
    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, -1, sizeof(head));
        memset (Hash, 0, sizeof(Hash));
        tot = s = 0;
        e = (1<<10) + m + 1;
        for (int i=1; i<=n; i++)
        {
            int y, x = 0;
            for (int j=1; j<=m; j++)
            {
                int y = Scan();
                x = x*2 + y;
            }
            Hash[x] ++;
        }
        
        for (int i=0; i<maxn; i++)
        {
            Add (s, i+1, Hash[i]);
            Add (i+1, s, 0);
            for (int j=1; j<=m; j++)
                if (i & 1<<(j-1))
                {
                    Add (i+1, maxn+j, INF);
                    Add (maxn+j, i+1, 0);
                }
        }
        
        for (int i=1; i<=m; i++)
        {
            scanf ("%d", &num);
            Add (maxn+i, e, num);
            Add (e, maxn+i, 0);
        }
        
        int ans = Dinic (s, e);
        printf ("%s
", ans == n ? "YES" : "NO");
    }
    return 0;
}