二分图多重匹配

 

在二分图的最大匹配中，每个点（不管是X集合还是Y集合）最多只能与一条匹配边相关联，

然而，经常有这种问题，即二分图的一个点可以和多条匹配边相关联，但有上限，即cap[i]表示点i最多能和cap[i]条匹配边相关联。

 

hdu 3605

题意：2012来了，n个人可以逃往m个星球中的k个，每个星球都有上限，问所有的人能不能都都逃亡成功；

 

 

#include <stdio.h>
#include <string.h>
const int N = 100000 + 10;
const int M = 10 + 10;
int n,m;
int Map[N][M];
int cap[M];//星球i的容量上限
int cy[M][N];
int num[M];//num[i]记录星球i已经匹配了n个人
bool vis[M];


bool dfs(int u)
{
    for(int i=0; i<m; ++i)
    {
        if(!vis[i] && Map[u][i])
        {
            vis[i] = true;
            if(num[i] < cap[i])
            {
                cy[i][num[i]++] = u;
                return true;
            }
            else
            {
                for(int j=0; j<cap[i]; ++j)//寻找增广路，可以从u出发，经过n条匹配边中的一条找到增广路就行
                {
                    if(dfs(cy[i][j]))
                    {
                        cy[i][j] = u;
                        return true;
                    }
                }
            }
        }
    }
    return false;
}
bool MulMatch()
{
    memset(num, 0, sizeof(num));
    for(int i=0; i<n; ++i)
    {
        memset(vis, 0, sizeof(vis));
        if(!dfs(i))
            return false;
    }
    return true;
}
int main()
{    
    int i,j;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=0; i<n; ++i)
            for(j=0; j<m; ++j)
                scanf("%d",&Map[i][j]);
        
        for(i=0; i<m; ++i)
            scanf("%d",&cap[i]);
        printf("%s\n",MulMatch()?"YES":"NO");
    }
    
    return 0;
}

 hdu 1669

题意：给定n个人，m个组，没个人适合m个组中的k个，由给定的数据说明，
要求分组后，人最多的那个组是所有可能情况中最小的

组的人数的情况可能是0--->n  ，但是一个一个枚举太耗时了，所以用二分枚举最大组的容量上限，剩下的代码就都和上面那题一样

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int nMax = 1000 + 10;
const int mMax = 555 + 10;
int num[mMax];
bool vis[mMax];
int cy[mMax][nMax];
vector<int> G[nMax];
int n,m,limit;

void init()
{
    for(int i=0; i<n; ++i)
        G[i].clear();
}
bool dfs(int u)
{
    for(int i=0; i<G[u].size(); ++i)
    {
        int v = G[u][i];
        if(!vis[v])
        {
            vis[v] = true;
            if(num[v] < limit)
            {
                cy[v][num[v]++] = u;
                return true;
            }
            for(int j=0; j<limit; ++j)
                if(dfs(cy[v][j]))
                {
                    cy[v][j] = u;
                    return true;
                }
            
        }
    }
    return false;
}
bool MulMatch()
{
    memset(num, 0, sizeof(num));
    memset(cy, 0, sizeof(cy));
    for(int i=0; i<n; ++i)
    {
        memset(vis, 0, sizeof(vis));
        if(!dfs(i))
            return false;
    }
    return true;
}
int main()
{
    char str[20];
    int i,j;
    while(true)
    {
        scanf("%d%d",&n,&m);
        if(n==0 && m==0)
            break;
        init();
        for(i=0; i<n; ++i)
        {
            scanf("%s",str);
            while( getchar()==' ')
            {
                scanf("%d",&j);
                G[i].push_back(j);
            }
        }
        int low = 0, high = n,ans = 0;
        while(low <= high)
        {
            limit = (low + high) >> 1;//二分枚举最大组的容量上限为limit
            if(MulMatch())
            {
                ans = limit;
                high = limit - 1;
            }
            else
                low = limit + 1;
        }
        printf("%d\n",ans);
    }
    return 0;
}