二分图最大匹配总结
全部引用自kuangbin的博客。
二分图匹配（匈牙利算法）
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<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算法
这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法
/* *********************************************二分图匹配（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(){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;}//**************************************************************************/下面的程序效率很高。是用vector实现邻接表的匈牙利算法。
处理点比较多的效率很高。1500的点都没有问题
/*
HDU 1054
用STL中的vector建立邻接表实现匈牙利算法
效率比较高
G++ 578ms 580K
*/
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<vector>
using namespace std;
//************************************************
const int MAXN=1505;//这个值要超过两边个数的较大者，因为有linker
int linker[MAXN];
bool used[MAXN];
vector<int>map[MAXN];
int uN;
bool dfs(int u)
{
for(int i=0;i<map[u].size();i++)
{
if(!used[map[u][i]])
{
used[map[u][i]]=true;
if(linker[map[u][i]]==-1||dfs(linker[map[u][i]]))
{
linker[map[u][i]]=u;
return true;
}
}
}
return false;
}
inthungary()
{
int u;
int res=0;
memset(linker,-1,sizeof(linker));
for(u=0;u<uN;u++)
{
memset(used,false,sizeof(used));
if(dfs(u)) res++;
}
return res;
}
//*****************************************************
int main()
{
int u,k,v;
int n;
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i<MAXN;i++)
map[i].clear();
for(int i=0;i<n;i++)
{
scanf("%d:(%d)",&u,&k);
while(k--)
{
scanf("%d",&v);
map[u].push_back(v);
map[v].push_back(u);
}
}
uN=n;
printf("%d ",hungary()/2);
}
return 0;
}