二分图匹配

二分图匹配

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

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

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

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

由上面可以得出：

1)一个单独的顶点是一条路径；

2)如果存在一路径p1,p2,......pk，其中p1 为起点，pk为终点，那么在覆盖图中，顶点p1,p2,......pk不再与其它的

   顶点之间存在有向边．

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

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

3.二分图最大独立集=顶点数-二分图最大匹配
独立集：图中任意两个顶点都不相连的顶点集合。

总结：对于二分匹配，有一个集合X，有一个集合Y，X、Y集合内部无联系，之间有联系，X集合连接Y集合，则dfs时对Y集合的每个找其匹配是否为X集合的u，hunger时对X集合的每个点遍历是否匹配

一、匈牙利算法

顶点编号从0开始的

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

const int maxn=510;
int uN,vN;//u,v数目,uN是匹配左边的顶点数，vN是匹配右边的顶点数
int g[maxn][maxn];//初始化：g[][]两边顶点的划分情况,建立g[i][j]表示i->j的有向边就可以了，是左边向右边的匹配
int linker[maxn];
bool used[maxn];
bool dfs(int u)//从左边开始找增广路径
{
int v;
for(v=0;v<vN;v++)//这个顶点编号从0开始，若要从1开始需要修改
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<uN;u++)
{
memset(used,0,sizeof(used));
if(dfs(u)) res++;
}
return res;
}

二、Hopcroft-Carp算法

这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法、需要ｑｕｅｕｅ头文件

const int maxn=3000;
const int INF=1<<28;
int g[maxn][maxn],Mx[maxn],My[maxn],Nx,Ny;//初始化：g[][]邻接矩阵
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));//调用：res=MaxMatch();  Nx,Ny要初始化！！！
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;
}