hdu3605-二分图多重匹配

题意：有N个人，M个星球，每个人有自己想去的星球，每个星球可容纳a[i]个人，问最后能否让每个人都去到自己想去的星球。
题意很好理解，也很容易看出来是多重匹配，就是数据量比较大，直接模板会T。
然后就要用状态压缩来做。匈牙利算法好写不直观，最大流直观但不好写。
最大流的压缩方法是：
按照题意，应该是 s（源点）–人（100000个）–星球（10个）–t（汇点）
对于一个人A，A对每个星球可以选择去还是不去两种，最多一共有10个星球，
那么就是2的10次方种选择。也就是1024种，远小于10万个点，所以就把重复的合并起来。那么图就变成了
s（源点）–相同选择的人（1024个）–星球（10个）–t（汇点）
这样跑起来就不会超时了

匈牙利算法：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
const int maxn = 100050;
int n,m;

int mapn[maxn][15], match[maxn][15];
bool vis[15];
int star[maxn], cnt[maxn];


bool dfs(int u)
{
    for(int i=0; i<m; i++)
    {
        if(!mapn[u][i] || vis[i])
            continue;
        vis[i] = true;
        if(cnt[i] < star[i])
        {
            match[i][cnt[i]++] = u;
            return true;
        }
        else
        {
            for(int j=0; j<star[i]; j++)
            {
                if(dfs(match[i][j]))
                {
                    match[i][j] = u;
                    return true;
                }
            }
        }
    }
    return false;
}
int putans(int n)
{
    for(int i=0; i<n; i++)
    {
        memset(vis, false, sizeof(vis));
        if(!dfs(i))
            return false;
    }
    return true;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(cnt, 0, sizeof(cnt));
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                scanf("%d",&mapn[i][j]);

        for(int i=0; i<m; i++)
            scanf("%d",&star[i]);
        if(putans(n))
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

Dinic算法

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int N = 110000;// 点数
const int inf = 0x3f3f3f;

struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f) {}
};


int n,m,s,t;//结点数，边数（包括反向弧），源点编号，汇点编号
vector<Edge>edges;//边表，dges[e]和dges[e^1]互为反向弧
vector<int>G[N];//邻接表，G[i][j]表示结点i的第j条边在e数组中的编号
bool vis[N]; //BFS的使用
int d[N]; //从起点到i的距离
int cur[N]; //当前弧下标

void init()
{
    edges.clear();
    for(int i=0; i<N; i++)
    {
        G[i].clear();
        d[i] = 0;
    }
}
void addedge(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int  m=edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

bool bfs()
{
    memset(vis,0,sizeof(vis));
    queue<int>Q;
    Q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!Q.empty())
    {
        int x=Q.front();
        Q.pop();
        for(int i=0; i<G[x].size(); i++)
        {
            Edge&e=edges[G[x][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[x]+1;
                Q.push(e.to);
            }
        }
    }
    return vis[t];
}

int dfs(int x,int a)
{
    if(x==t||a==0)
        return a;
    int flow=0,f;
    for(int i=cur[x]; i<G[x].size(); i++)
    {
        Edge&e=edges[G[x][i]];
        if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
        {
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(!a)
                break;
        }
    }
    return flow;
}

int Maxflow(int s,int t)
{
    int flow=0;
    while(bfs())//不停地用bfs构造分层网络，然后用dfs沿着阻塞流增广
    {
        memset(cur,0,sizeof(cur));
        flow += dfs(s,inf);
    }
    return flow;
}

int main()
{
    while(scanf("%d%d",&n,&m) !=EOF)
    {
        int result = 0;
        int status[1100];
        init();
        memset(status, 0, sizeof(status));
        s = 0, t = n+m+1;
        for(int i=1; i<=n; i++)
        {
            int tmp=0;
            for(int j=1; j<=m; j++)
            {
                tmp <<= 1;
                int is;
                scanf("%d",&is);
                tmp |= is;
            }
            status[tmp]++;
        }
        for(int i=1; i<=(1<<10); i++)
        {
            if(status[i])
                addedge(s,i,status[i]);
            for(int j=1; j<=m; j++)
                if(i & (1<<(j-1)))
                    addedge(i,n+j,status[i]);
        }
        for(int i=1; i<=m; i++)
        {
            int star;
            scanf("%d",&star);
            result += star;
            addedge(n+i, t, star);
        }

        if(Maxflow(s, t) == n)
            printf("YES\n");
        else
            printf("NO\n");
    }
}