二分图最大匹配之Hopcroft-Karp算法 详解

Hopcroft-Karp算法 原链接

该算法由John.E.Hopcroft和Richard M.Karp于1973提出，故称Hopcroft-Karp算法。

原理

为了降低时间复杂度，可以在增广匹配集合M时，每次寻找多条增广路径。这样就可以进一步降低时间复杂度，可以证明，算法的时间复杂度可以到达O（n^0.5*m），虽然优化不了多少，但在实际应用时，效果还是很明显的。

基本算法

该算法主要是对匈牙利算法的优化，在寻找增广路径的时候同时寻找多条不相交的增广路径，形成极大增广路径集，然后对极大增广路径集进行增广。在寻找增广路径集的每个阶段，找到的增广路径集都具有相同的长度，且随着算法的进行，增广路径的长度不断的扩大。可以证明，最多增广n^0.5次就可以得到最大匹配。

算法流程

（1）从G=(X,Y;E)中取一个初始匹配。

（2）若X中的所有顶点都被M匹配，则表明M为一个完美匹配，返回；否则，以所有未匹配顶点为源点进行一次BFS，标记各个点到源点的距离。

（3）在满足dis[v] = dis[u] + 1的边集<v,u>中，从X中找到一个未被M匹配的顶点x0，记S = {x0}，T = ￠。

（4）若N（S） = T，则表明当前已经无法得到更大匹配，返回；否则取一y0∈N(S) - 。

（5）若y0已经被M匹配则转步骤（6），否则做一条x0->y0的M-增广路径P（x0,y0）,取M = M△P（x0,y0）。

（6）由于y已经被M匹配，所以M中存在一条边（y0,z0）去S = S∪ {z0}，T = T∪{y0}，转步骤（2）。

算法具体时间与分析

在寻找增广路径中可以对X中的每个未匹配的顶点进行BFS，BFS时对每个顶点维护一个距离编号dx[nx],dy[ny]，如果某个Y中的节点为未匹配点，则找到一条增广路径。BFS结束后找到了增广路径集。然后利用DFS与匈牙利算法类似的方法对每条增广路进行增广，这样就可以找到最大匹配。

实现代码

以POJ 1469为例。

#include<bits/stdc++.h>
 using namespace std;
 const int MAXN=500;// 最大点数
 const int INF=1<<28;// 距离初始值
 int bmap[MAXN][MAXN];//二分图
 int cx[MAXN];//cx[i]表示左集合i顶点所匹配的右集合的顶点序号
 int cy[MAXN]; //cy[i]表示右集合i顶点所匹配的左集合的顶点序号
 int nx,ny;
 int dx[MAXN];
 int dy[MAXN];
/*dx[i]表示左集合i顶点的距离编号，dy[i]表示右集合i顶点的距离编号*/
 int dis;
 bool bmask[MAXN];
 //寻找 增广路径集
 bool searchpath()
 {
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));//第几层
    memset(dy,-1,sizeof(dy));
    for(int i=1;i<=nx;i++)
    {
       //cx[i]表示左集合i顶点所匹配的右集合的顶点序号
       if(cx[i]==-1)
       {
          //将未遍历的节点 入队 并初始化次节点距离为0
          Q.push(i);
          dx[i]=0;//第0层
       }
    }
    //广度搜索增广路径
    while(!Q.empty())
    {
       int u=Q.front();
       Q.pop();
       if(dx[u]>dis) break;
       //取右侧节点
       for(int v=1;v<=ny;v++)
       {
          //右侧节点的增广路径的距离
          if(bmap[u][v]&&dy[v]==-1)
          {
             dy[v]=dx[u]+1; //v对应的距离 为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 v=1;v<=ny;v++)
    {
       //如果该点没有被遍历过 并且距离为上一节点+1
       if(!bmask[v]&&bmap[u][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;
 }
 //得到最大匹配的数目
 int MaxMatch()
 {
    int res=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));//cx[i]表示左集合i顶点所匹配的右集合的顶点序号
    while(searchpath())    //如果存在增广路 一直迭代到无增广路
    {
       memset(bmask,0,sizeof(bmask));//标记数组
       for(int i=1;i<=nx;i++)
       {
          if(cx[i]==-1)
          {
             res+=findpath(i);
          }
       }
    }
    return res;
 }
 int main()
 {
    int num;
    scanf("%d",&num);
    while(num--)
    {
       memset(bmap,0,sizeof(bmap));
       scanf("%d%d",&nx,&ny);
       for(int i=1;i<=nx;i++)
       {
          int snum;
          scanf("%d",&snum);
          int u;
          for(int j=1;j<=snum;j++)
          {
             scanf("%d",&u);
             bmap[i][u]=1;
            // bmap[u][i]=1;
          }
       }
      // cout<<MaxMatch()<<endl;
       if(MaxMatch()==nx)
       {
          printf("YES\n");
       }
       else
       {
          printf("NO\n");
       }
    }
    //system("pause");
    return 0;
 }
 /*
4
1 3
1 3 4
2
 */