[hdu 3605]Escape

这题的做法非常直观，却又非常不直观

先容许我吐一下槽吧~作者你的英语是读到火星上去了喵？

题目大体是说人类要移民，然后有 n 个人， m 个星球

每个人都有 m 个 0 、 1 数码表示他能否移民到该星球，每个星球有个最大人口容量

问是否有方案移民该 n 个人

乍一看很水，但是看看 n 的数据范围真是太感动人心了，有种这尼玛更本不是网络流的感脚——

但是 m 的范围只有 10 ！直觉告诉我似乎可以动手脚的样子喵？

状压！因为不需要输出方案，所以两个可移民方案相同的人完全可以视为同一人

然后点就被压到了 1024 以内，妥妥地过掉了~

我才不会说我连边连错害我调了半小时呢喵

#include <cstdio>
#include <cstring>
#define min(x, y) ((x)<(y) ? (x):(y))
const int inf=0x7FFFFFFF;
const int sizeOfPoint=10050;
const int sizeOfEdge=500050;

int n, m, t;
int S, T;
int f[sizeOfPoint], a[sizeOfPoint];

struct edge {int point, flow; edge * next, * pair;};
edge memory[sizeOfEdge], * port=memory;
edge * e[sizeOfPoint];
inline void clear() {port=memory; memset(e, 0, sizeof e); t=0; memset(f, 0, sizeof f);}
inline edge * newedge(int point, int flow, edge * next) {edge * ret=port++; ret->point=point; ret->flow=flow; ret->next=next; ret->pair=NULL; return ret;}
inline void build(int u, int v, int f) {e[u]=newedge(v, f, e[u]); e[v]=newedge(u, 0, e[v]); e[u]->pair=e[v]; e[v]->pair=e[u];}
int h[sizeOfPoint];
inline bool bfs();
inline int aug();
inline int dinic();

int main()
{
    int x, state;

    while (scanf("%d %d", &n, &m)!=EOF)
    {
        clear();
        for (int i=1;i<=n;i++)
        {
            state=0;
            for (int j=0;j<m;j++)
            {
                scanf("%d", &x);
                state|=x<<j;
            }
            if (!f[state]++) a[++t]=state;
        }
        S=0; T=t+m+1;
        for (int i=1;i<=t;i++)
        {
            build(S, i, f[a[i]]);
            for (int j=0;j<m;j++) if ((a[i]>>j)&1)
                build(i, t+j+1, f[a[i]]);
        }    
        for (int i=1;i<=m;i++)
        {
            scanf("%d", &x);
            build(t+i, T, x);
        }

        if (dinic()==n) printf("YES
");
        else printf("NO
");
    }

    return 0;
}
inline bool bfs()
{
    static int q[sizeOfPoint];
    int l=0, r=0;
    memset(h, 0xFF, sizeof h); h[T]=0;
    for (q[r++]=T;l<r;l++)
    {
        int u=q[l];
        for (edge * i=e[u];i;i=i->next) if (i->pair->flow && h[i->point]==-1)
            h[q[r++]=i->point]=h[u]+1;
    }
    return h[S]>=0;
}
inline int aug()
{
    static edge * t[sizeOfPoint], * path[sizeOfPoint];
    static int aug[sizeOfPoint];
    int flow=0;

    memcpy(t, e, sizeof e);
    memset(path, 0, sizeof path);
    memset(aug, 0, sizeof aug);
    aug[S]=inf;
    for (int u=S; ; )
    {
        if (u==T)
        {
            flow+=aug[T];
            for (edge * i=path[T];i;i=path[i->point])
            {
                i->pair->flow-=aug[T], i->flow+=aug[T];
                aug[i->point]-=aug[T];
                if (!aug[i->point]) h[i->point]=-1;
            }
            u=S;
        }

        edge *& i=t[u];
        for ( ;i && (!i->flow || h[u]!=h[i->point]+1);i=i->next);
        if (i)
        {
            path[i->point]=i->pair; aug[i->point]=min(aug[u], i->flow);
            u=i->point; i=i->next;
        }
        else
        {
            if (u==S) break;
            u=path[u]->point;
        }
    }

    return flow;
}
inline int dinic()
{
    int ret=0, flow;
    while (bfs())
        while (flow=aug())
            ret+=flow;
    return ret;
}