二分图最大匹配总结

转载链接：

http://blog.csdn.net/hackbuteer1/article/details/7398008

http://www.cnblogs.com/kuangbin/archive/2012/08/26/2657446.html

两位大神，原谅小弟吧，你们总结的太好了，不转载实在对不起你们！

 

二分图指的是这样一种图，其所有顶点可以分成两个集合X和Y，其中X或Y中任意两个在同一集合中的点都不相连，所有的边关联在两个顶点中，恰好一个属于集合Ｘ，另一个属于集合Ｙ。给定一个二分图G，M为G边集的一个子集，如果M满足当中的任意两条边都不依附于同一个顶点，则称M是一个匹配。图中包含边数最多的匹配称为图的最大匹配。

     二分图的最大匹配有两种求法，第一种是最大流；第二种就是我现在要讲的匈牙利算法。这个算法说白了就是最大流的算法，但是它跟据二分图匹配这个问题的特点，把最大流算法做了简化，提高了效率。

      增广路径的定义(也称增广轨或交错轨)：
　　若P是图G中一条连通两个未匹配顶点的路径，并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径。
由增广路径的定义可以推出下述4个结论：
        1－P的路径长度必定为奇数，第一条边和最后一条边都不属于M。
        2－P上所有第奇数条边都不在M中，所有第偶数条边都出现在M中。
　　 3－P经过取反操作可以得到一个更大的匹配M’。所谓“取反”即把P上所有第奇数条边(原不在M中)加入到M中，并把P中所有第偶数条边(原在M中)从M中删除，则新的匹配数就比原匹配数多了1个。（增广路顾名思义就是使匹配数增多的路径）
        4－M为G的最大匹配当且仅当不存在相对于M的增广路径。

   最大流算法的核心问题就是找增广路径（augment path）。匈牙利算法也不例外，它的基本模式就是：
     初始时最大匹配为空
      while 找得到增广路径
               do 把增广路径加入到最大匹配中去
      可见和最大流算法是一样的。但是这里的增广路径就有它一定的特殊性。（注：匈牙利算法虽然根本上是最大流算法，但是它不需要建网络模型，所以图中不再需要源点和汇点，仅仅是一个二分图。每条边也不需要有方向。）

      算法的思路是不停的找增广路径, 并增加匹配的个数,增广路径顾名思义是指一条可以使匹配数变多的路径，在匹配问题中,增广路径的表现形式是一条"交错路径"，也就是说这条由图的边组成的路径， 它的第一条边是目前还没有参与匹配的，第二条边参与了匹配，第三条边没有..最后一条边没有参与匹配，并且始点和终点还没有被选择过。这样交错进行，显然他有奇数条边。那么对于这样一条路径，我们可以将第一条边改为已匹配，第二条边改为未匹配...以此类推。也就是将所有的边进行"反色"，容易发现这样修改以后，匹配仍然是合法的，但是匹配数增加了一对。另外，单独的一条连接两个未匹配点的边显然也是交错路径。可以证明。当不能再找到增广路径时，就得到了一个最大匹配，这也就是匈牙利算法的思路。

3个重要结论：

最小点覆盖数： 最小覆盖要求用最少的点（Ｘ集合或Ｙ集合的都行）让每条边都至少和其中一个点关联。可以证明：最少的点（即覆盖数）＝最大匹配数
最小路径覆盖=最小路径覆盖＝｜N｜－最大匹配数
用尽量少的不相交简单路径覆盖有向无环图Ｇ的所有结点。解决此类问题可以建立一个二分图模型。把所有顶点i拆成两个：Ｘ结点集中的i和Y结点集中的i'，如果有边i->j，则在二分图中引入边i->j'，设二分图最大匹配为m，则结果就是n-m。
二分图最大独立集=顶点数-二分图最大匹配
在Ｎ个点的图G中选出m个点，使这m个点两两之间没有边，求m最大值。
如果图Ｇ满足二分图条件，则可以用二分图匹配来做．最大独立集点数 = N - 最大匹配数。

 

二分图匹配（匈牙利算法）

1。一个二分图中的最大匹配数等于这个图中的最小点覆盖数

König定理是一个二分图中很重要的定理，它的意思是，一个二分图中的最大匹配数等于这个图中的最小点覆盖数。如果你还不知道什么是最小点覆盖，我也在这里说一下：假如选了一个点就相当于覆盖了以它为端点的所有边，你需要选择最少的点来覆盖所有的边。

 

2。最小路径覆盖=最小路径覆盖＝｜G｜－最大匹配数

 在一个N*N的有向图中，路径覆盖就是在图中找一些路经，使之覆盖了图中的所有顶点，
 且任何一个顶点有且只有一条路径与之关联；（如果把这些路径中的每条路径从它的起始点走到它的终点，
 那么恰好可以经过图中的每个顶点一次且仅一次）；如果不考虑图中存在回路，那么每每条路径就是一个弱连通子集．

