二分图最大匹配基础总结

今天学了最大匹配，感觉还是有点是非是懂，感觉大白上写的很详细。。所以写一下今天的总结感受\(≧▽≦)/

二分图：二分图是这样一个图，它的顶点可以分类两个集合X和Y，所有的边关联的两个顶点恰好一个属于集合X，另一个属于集合Y。

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

最大匹配：图中包含边数最多的匹配称为图的最大匹配。

完美匹配：如果所有点都在匹配边上，则称这个最大匹配是完美匹配。

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

什么是最小点覆盖，我也在这里说一下：假如选了一个点就相当于覆盖了以它为端点的所有边，你需要选择最少的点来覆盖所有的边。

HDU 1150 

HDU 1498

HDU 2603

 

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

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

由上面可以得出：

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

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

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

HDU 1151

 

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

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

HDU 1608

 

真正求二分图的最大匹配的题目很少，往往做一些简单的变化：

变种1：二分图的最小顶点覆盖

最小顶点覆盖要求用最少的点（X或Y中都行），让每条边都至少和其中一个点关联。

knoig定理:二分图的最小顶点覆盖数 = 二分图的最大匹配数（m）。

变种2：DAG图的最小路径覆盖

用尽量少的不相交简单路径覆盖有向无环图(DAG)G的所有顶点，这就是DAG图的最小路径覆盖问题。

结论：DAG图的最小路径覆盖数 = 节点数（n）- 最大匹配数（m）

变种3:二分图的最大独立集

结论：二分图的最大独立集数 = 节点数（n）— 最大匹配数（m）

今天晚上又去问了问柴爷，虽说之前知道公式，但是不是很明白公式和什么时候用，今天算是小明白赶快写下来，最小路径覆盖既用最少的边覆盖所有的节点，因为之前给的一些联通的节点可以得到最大匹配，也就是说求剩下的节点所需要的最少的边数，因为为n*n的有向图里用，所以直接用节点-最大匹配即可，而最小顶点覆盖既，如例子，几个警察分别管理一些道路，问需要最少多少个警察便可以管理所有道路，既用最少的点覆盖所有的边，最大独立集便是在n*n的有向图里，如果你求出最大匹配数m，n+n-2*m/2=n+n-m(假如有m匹配数，既一定有一半的点无关，所以有关的便是2*m/2)

 

贪心优化：贪心建图之后，在查找无匹配边，假若没有则是最优化，如果有则更新

 

for (int j = 1;j <= n2;j++)
         for (int i = 1;i <= n1;i++)
             if (g[i][j] && !link[j])
                 link[j] = i;

 

增光路算法大概：选一个未盖点u做起点，设这个x为x节点，然后选择一条从u出发的非匹配边到达y节点v，如果v是未节点，则成功找到一条增光路，否则下一步从v走匹配边。因为一个匹配点恰好和一条匹配边邻接，设匹配点v的匹配边的另一端点vist[v]，则可理解从u走到了vist[v],而这个vist[v]也是一个x节点，如果始终没有找到未盖点，则会扩展成一颗所谓的匈牙利树。

看的别人的博客写的两种算法

匈牙利算法：

#include  <iostream>
 using namespace std;
const int MAXN = 1001 ,MAXM = 1001 ;
int n1,n2,m,ans; //n1,n2分别为二分图两边节点的个数,两边的节点分别用1..n1,1..n2编号,m为边数
 bool g[MAXN][MAXM]; //图G邻接矩阵g[x][y]
 bool y[MAXM]; //Y集合中点i访问标记
 int link[MAXM]; //link[y]表示当前与y节点相邻的x节点
 
void init()
 {
     int x,y;
     memset(g,0 ,sizeof (g));
     memset(link,-1 ,sizeof (link));
     ans = 0 ;
     scanf("%d%d%d" ,&n1,&n2,&m);
     for (int i = 1 ;i <= m;i++)
     {
         scanf("%d%d" ,&x,&y);
         g[x][y] = true ;
     }
 }

bool find(int x) //是否存在X集合中节点x开始的增广路
 {
     for (int i = 1 ;i <= n2;i++)
         if (g[x][i] && !y[i]) //如果节点i与x相邻并且未访问过
         {
             y[i] = true ;
             if (link[i] == -1 || find(link[i])) //如果找到一个未盖点i中或从与i相邻的节点出发有增广路
             {
                 link[i] = x;
                 return true ;
             }
         }
     return false ;
 }

int main()
 {
     init();
      /*for (int j = 1;j <= n2;j++)
         for (int i = 1;i <= n1;i++)
             if (g[i][j] && !link[j])
                 link[j] = i;//贪心初始解优化*/ 
     for (int i = 1 ;i <= n1;i++)
     {
         memset(y,0 ,sizeof (y));
         if (find(i))
             ans++;
     }
     printf("%d/n" ,ans);
     return 0 ;
 }

Hopcroft-Carp算法：（这种方法我还没有用过，这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法）

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()
{
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<Nx;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<Ny;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<Ny;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<Nx;i++)
          if(Mx[i]==-1&&DFS(i))  res++;
    }
    return res;
}