算法学习：图论之用匈牙利算法求二分图的最大匹配

匈⽛利算法解决⼆分图最⼤匹配预备知识 匈⽛利算法是由匈⽛利数学家Edmonds于1965年提出，因⽽得名。

匈⽛利算法是基于Hall定理中充分性证明的思想，它是⼆分图匹配最常见的算法，该算法的核⼼就是寻找增⼴路径，它是⼀种⽤增⼴路径求⼆分图最⼤匹配的算法。

⼆分图 ⼆分图⼜称作⼆部图，是图论中的⼀种特殊模型。

设G=(V,E)是⼀个⽆向图，如果顶点V可分割为两个互不相交的⼦集(A，B)，并且图中的每条边（i，j）所关联的两个顶点 i 和 j 分别属于这两个不同的顶点集(i in A，j in B)，则称图G为⼀个⼆分图。

匹配 在图论中，⼀个图是⼀个匹配（或称独⽴边集）是指这个图之中，任意两条边都没有公共的顶点。

这时每个顶点都⾄多连出⼀条边，⽽每⼀条边都将⼀对顶点相匹配。

例如，图3、图4中红⾊的边就是图2的匹配。

图3中1、4、5、7为匹配点，其他顶点为⾮匹配点，1-5、4-7为匹配边，其他边为⾮匹配边。

最⼤匹配 ⼀个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最⼤匹配。

图 4 是⼀个最⼤匹配，它包含 4 条匹配边。

任意图中，极⼤匹配的边数不少于最⼤匹配的边数的⼀半。

完美匹配 如果⼀个图的某个匹配中，所有的顶点都是匹配点，那么它就是⼀个完美匹配。

显然，完美匹配⼀定是最⼤匹配，但并⾮每个图都存在完美匹配。

最⼤匹配数：最⼤匹配的匹配边的数⽬。

最⼩点覆盖数：选取最少的点，使任意⼀条边⾄少有⼀个端点被选择。

最⼤独⽴数：选取最多的点，使任意所选两点均不相连。

最⼩路径覆盖数：对于⼀个DAG（有向⽆环图），选取最少条路径，使得每个顶点属于且仅属于⼀条路径，路径长可以为0（即单个点）定理1：Konig定理——最⼤匹配数 = 最⼩点覆盖数定理2：最⼤匹配数 = 最⼤独⽴数定理3：最⼩路径覆盖数 = 顶点数 - 最⼤匹配数匈⽛利算法例⼦ 为了便于理解，选取了dalao博客⾥找妹⼦的例⼦： 通过数代⼈的努⼒，你终于赶上了剩男剩⼥的⼤潮，假设你是⼀位光荣的新世纪媒⼈，在你的⼿上有N个剩男，M个剩⼥，每个⼈都可能对多名异性有好感（惊讶，-_-||暂时不考虑特殊的性取向） 如果⼀对男⼥互有好感，那么你就可以把这⼀对撮合在⼀起，现在让我们⽆视掉所有的单相思（好忧伤的感觉，快哭了），你拥有的⼤概就是下⾯这样⼀张关系图，每⼀条连线都表⽰互有好感。

设G=(V,{R})是一个无向图。

如顶点集V可分割为两个互不相交的子集，并且图中每条边依附的两个顶点都分属两个不同的子集。

则称图G为二分图。

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

v选择这样的边数最大的子集称为图的最大匹配问题(maximal matching problem)v如果一个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。

最大匹配在实际中有广泛的用处，求最大匹配的一种显而易见的算法是：先找出全部匹配，然后保留匹配数最多的。

但是这个算法的复杂度为边数的指数级函数。

因此，需要寻求一种更加高效的算法。

匈牙利算法是求解最大匹配的有效算法，该算法用到了增广路的定义(也称增广轨或交错轨)：若P是图G中一条连通两个未匹配顶点的路径，并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M 的一条增广路径。

由增广路径的定义可以推出下述三个结论：v 1. P的路径长度必定为奇数，第一条边和最后一条边都不属于M。

v 2. P经过取反操作（即非M中的边变为M中的边，原来M中的边去掉）可以得到一个更大的匹配M’。

v 3. M为G的最大匹配当且仅当不存在相对于M的增广路径。

从而可以得到求解最大匹配的匈牙利算法：v(1)置M为空v(2)找出一条增广路径P，通过取反操作获得更大的匹配M’代替Mv(3)重复(2)操作直到找不出增广路径为止根据该算法，我选用dfs (深度优先搜索)实现。

程序清单如下：int match[i] //存储集合m中的节点i在集合n中的匹配节点,初值为-1。

