二分匹配

PS：二分图匹配这一章的内容，我认为最重要的是要弄清楚概念。

一些定义：

二分图：二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如

果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联

的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个

二分图。记为G=(A,B;E)。

二分图匹配：给定一个二分图G，M为G边集的一个子集，如果M满足当中的任意两条边都不依附于同一个顶点，则称M是一个匹配。

需要强调的是：集合A或者B中，本集合中的元素之间是没有关系的。

 最大匹配可用最大流来解，最佳匹配可用最大流最小费用流来解。

二分匹配的意义何在，最大匹配、最佳匹配算法的时间复杂度低。

 

一、最大匹配

最大匹配是找到匹配数最多的匹配。

DFS版匈牙利算法： 代码最简洁。时间复杂度为O(n*m), 空间复杂度为O(n*n)。

不卡时间大家都喜欢用这个。

BFS版匈牙利算法： 代码稍多。时间复杂度为O(n*m), 空间复杂度为O(n*n)

Hopcroft-Karp算法：对匈牙利算法进行了优化，时间复杂度O(m√n)。代码很长，空间复杂度为O(m*m)。

需要说明的是：准备模版的时候还是多准备一些比较好，有些题目是卡时间，有些却是卡空间。所以有些题目用好的算法就是AC不了。

DFS匈牙利算法模版：

//适合边比较多的图
const int N=300;
bool bmap[N][N],bmask[N];
int cx[N],cy[N];
int nx,ny,ans;
int findpath(int u)
{
    int i,j;
    for(i=1;i<=ny;i++)
    {
        if(bmap[u][i]&&!bmask[i])
        {
            bmask[i]=1;
            if(cy[i]==-1||findpath(cy[i]))
            {
                cy[i]=u; cx[u]=i;
                return 1;
            }
        }
    }
    return 0;
}
void maxmatch()
{
    int i ,j;
    ans=0;
    for(i=1;i<=nx;i++) cx[i]=-1;
    for(i=1;i<=ny;i++) cy[i]=-1;
    for(i=1;i<=nx;i++)
    {
        if(cx[i]==-1)
        {
            for(j=1;j<=ny;j++)
                bmask[j]=0;
            ans+=findpath(i);
        }
    }
}
void init()
{
    memset(bmap,0,sizeof(bmap));
}

(2)匈牙利算法BFS    时间复杂度O(n*m)

const int N=1010;
int bmap[N][N],cx[N],cy[N],bmask[N],que[N],pre[N];
int nx,ny,ans;
void maxmatch()
{
    ans=0;
    int qs,qe;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));
    memset(bmask,-1,sizeof(bmask));
    for(int i=1;i<=nx;i++)
    {
        if(cx[i] == -1)
        {
            qs=qe=0;
            que[qe++]=i;
            pre[i]=-1;
            bool flag=0;
            while(qs<qe&&!flag)
            {
                int u=que[qs];
                for(int v=1;v<=ny&&!flag;v++)
                {
                    if(bmap[u][v]&&bmask[v]!=i)
                    {
                        bmask[v]=i;que[qe++]=cy[v];
                        if(cy[v]>=0) pre[cy[v]]=u;
                        else
                        {
                            flag=1;
                            int d=u,e=v;
                            while(d!=-1)
                            {
                                int t=cx[d];
                                cx[d]=e; cy[e]=d;
                                d=pre[d]; e=t;
                            }
                        }
                    }
                }
                qs++;
            }
            if(cx[i]!=-1) ans++;
        }
    }
}
void init()
{
    memset(bmap,0,sizeof(bmap));
}

Hopcroft-Karp算法模版：有时候顶点较多，所以直接用邻接表，没用邻接矩阵。

const int N=10150,INF=0x3f3f3f3f;
int cx[N],cy[N],dx[N],dy[N];
bool bmask[N];
int nx,ny,dis,ans;
vector<int> bmap[N];
bool searchpath()
{
    queue<int> q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=1;i<=nx;i++)
    {
        if(cx[i]==-1){ q.push(i); dx[i]=0; }
        while(!q.empty())
        {
            int u=q.front(); q.pop();
            if(dx[u]>dis) break;
            for(int i=0;i<bmap[u].size();i++)
            {
                int v=bmap[u][i];
                if(dy[v]==-1)
                {
                    dy[v]= dx[u] + 1;
                    if(cy[v]==-1) dis=dy[v];
                    else
                    {
                        dx[cy[v]]= dy[v]+1;
                        q.push(cy[v]);
                    }
                }
            }
        }
    }
    return dis!=INF;
}
int findpath(int u)
{
    for(int i=0;i<bmap[u].size();i++)
    {
        int v=bmap[u][i];
        if(!bmask[v]&&dy[v]==dx[u]+1)
        {
            bmask[v]=1;
            if(cy[v]!=-1&&dy[v]==dis) continue;
            if(cy[v]==-1||findpath(cy[v]))
            {
                cy[v]=u; cx[u]=v;
                return 1;
            }
        }
    }
    return 0;
}
void maxmatch()
{
    ans=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));
    while(searchpath())
    {
        memset(bmask,0,sizeof(bmask));
        for(int i=1;i<=nx;i++)
            if(cx[i]==-1) ans+=findpath(i);
    }
}
void init()
{
    for(int i=0;i<N;i++) bmap[i].clear();
}