由上面可以得出：

 1.一个单独的顶点是一条路径；
 2.如果存在一路径p1,p2,......pk，其中p1 为起点，pk为终点，那么在覆盖图中，顶点p1,p2,......pk不再与其它的
   顶点之间存在有向边．

最小路径覆盖就是找出最小的路径条数，使之成为G的一个路径覆盖．

 路径覆盖与二分图匹配的关系：最小路径覆盖＝｜G｜－最大匹配数；

3。二分图最大独立集=顶点数-二分图最大匹配

独立集：图中任意两个顶点都不相连的顶点集合。

二分图模板：

 

模板一：匈牙利算法

/* **************************************************************************

//二分图匹配（匈牙利算法的DFS实现）

//初始化：g[][]两边顶点的划分情况

//建立g[i][j]表示i->j的有向边就可以了，是左边向右边的匹配

//g没有边相连则初始化为0

//uN是匹配左边的顶点数，vN是匹配右边的顶点数

//调用：res=hungary();输出最大匹配数

//优点：适用于稠密图，DFS找增广路，实现简洁易于理解

//时间复杂度:O(VE)

//***************************************************************************/

//顶点编号从0开始的

const int MAXN=510;

int uN,vN;//u,v数目

int g[MAXN][MAXN];

int linker[MAXN];

bool used[MAXN];

bool dfs(int u)//从左边开始找增广路径

{

    int v;

    for(v=0;v 
  
      if(g[u][v]&&!used[v])
 
  
      {
 
  
          used[v]=true;
 
  
          if(linker[v]==-1||dfs(linker[v]))
 
  
          {//找增广路，反向
 
  
              linker[v]=u;
 
  
              return true;
 
  
          }
 
  
      }
 
  
    return false;//这个不要忘了，经常忘记这句
 
  
}
 
  
int hungary()
 
  
{
 
  
    int res=0;
 
  
    int u;
 
  
    memset(linker,-1,sizeof(linker));
 
  
    for(u=0;u 
  
    {
 
  
        memset(used,0,sizeof(used));
 
  
        if(dfs(u)) res++;
 
  
    }
 
  
    return res;
 
  
}
 
  
//******************************************************************************/
 
  
 
 
  
模板二： Hopcroft-Carp算法
 
  
这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法
 
  
/* *********************************************
 
  
二分图匹配（Hopcroft-Carp的算法）。
 
  
初始化：g[][]邻接矩阵
 
  
调用：res=MaxMatch();  Nx,Ny要初始化！！！
 
  
时间复杂大为 O(V^0.5 E)
 
  
 
 
  
适用于数据较大的二分匹配
 
  
需要ｑｕｅｕｅ头文件
 
  
********************************************** */
 
  
const int MAXN=3000;
 
  
const int INF=1<<28;
 
  
int g[MAXN][MAXN],Mx[MAXN],My[MAXN],Nx,Ny;
 
  
int dx[MAXN],dy[MAXN],dis;
 
  
bool vst[MAXN];
 
  
bool searchP()
 
  
{
 
  
    queueQ;
 
  
    dis=INF;
 
  
    memset(dx,-1,sizeof(dx));
 
  
    memset(dy,-1,sizeof(dy));
 
  
    for(int i=0;i 
  
        if(Mx[i]==-1)
 
  
        {
 
  
            Q.push(i);
 
  
            dx[i]=0;
 
  
        }
 
  
    while(!Q.empty())
 
  
    {
 
  
        int u=Q.front();
 
  
        Q.pop();
 
  
        if(dx[u]>dis)  break;
 
  
        for(int v=0;v 
  
            if(g[u][v]&&dy[v]==-1)
 
  
            {
 
  
                dy[v]=dx[u]+1;
 
  
                if(My[v]==-1)  dis=dy[v];
 
  
                else
 
  
                {
 
  
                    dx[My[v]]=dy[v]+1;
 
  
                    Q.push(My[v]);
 
  
                }
 
  
            }
 
  
    }
 
  
    return dis!=INF;
 
  
}
 
  
bool DFS(int u)
 
  
{
 
  
    for(int v=0;v 
  
       if(!vst[v]&&g[u][v]&&dy[v]==dx[u]+1)
 
  
       {
 
  
           vst[v]=1;
 
  
           if(My[v]!=-1&&dy[v]==dis) continue;
 
  
           if(My[v]==-1||DFS(My[v]))
 
  
           {
 
  
               My[v]=u;
 
  
               Mx[u]=v;
 
  
               return 1;
 
  
           }
 
  
       }
 
  
    return 0;
 
  
}
 
  
int MaxMatch()
 
  
{
 
  
    int res=0;
 
  
    memset(Mx,-1,sizeof(Mx));
 
  
    memset(My,-1,sizeof(My));
 
  
    while(searchP())
 
  
    {
 
  
        memset(vst,0,sizeof(vst));
 
  
        for(int i=0;i 
  
          if(Mx[i]==-1&&DFS(i))  res++;
 
  
    }
 
  
    return res;
 
  
}