int n,m,match[100]; //二分图的两个集合分别含有n和m个元素。

bool visit[100],map[100][100]; //map存储邻接矩阵。

bool dfs(int k){int t;for(int i = 0; i < m; i++)if(map[k][i] && !visit[i]){visit[i] = true;t = match[i];match[i] = k; //路径取反操作。

python实现匈⽛利算法求解⼆分图最⼤匹配重点：理解和取反1. 匈⽛利算法求解⽬标：找到⼆分图的最⼤匹配整体思路：每⼀步寻找⼀条增⼴路径，取反2. 关键步骤⼆分图的顶点分为左边点集X和右边点集Y，假定遍历的点集是X。

对于每⼀次迭代的点x_i，1. 搜索增⼴路径：遍历x_i的邻接节点y_j1. 如果y_j未匹配，则找到增⼴路2. 如果y_j已匹配，则寻找y_j的匹配节点的增⼴路径（深搜或者⼴搜）2. 取反：把增⼴路径中的已经匹配边改成未匹配；未匹配的改成匹配3. python代码算法输⼊为字典形式的特殊邻接表。

特殊之处在于字典的键和值的顶点分别属于⼆分图的左右点集合。

深度搜索增⼴路径函数的参数中的visited_set的作⽤是避免重复访问。

# 匈⽛利算法（dfs）class Hungarian:def search_extend_path(self, l_node, adjoin_map, l_match, r_match, visited_set):'''深度搜索增⼴路径'''for r_node in adjoin_map[l_node]: # 邻接节点if r_node not in r_match.keys(): # 情况1：未匹配, 则找到增⼴路径，取反l_match[l_node] = r_noder_match[r_node] = l_nodereturn Trueelse: # 情况2：　已匹配next_l_node = r_match[r_node]if next_l_node not in visited_set:visited_set.add(next_l_node)if self.search_extend_path(next_l_node, adjoin_map, l_match, r_match, visited_set): # 找到增⼴路径，取反l_match[l_node] = r_noder_match[r_node] = l_nodereturn Truereturn Falsedef run(self, adjoin_map):''':param adjoin_map: {x_i: [y_j, y_k]}:return:'''l_match, r_match = {}, {} # 存放匹配for lNode in adjoin_map.keys():self.search_extend_path(lNode, adjoin_map, l_match, r_match, set())return l_match。

一、概述匈牙利算法是一种用于求解二分图最大匹配的经典算法，它的时间复杂度为O(n^3)，在实际应用中具有广泛的用途。

本文将通过一个具体的例题，详细介绍利用匈牙利算法求解完美匹配的具体步骤和方法。

二、问题描述假设有一个二分图G=(V, E)，其中V={U,V}，U={u1,u2,u3}，V={v1,v2,v3}，E={(u1,v1),(u1,v2),(u2,v2),(u3,v3)}，现在希望求解这个二分图的最大匹配。

三、匈牙利算法详解1. 初始化：需要初始化一个大小为|U|的数组match[]，用来记录每一个U中的顶点匹配的V中的顶点，初始化为-1，表示初始时没有匹配的顶点。

2. 寻找增广路径：通过遍历U中的每一个顶点，逐个寻找增广路径。

对于每一个未匹配的顶点，都尝试进行增广路径的寻找。

3. 匹配顶点：如果找到了一条增广路径，将增广路径上的顶点逐个匹配，并更新match[]数组。

4. 寻找最大匹配：重复上述步骤，直至无法继续寻找增广路径为止，此时match[]数组中记录的就是二分图的最大匹配。

四、具体例题求解接下来通过一个具体的例题来详细介绍匈牙利算法的求解过程。

假设有一个二分图G=(V, E)，其中V={U,V}，U={u1,u2,u3}，V={v1,v2,v3}，E={(u1,v1),(u1,v2),(u2,v2),(u3,v3)}。

首先初始化match[]数组为{-1,-1,-1}。

（1）对u1进行增广路径的寻找由于u1未匹配，从u1开始寻找增广路径。

首先考虑与u1相连的v1和v2。

对v1进行匹配，得到match[0]为1。

对v2进行匹配，得到match[0]为1。

（2）对u2进行增广路径的寻找由于u2未匹配，从u2开始寻找增广路径。

考虑与u2相连的v2。

对v2进行匹配，得到match[1]为2。

（3）对u3进行增广路径的寻找由于u3未匹配，从u3开始寻找增广路径。

考虑与u3相连的v3。

对v3进行匹配，得到match[2]为3。

⼆分图匹配--匈⽛利算法⼆分图匹配--匈⽛利算法⼆分图匹配匈⽛利算法基本定义：⼆分图 —— 对于⽆向图G=(V,E)，如果存在⼀个划分使V中的顶点分为两个互不相交的⼦集，且每个⼦集中任意两点间不存在边 ϵ∈E,则称图G为⼀个⼆分图。

⼆分图的充要条件是，G⾄少有两个顶点，且所有回路长度为偶数。

匹配 —— 边的集合，其中任意两条边都不存在公共顶点。

匹配边即是匹配中的元素，匹配点是匹配边的顶点，同样⾮匹配边，⾮匹配点相反定义。

最⼤匹配——在图的所有匹配中，包含最多边的匹配成为最⼤匹配 完美匹配——如果在⼀个匹配中所有的点都是匹配点，那么该匹配称为完美匹配。

附注：所有的完美匹配都是最⼤匹配，最⼤匹配不⼀定是完美匹配。

假设完美匹配不是最⼤匹配，那么最⼤匹配⼀定存在不属于完美匹配中的边，⽽图的所有顶点都在完美匹配中，不可能找到更多的边，所以假设不成⽴，及完美匹配⼀定是最⼤匹配。

交替路——从⼀个未匹配点出发，依次经过⾮匹配边，匹配边，⾮匹配边…形成的路径称为交替路，交替路不会形成环。

增⼴路——起点和终点都是未匹配点的交替路。

因为交替路是⾮匹配边、匹配边交替出现的，⽽增⼴路两端节点都是⾮匹配点，所以增⼴路⼀定有奇数条边。

⽽且增⼴路中的节点(除去两端节点)都是匹配点，所属的匹配边都在增⼴路径上，没有其他相连的匹配边，因此如果把增⼴路径中的匹配边和⾮匹配边的“⾝份”交换，就可以获得⼀个更⼤的匹配(该过程称为改进匹配)。

⽰例图Fig1_09_09.JPG注释：Fig3是⼀个⼆分图G=(V,E),V={1,2,3,4,5,6,7,8},E={(1,7),(1,5),(2,6),(3,5),(3,8),(4,5),(4,6)},该图可以重绘成Fig4，V可分成两个⼦集V={V1,V2},V1={1,2,3,4},V2={5,6,7,8}。

Fig4中的红⾊边集合就是⼀个匹配{(1,5),(4,6),(3,8)}Fig2中是最⼤匹配Fig1中红⾊边集合是完美匹配Fig1中交替路举例(4-6-2-7-1-5)Fig4中增⼴路(2-6-4-5-1-7)匈⽛利树匈⽛利树中从根节点到叶节点的路径均是交替路，且匈⽛利树的叶节点都是匹配点。

二分图的最优匹配（KM算法）KM算法用来解决最大权匹配问题：在一个二分图内，左顶点为X，右顶点为Y，现对于每组左右连接XiYj有权wij，求一种匹配使得所有wij的和最大。

基本原理该算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。

设顶点Xi的顶标为A[ i ]，顶点Yj的顶标为B[ j ]，顶点Xi与Yj之间的边权为w[i,j]。

在算法执行过程中的任一时刻，对于任一条边(i,j)，A[ i ]+B[j]>=w[i,j]始终成立。

KM算法的正确性基于以下定理：若由二分图中所有满足A[ i ]+B[j]=w[i,j]的边(i,j)构成的子图（称做相等子图）有完备匹配，那么这个完备匹配就是二分图的最大权匹配。

首先解释下什么是完备匹配，所谓的完备匹配就是在二部图中，X点集中的所有点都有对应的匹配或者是Y点集中所有的点都有对应的匹配，则称该匹配为完备匹配。

这个定理是显然的。

因为对于二分图的任意一个匹配，如果它包含于相等子图，那么它的边权和等于所有顶点的顶标和；如果它有的边不包含于相等子图，那么它的边权和小于所有顶点的顶标和。

所以相等子图的完备匹配一定是二分图的最大权匹配。

初始时为了使A[ i ]+B[j]>=w[i,j]恒成立，令A[ i ]为所有与顶点Xi关联的边的最大权，B[j]=0。

如果当前的相等子图没有完备匹配，就按下面的方法修改顶标以使扩大相等子图，直到相等子图具有完备匹配为止。

我们求当前相等子图的完备匹配失败了，是因为对于某个X顶点，我们找不到一条从它出发的交错路。

这时我们获得了一棵交错树，它的叶子结点全部是X顶点。

现在我们把交错树中X顶点的顶标全都减小某个值d，Y顶点的顶标全都增加同一个值d，那么我们会发现：1）两端都在交错树中的边(i,j)，A[ i ]+B[j]的值没有变化。

也就是说，它原来属于相等子图，现在仍属于相等子图。

2）两端都不在交错树中的边(i,j)，A[ i ]和B[j]都没有变化。

最大二分图匹配（匈牙利算法）二分图指的是这样一种图：其所有的顶点分成两个集合M和N，其中M或N中任意两个在同一集合中的点都不相连。

二分图匹配是指求出一组边，其中的顶点分别在两个集合中，并且任意两条边都没有相同的顶点，这组边叫做二分图的匹配，而所能得到的最大的边的个数，叫做最大匹配。

计算二分图的算法有网络流算法和匈牙利算法（目前就知道这两种），其中匈牙利算法是比较巧妙的，具体过程如下（转自组合数学）：令g=（x,*,y）是一个二分图，其中x={x1,x2...},y={y1,y2,....}.令m为g中的任意匹配。

1。

将x的所有不与m的边关联的顶点表上￥，并称所有的顶点为未扫描的。

转到2。

2。

如果在上一步没有新的标记加到x的顶点上，则停，否则，转33。

当存在x被标记但未被扫描的顶点时，选择一个被标记但未被扫描的x的顶点，比如xi，用（xi）标记y 的所有顶点，这些顶点被不属于m且尚未标记的边连到xi。

现在顶点xi 是被扫描的。

如果不存在被标记但未被扫描的顶点，转4。

4。

如果在步骤3没有新的标记被标记到y的顶点上，则停，否则转5。

5。

当存在y被标记但未被扫描的顶点时。

选择y的一个被标记但未被扫描的顶点，比如yj，用（yj）标记x的顶点，这些顶点被属于m且尚未标记的边连到yj。

现在，顶点yj是被扫描的。

如果不存在被标记但未被扫描的顶点则转道2。

由于每一个顶点最多被标记一次且由于每一个顶点最多被扫描一次，本匹配算法在有限步内终止。

代码实现：bfs过程：#include<stdio.h>#include<string.h>main(){bool map[100][300];inti,i1,i2,num,num1,que[300],cou,stu,match1[100],match2[300],pqu e,p1,now,prev[300],n;scanf("%d",&n);for(i=0;i<n;i++){scanf("%d%d",&cou,&stu);memset(map,0,sizeof(map));for(i1=0;i1<cou;i1++){scanf("%d",&num);for(i2=0;i2<num;i2++){scanf("%d",&num1);map[i1][num1-1]=true;}}num=0;memset(match1,int(-1),sizeof(match1)); memset(match2,int(-1),sizeof(match2)); for(i1=0;i1<cou;i1++){p1=0;pque=0;for(i2=0;i2<stu;i2++){if(map[i1][i2]){prev[i2]=-1;que[pque++]=i2;}elseprev[i2]=-2;}while(p1<pque){now=que[p1];if(match2[now]==-1)break;p1++;for(i2=0;i2<stu;i2++){if(prev[i2]==-2&&map[match2[now]][i2]){prev[i2]=now;que[pque++]=i2;}}}if(p1==pque)continue;while(prev[now]>=0){match1[match2[prev[now]]]=now; match2[now]=match2[prev[now]]; now=prev[now];}match2[now]=i1;match1[i1]=now;num++;}if(num==cou)printf("YES\n");elseprintf("NO\n");}}dfs实现过程：#include<stdio.h>#include<string.h>#define MAX 100bool map[MAX][MAX],searched[MAX]; int prev[MAX],m,n;bool dfs(int data){int i,temp;for(i=0;i<m;i++){if(map[data][i]&&!searched[i]){searched[i]=true;temp=prev[i];prev[i]=data;if(temp==-1||dfs(temp))return true;prev[i]=temp;}}return false;}main(){int num,i,k,temp1,temp2,job;while(scanf("%d",&n)!=EOF&&n!=0) {scanf("%d%d",&m,&k);memset(map,0,sizeof(map));memset(prev,int(-1),sizeof(prev)); memset(searched,0,sizeof(searched));for(i=0;i<k;i++){scanf("%d%d%d",&job,&temp1,&temp2); if(temp1!=0&&temp2!=0)map[temp1][temp2]=true;}num=0;for(i=0;i<n;i++){memset(searched,0,sizeof(searched)); dfs(i);}for(i=0;i<m;i++){if(prev[i]!=-1)num++;}printf("%d\n",num);}}。

⼆分图最⼤匹配总结⼆分图匹配（匈⽛利算法）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的算法）。