您的位置：首页 > 其它

二分图最大匹配总结

2015-08-10 10:12 405 查看

全部引用自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开始的

constintMAXN=510;

intuN,vN;//u,v数目

intg[MAXN][MAXN];

intlinker[MAXN];

boolused[MAXN];

booldfs(intu)//从左边开始找增广路径

intv;

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;

returntrue;

returnfalse;//这个不要忘了，经常忘记这句

inthungary()

intres=0;

intu;

memset(linker,-1,sizeof(linker));

for(u=0;u<uN;u++)

memset(used,0,sizeof(used));

if(dfs(u))res++;

returnres;

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

模板二：Hopcroft-Carp算法

这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法

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

二分图匹配（Hopcroft-Carp的算法）。

初始化：g[][]邻接矩阵

调用：res=MaxMatch();Nx,Ny要初始化！！！

时间复杂大为O(V^0.5E)

适用于数据较大的二分匹配

需要ｑｕｅｕｅ头文件

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

constintMAXN=3000;

constintINF=1<<28;

intg[MAXN][MAXN],Mx[MAXN],My[MAXN],Nx,Ny;

intdx[MAXN],dy[MAXN],dis;

boolvst[MAXN];

boolsearchP()

queue<int>Q;

dis=INF;

memset(dx,-1,sizeof(dx));

memset(dy,-1,sizeof(dy));

for(inti=0;i<Nx;i++)

if(Mx[i]==-1)

Q.push(i);

dx[i]=0;

while(!Q.empty())

intu=Q.front();

Q.pop();

if(dx[u]>dis)break;

for(intv=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]);

returndis!=INF;

boolDFS(intu)

for(intv=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;

return1;

return0;

intMaxMatch()

intres=0;

memset(Mx,-1,sizeof(Mx));

memset(My,-1,sizeof(My));

while(searchP())

memset(vst,0,sizeof(vst));

for(inti=0;i<Nx;i++)

if(Mx[i]==-1&&DFS(i))res++;

returnres;

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

下面的程序效率很高。是用vector实现邻接表的匈牙利算法。

处理点比较多的效率很高。1500的点都没有问题

/*

HDU1054

用STL中的vector建立邻接表实现匈牙利算法

效率比较高

G++578ms580K

*/

#include<stdio.h>

#include<iostream>

#include<algorithm>

#include<string.h>

#include<vector>

usingnamespacestd;

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

constintMAXN=1505;//这个值要超过两边个数的较大者，因为有linker

intlinker[MAXN];

boolused[MAXN];

vector<int>map[MAXN];

intuN;

booldfs(intu)

{

for(inti=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;

returntrue;

}

}

}

returnfalse;

}

inthungary()

{

intu;

intres=0;

memset(linker,-1,sizeof(linker));

for(u=0;u<uN;u++)

{

memset(used,false,sizeof(used));

if(dfs(u))res++;

}

returnres;

}

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

intmain()

{

intu,k,v;

intn;

while(scanf("%d",&n)!=EOF)

{

for(inti=0;i<MAXN;i++)

map[i].clear();

for(inti=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\n",hungary()/2);

}

return0;

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航