题目类型：

1、判断是否构成二分图  http://www.cnblogs.com/Potato-lover/p/3985869.html

2、二分 + 最大匹配 http://www.cnblogs.com/Potato-lover/p/3989675.html

3、奇偶建图  http://www.cnblogs.com/Potato-lover/p/3991533.html

 

二、最佳匹配

与最大匹配不同的是，最佳匹配是在每一个匹配之间加一个权值。求的就是权值之和最大的匹配。

Kuhn Munkras 算法：时间复杂度为O(m*m*n)。

模版：

const int N=110, INF=0x3f3f3f3f;
int Map[N][N],mat1[N],mat2[N];
int KM(int m,int n)
{
    int s[N],t[N],a[N],b[N];
    int i,j,k,p,q,ans=0;
    for(i=0;i<m;i++)
    {
        a[i]=-INF;
        for(j=0;j<n;j++)
            a[i]=Map[i][j]>a[i]?Map[i][j]:a[i];
        if(a[i]==-INF) return -1;//cannot match
    }
    memset(b,0,sizeof(b));
    memset(mat1,-1,sizeof(mat1));
    memset(mat2,-1,sizeof(mat2));
    for(i=0;i<m;i++)
    {
        memset(t,-1,sizeof(t));
        p=q=0;
        for(s[0]=i;p<=q&&mat1[i]<0;p++)
        {
            for(k=s[p],j=0;j<n&&mat1[i]<0;j++)
            {
                if(a[k]+b[j]==Map[k][j]&&t[j]<0)
                {
                    s[++q]=mat2[j]; t[j]=k;
                    if(s[q]<0)
                        for(p=j;p>=0;j=p)
                        {
                            mat2[j]=k=t[j];p=mat1[k]; mat1[k]=j;
                        }
                }
            }
        }
        if(mat1[i]<0)
        {
            i--,p=INF;
            for(k=0;k<=q;k++)
            {
                for(j=0;j<n;j++)
                    if(t[j]<0&&a[s[k]]+b[j]-Map[s[k]][j]<p)
                        p=a[s[k]]+b[j]-Map[s[k]][j];
            }
            for(j=0;j<n;j++) b[j]+=t[j]<0?0:p;
            for(k=0;k<=q;k++) a[s[k]]-=p;
        }
}
    for(i=0;i<m;i++) ans+=Map[i][mat1[i]];
    return ans;
}
void init()
{
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
             Map[i][j]=-INF;
}

题目：

 http://www.cnblogs.com/Potato-lover/category/615224.html

 

三、多重匹配

最大匹配值允许A集合与B集合是一一对应。多重匹配可以使得B的元素与多个A的元素匹配。

算法模版：

const int N=1010;
int cy[N][N],vcy[N];
bool bmask[N],bmap[N][N];
int nx,ny,limit,L,R;
bool findpath(int u)
{
    int i,j;
    for(i=1;i<=ny;i++)
    {
        if(bmap[u][i]&&!bmask[i])
        {
            bmask[i]=1;
            if(vcy[i]<limit)
            {
                cy[i][++vcy[i]] =u;
                return 1;
            }
            for(j=1;j<=vcy[i];j++)
            {
                if(findpath(cy[i][j]))
                {
                    cy[i][j]=u;
                    return 1;
                }
            }
        }
    }
    return 0;
}
bool mulmatch()
{
    memset(vcy,0,sizeof(vcy));
    for(int i=1;i<=nx;i++)
    {
        memset(bmask,0,sizeof(bmask));
        if(!findpath(i)) return 0;
    }
    return 1;
}
void init()
{
    memset(bmap,0,sizeof(bmap));
}
int main()
{
    L=0,R=nx;
    while(L<=R)
    {
        limit=(L+R)/2;
        if(mulmatch()) R=limit-1;
        else L=limit+1;
    }
    printf("%d
",L);
}

 题目：

2289  Jamie's Contact Groups

 

四、二分图模型的应用

1、二分图最小点覆盖  http://www.cnblogs.com/Potato-lover/p/3980411.html

2、有向无环图的最小路径覆盖  http://www.cnblogs.com/Potato-lover/p/3989625.html

3、二分图的最大独立集  http://www.cnblogs.com/Potato-lover/p/3980491.html