算法学习：图论之用匈牙利算法求二分图的最大匹配
匈牙利算法解决二分图最大匹配
匈⽛利算法解决⼆分图最⼤匹配预备知识 匈⽛利算法是由匈⽛利数学家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个剩⼥，每个⼈都可能对多名异性有好感（惊讶，-_-||暂时不考虑特殊的性取向） 如果⼀对男⼥互有好感，那么你就可以把这⼀对撮合在⼀起，现在让我们⽆视掉所有的单相思（好忧伤的感觉，快哭了），你拥有的⼤概就是下⾯这样⼀张关系图，每⼀条连线都表⽰互有好感。
匈牙利算法
4
匈牙利算法
• 在二分图上寻找最大匹配的算法
• 算法思想核心：增广路 • 若P是图G中一条连通两个未匹配顶点（在两边 ）的路径，并已匹配和待匹配的边在P上交替出 现，则称P为相对于图G当前匹配的一条增广路 径。
5
匈牙利算法
• 三个结论： • 1－P的路径长度必定为奇数，第一条边和最后 一条边都未匹配。 • 2－路径P上的匹配边和未匹配边取反可以得到 一个更大的匹配 • 3－当前匹配为G的最大匹配当且仅当不存在增 广路径。 • 匈牙利算法：不断寻找增广路的过程
6
匈牙利算法
• 匈牙利算法步骤：
• 1.置匹配为空 • 2.找出一条增广路径P，把路径P上的边匹配情 况全部取反
• 3.重复2直到找不到增广稳定婚姻问题
• 有n个男士与n个女士，每一个男士有他喜欢的 一些女士 • 问是否存在一种婚姻匹配方法，使得每一个男士 都与一个他喜欢的女士结婚 • 二分图——是否存在完美匹配
3
二分图最大匹配问题
• 给出一个二分图，选出最多的边，使得任意两条 边都不相邻
如果一个匹配中，|V1|<=|V2|且匹配数|M|=|V1| 则称此匹配为完全匹配，特别的当|V1|=|V2|时称 为完美匹配
二分图匹配(匈牙利算法)
设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实现匈牙利算法求解二分图最大匹配
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算法）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);}}。
二分图匹配(匈牙利算法)
KM算法
对于任意的G和M,可行顶标都是存在的: l(x) = maxw(x,y) l(y) = 0 欲求完全二分图的最佳匹配,只要用匈牙利算法求 其相等子图的完备匹配;问题是当标号之后的Gl无 完备匹配时怎么办?1957年(居然比匈牙利算法 早???),Kuhn和Munkras给出了一个解决该问 题的有效算法,用逐次修改可行顶标l(v)的办法使对 应的相等子图之最大匹配逐次增广,最后出现完备 匹配.
例题3 打猎 猎人要在n*n的格子里打鸟,他可以在某一行 中打一枪,这样此行中的所有鸟都被打掉, 也可以在某一列中打,这样此列中的所有鸟 都打掉.问至少打几枪,才能打光所有的鸟? 建图:二分图的X部为每一行,Y部为每一列, 如果(i,j)有一只鸟,那么连接X部的i与Y部的j. 该二分图的最大匹配数则是最少要打的枪数.
1 2 3 4 5
1 2 5 3 4
1
2
3
4
由于每条边表示一个空地,有冲 突的空地之间必有公共顶点,所 以问题转化为二部图的最大匹配 问题.
1 2Leabharlann 34例题1 Place the Robots(ZOJ) 小结
比较前面的两个模型:模型一过于简单,没有给问 题的求解带来任何便利;模型二则充分抓住了问题的内 在联系,巧妙地建立了二部图模型.为什么会产生这种 截然不同的结果呢?其一是由于对问题分析的角度不同: 模型一以空地为点,模型二以空地为边;其二是由于对 原型中要素的选取有差异:模型一对要素的选取不充分, 模型二则保留了原型中"棋盘"这个重要的性质.由此 可见,对要素的选取,是图论建模中至关重要的一步.
例题4 最小路径覆盖 一个不含圈的有向图G中,G的一个路径覆盖 是一个其结点不相交的路径集合P,图中的每 一个结点仅包含于P中的某一条路径.路径可 以从任意结点开始和结束,且长度也为任意 值,包括0.请你求任意一个不含圈的有向图 G的最小路径覆盖数. 理清一个关系:最小路径覆盖数=G的定点 数-最小路径覆盖中的边数
二分图最大匹配总结
⼆分图最⼤匹配总结⼆分图匹配（匈⽛利算法）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的算法）。
用匈牙利算法求二分图的最大匹配
用匈牙利算法求二分图的最大匹配二分图的最大匹配有两种求法，第一种是最大流；第二种就是匈牙利算法。
这个算法说白了就是最大流的算法，但是它跟据二分图匹配这个问题的特点，把最大流算法做了简化，提高了效率。
最大流算法的核心问题就是找增广路径（augment path）。
匈牙利算法也不例外，它的基本模式就是：初始时最大匹配M为空while 找得到增广路径do 把增广路径加入到最大匹配中去可见和最大流算法是一样的。
但是这里的增广路径就有它一定的特殊性，下面我来分析一下。
（注：匈牙利算法虽然根本上是最大流算法，但是它不需要建网络模型，所以图中不再需要源点和汇点，仅仅是一个二分图。
每条边也不需要有方向。
）图1是我给出的二分图中的一个匹配：［1，5］和［2，6］。
图2就是在这个匹配的基础上找到的一条增广路径：3->6->2->5->1->4。
我们借由它来描述一下二分图中的增广路径的性质：(1)有奇数条边。
(2)起点在二分图的左半边，终点在右半边。
(3)路径上的点一定是一个在左半边，一个在右半边，交替出现。
（其实二分图的性质就决定了这一点，因为二分图同一边的点之间没有边相连。
）(4)整条路径上没有重复的点。
(5)起点和终点都是目前还没有配对的点，而其它所有点都是已经配好对的。
（如图1、图2所示，［1，5］和［2，6］在图1中是两对已经配好对的点；而起点3和终点4目前还没有与其它点配对。
）(6)路径上的所有第奇数条边都不在原匹配中，所有第偶数条边都出现在原匹配中。
（如图1、图2所示，原有的匹配是［1，5］和［2，6］，这两条配匹的边在图2给出的增广路径中分边是第2和第4条边。
而增广路径的第1、3、5条边都没有出现在图1给出的匹配中。
）(7)最重要的一条，把增广路径上的所有第奇数条边加入到原匹配中去，并把增广路径中的所有第偶数条边从原匹配中删除（这个操作称为增广路径的取反），则新的匹配数就比原匹配数增加了1个。
匈牙利算法流程
匈牙利算法流程匈牙利算法是一种经典的图论算法，用于解决二分图的最大匹配问题，其流程简洁而高效。
下面将以人类的视角来叙述匈牙利算法的流程。
我们假设有一个二分图，其中左边有一组顶点，右边有另一组顶点。
我们的目标是找到一个最大的匹配，即找到左边的每个顶点与右边的某个顶点之间的边，使得每个右边的顶点最多与一个左边的顶点相连。
开始时，我们将所有的边标记为未匹配状态。
然后，我们从左边的第一个顶点开始，尝试寻找一个未匹配的右边的顶点。
如果找到了，我们将这条边标记为匹配状态，并继续寻找下一个左边的顶点。
如果没有找到，我们就需要进行增广路径的寻找。
为了寻找增广路径，我们从未匹配的左边顶点开始，沿着它的边逐个访问右边的顶点。
如果当前的右边顶点已经匹配了，我们就尝试寻找与这个右边顶点相匹配的左边顶点，然后再以这个左边顶点为起点，继续递归地寻找下一个右边顶点。
如果找到了增广路径，我们就可以通过交替匹配和取消匹配来增加匹配数目。
为了实现这个过程，我们需要用一个数组来保存每个左边顶点的匹配状态，另一个数组来保存每个右边顶点的匹配状态。
同时，我们还需要一个标记数组来记录每个左边顶点是否已经访问过。
通过深度优先搜索的方式，我们可以找到增广路径并更新匹配状态。
当所有的左边顶点都被访问过时，我们就找到了一个最大的匹配。
此时，我们可以输出匹配数目，或者根据需要输出具体的匹配方案。
总结一下，匈牙利算法通过不断寻找增广路径来增加匹配数目，直到无法找到增广路径为止。
它的核心思想是通过深度优先搜索来寻找增广路径，以达到最大匹配的目标。
这个算法简单而高效，被广泛应用于实际问题的求解中。
二分图(匈牙利,KM算法详解)
4,匹配数+1;
最小点覆盖
最小覆盖： 最小覆盖要求用最少的点（Ｘ集 合或Ｙ集合的都行）让每条边都至少和其中一 个点关联。可以证明：最少的点（即覆盖数） ＝最大匹配数 M
简单的证明如下：
1
4
1
4
2
5 把图中红色线去掉
2
5
蓝色线加上
3
6
3
6
1
4
更改各自的匹配点
找到一个更好的匹配 2
5
3
6
总结
所以流程就是:
1,对于一个未匹配的节点u,寻找它的每条边,如果它的边上 的另一个节点v还没匹配则表明找到了一个匹配,直接转步 骤4;
2,假如节点u它边上的另一个节点v已经匹配,那么就转向跟 v匹配的节点,假设是w,然后再对w重复1,2的步骤,即寻找增 广路.
现在我们假设要求的是最大距离.那么就是求最大权 匹配. 下面我们先介绍一下KM算法
KM算法
基本概念：可行顶标和相等子图
可行顶标：L是一个关于结点的函数，L(x)是顶点x对应 的顶标值。可行顶标对于图中的每条边(x,y)都有 L(x)+L(y)>=w(x,y)
相等子图：只包含L(x)+L(y)=w(x,y)的边的子图
KM算法
定理：如果一个相等子图中包含完备匹配，那 么这个匹配就是最优匹配
证明：由于在算法过程一直保持顶标的可行性， 所以任意一个匹配的权值和肯定小于等于所有 结点的顶标之和，则相等子图中的完备匹配肯 定是最优匹配
KM算法
算法流程 设顶点Xi的顶标为a[i]，顶点Yi的顶标为b[i] ⅰ.初始时，a[i]为与Xi相关联的边的最大权值，
最大匹配算法(匈牙利算法)
最小路径覆盖
将n个点拆成2n个点，如1号变为1和1’， 1代表出边，1’代表进边。对于每个结点， 将与其相临的边连出来。 对已经连好的图求最大匹配数
最小路径覆盖
最小路径覆盖数=顶点数n-最大匹配数
Nkoj 1684 1465 1681 1070
courses Taxi Cab Scheme Girls and boys 信和信封的问题
一张残缺的棋盘，用1*2的矩形去覆盖它， 要求矩形不互相重叠棋盘染成黑白相间，黑色方格作为左 边的点，白色方格作为右边的点，相邻 的黑白方格中间连一条边。 对已经建好的图求最大匹配
二分图的最大独立数
最大独立数=最大匹配数
最小路径覆盖
一张图n个点，给定某些点之间可以用线 连起来。 问最少画多少笔才能将所有的点全部盖 住 poj1422
二分图的最小覆盖数
棋盘上有N个点，每次可以拿走一行或者 一列。 问最少多少次可以把棋盘上的所有点都 拿走
poj3041
二分图的最小覆盖数
将行作为左边的点，列作为右边的点， 原图中的每个点形成一条边，将代表其 行和列的点连接起来。 对已经建好的图求最大匹配
Konig定理
最大匹配数=最小覆盖数
二分图的最大独立数
二分图的 最大匹配
RCA
二分图
1
二分图是一种特殊的图 对于无向图G=(V,E)，如 果V可以分为两个互不相 交的子集，并且图中的每 条边所依附的两点都属于 不同的子集，则图G则称 为一个二分图
1’ 2 2’ 3 3’ 4 4’ 5
最大匹配
给定一个二分图G，在G的一个子图的边 集中的任意两条边都不依附于同一个顶 点，则称此子图是一个匹配。 选择这样的边数最大的子集称为图的最 最 大匹配问题(maximal matching problem) 大匹配问题 如果一个匹配中，图中的每个顶点都和 图中某条边相关联，则称此匹配为完全 完全 匹配，也称作完备匹配。 完备匹配。 匹配 完备匹配
匈牙利算法 描述
匈牙利算法描述匈牙利算法是图论中一种用于解决二分图匹配问题的算法。
它首次由匈牙利数学家Denzel匈牙利在1955年发表，因而得名。
匈牙利算法属于图匹配算法的范畴，在实际应用中有着很强的效率和准确性。
本文将介绍匈牙利算法的原理、实现方法和应用领域等相关内容。
一、匈牙利算法原理匈牙利算法是解决二分图最大匹配问题的经典算法之一。
在二分图中，匈牙利算法的目标是寻找图中的最大匹配，即尽可能多地找到满足匹配条件的边，也就是找到尽可能多的配对节点。
在匈牙利算法中，主要使用了增广路的概念，通过不断地寻找增广路，来不断地扩展匹配。
具体而言，匈牙利算法的核心思想是利用增广路径寻找最大匹配。
在每一次匹配的过程中，首先选择一个未匹配的节点，然后通过交替路径寻找增广路径，直到无法找到增广路径为止。
当无法找到增广路径时，说明找到了最大匹配。
增广路径指的是一条由未匹配的节点和匹配节点交替构成的路径，其中未匹配节点为起点和终点。
通过不断地寻找增广路径，可以逐步扩展匹配。
在匈牙利算法中，为了记录节点的匹配状态和寻找增广路径，通常使用匈牙利标号和匈牙利交错路的方式。
匈牙利标号是为每个节点标记一个代表节点匹配状态的值，而匈牙利交错路则是一种用于寻找增广路径的方法。
借助这些工具，匈牙利算法可以高效地解决最大匹配问题。
二、匈牙利算法实现方法匈牙利算法的实现方法较为复杂，需要结合图论和图匹配的相关知识。
在实际应用中，匈牙利算法通常通过编程实现，以解决特定的二分图匹配问题。
下面简要介绍匈牙利算法的一般实现方法。
1. 初始化匈牙利标号：首先对图中的所有未匹配节点进行初始化标号，即给它们赋予一个初始的匈牙利标号。
2. 寻找增广路径：选择一个未匹配的节点作为起点，通过交替路径和增广路的方法寻找增广路径。
在寻找增广路径的过程中，要根据节点的匈牙利标号来选择下一个节点，从而找到满足匹配条件的路径。
3. 匹配节点：如果成功找到一条增广路径，就可以将路径中的节点进行匹配，即将原来未匹配的节点与匹配节点进行匹配。
图论二分图匹配算法详细分析总结
二分图匹配算法总结 (by phoenixinter, Aug 2006)最近下决心要把二分图匹配部分的算法都搞搞清楚，努力了几天之后基本上搞定了，下面做一个这个专题的总结。
一、二分图最大匹配二分图最大匹配的经典匈牙利算法是由Edmonds在1965年提出的，算法的核心就是根据一个初始匹配不停的找增广路，直到没有增广路为止。
匈牙利算法的本质实际上和基于增广路特性的最大流算法还是相似的，只需要注意两点：（一）每个X节点都最多做一次增广路的起点；（二）如果一个Y节点已经匹配了，那么增广路到这儿的时候唯一的路径是走到Y节点的匹配点（可以回忆最大流算法中的后向边，这个时候后向边是可以增流的）。
找增广路的时候既可以采用dfs也可以采用bfs，两者都可以保证O(nm)的复杂度，因为每找一条增广路的复杂度是O(m)，而最多增广n次，dfs在实际实现中更加简短。
二、Hopcroft-Karp算法SRbGa很早就介绍过这个算法，它可以做到O(sqrt(n)*e)的时间复杂度，并且在实际使用中效果不错而且算法本身并不复杂。
Hopcroft-Karp算法是Hopcroft和Karp在1972年提出的，该算法的主要思想是在每次增广的时候不是找一条增广路而是同时找几条点不相交的最短增广路，形成极大增广路集，随后可以沿着这几条增广路同时进行增广。
可以证明在寻找增广路集的每一个阶段所寻找到的最短增广路都具有相等的长度，并且随着算法的进行最短增广路的长度是越来越长的，更进一步的分析可以证明最多只需要增广ceil(sqrt(n))次就可以得到最大匹配（证明在这里略去）。
因此现在的主要难度就是在O(e)的时间复杂度内找到极大最短增广路集，思路并不复杂，首先从所有X的未盖点进行BFS，BFS之后对每个X节点和Y节点维护距离标号，如果Y节点是未盖点那么就找到了一条最短增广路，BFS完之后就找到了最短增广路集，随后可以直接用DFS对所有允许弧(dist[y]=dist[x]+ 1，可以参见高流推进HLPP的实现)进行类似于匈牙利中寻找增广路的操作，这样就可以做到O(m)的复杂度。
用匈牙利算法求二分图的最大匹配.
一、用匈牙利算法求二分图(二部图,偶图的最大匹配算法中的几个术语说明:1。
二部图:如果图G=(V,E的顶点集何V可分为两个集合X,Y,且满足X∪Y =V, X∩Y=Φ,则G称为二部图;图G的边集用E(G表示,点集用V(G表示。
2。
匹配:设M是E(G的一个子集,如果M中任意两条边在G中均不邻接,则称M是G的一个匹配。
M中的—条边的两个端点叫做在M是配对的。
3。
饱和与非饱和:若匹配M的某条边与顶点v关联,则称M饱和顶点v,并且称v是M-饱和的,否则称v是M-不饱和的。
4。
交互道:若M是二分图G=(V,E的一个匹配。
设从图G中的一个顶点到另一个顶点存在一条道路,这条道路是由属于M的边和不属于M的边交替出现组成的,则称这条道路为交互道。
5。
可增广路:若一交互道的两端点为关于M非饱和顶点时,则称这条交互路是可增广路。
显然,一条边的两端点非饱和,则这条边也是可增广路。
6。
最大匹配:如果M是一匹配,而不存在其它匹配M',使得|M'|>|M|,则称M是最大匹配。
其中|M|表示匹配M的边数。
7。
对称差:A,B是两个集合,定义A⊕B = (A∪B\(A∩B ,则称A⊕B为A和B的对称差。
定理:M为G的最大匹配的充要条件是G中不存在可增广道路。
Hall定理:对于二部图G,存在一个匹配M,使得X的所有顶点关于M饱和的充要条件是:对于X的任意一个子集A,和A邻接的点集为T(A,恒有:|T(A| >= |A|。
匈牙利算法是基于Hall定理中充分性证明的思想,其基本步骤为:1。
任给初始匹配M;2。
若X已饱和则结束,否则进行第3步;3。
在X中找到一个非饱和顶点x0,作V1 ←{x0},V2 ←Φ ;4。
若T(V1 = V2则因为无法匹配而停止,否则任选一点y∈T(V1\V2;5。
若y已饱和则转6,否则做一条从x0→y的可增广路P,M←M⊕E(P,转2;6。
由于y已饱和,所以M中有一条边(y,z,作V1 ←V1∪{z}, V2←V2∪{y},转4;二、用匈牙利算法求二分图的最大匹配(伪代码给定一个二分图(x,y,x中的点和y中点的连接情况,一个匹配是二分图的子图,其中任一个x中的点只能和最多一个y中的点连接,一个y中的点也只能和一个x中的点连接,最大匹配就是使子图中的边数(我们称为匹配边最多的匹配。
二分图匹配算法（最大流匈牙利）
⼆分图匹配算法（最⼤流匈⽛利）⼆分图匹配相关概念⽆向⼆分图G(U⋃V,E)：U是⼀个顶点集合，V是另⼀个顶点集合，对于⼀个集合内的点⽆边直接相连，⽽对于不同集合的点可以连边，即(u,v)∈E。
匹配：两两不含公共端点的边的集合M称为匹配（就是两个集合之间连的边，只不过不同边的端点不能重合）最⼤匹配：元素最多的M，即⽽G中两两不含公共端点的边的集合M⊆E的基数|M|的最⼤值就是最⼤匹配。
完美匹配：当最⼤匹配的匹配数满⾜2∗|M|=V时，称为完美匹配。
形象的解释就是⼀各集合的所有点到另⼀个集合都有互不相同且唯⼀对应的点。
（类似于函数的双射），想象⼀下图增⼴路：设M为⼆分图G已匹配边的集合，若P是图G中⼀条连通两个未匹配顶点的路径（P的起点在X部，终点在Y部，反之亦可），并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的⼀条增⼴路径。
(就是连了两个还没有配对的顶点的路径，路径有⼀个配对边，⼀个⾮配对边交替组成)更多详细概念解释见匈⽛利部分的参考⽂章最⼤流的⽅法⼆分图的匹配可以看成是⼀种最⼤流问题（这谁想得出来啊）。
具体过程如下：现在有两个点集U和V，之间已经有了写连边，我们需要引⼊⼀个源，⼀个汇，把源跟集合U的所有点有向地连起来，把V的所有点和汇有向地连起来，就构成了⼀个流⽹络。
现在由于⼆分图匹配的限制，⼀个点不能连⾃⼰内部的点（在原来的⼆分图中这关系已经成⽴），不能连两个或多个边。
那么就把每个边的权值赋为⼀。
这样边的流量只有零壹两种，要么有边，要么不连边。
在上⾯跑最⼤流算法即可（具体讲解参见上篇博客）下⾯是代码：代码:#include <iostream>#include <memory.h>#include <vector>#include <queue>#define max_n 10005#define INF 0x3f3f3f3fusing namespace std;//邻接表struct edge{int v;//到达顶点int cap;//最⼤流量int rev;//对应反向边的编号};vector<edge> G[max_n];int level[max_n];//Dinic算法⽤到的层次图int iter[max_n];//当前弧优化void add_edge(int u,int v,int cap){G[u].push_back((edge){v,cap,G[v].size()});//最后⼀个表⽰uv这条边的反向边在G[v]⾥的标号G[v].push_back((edge){u,0,G[u].size()-1});}void bfs(int s)//处理层次图{memset(level,-1,sizeof(level));queue<int> que;level[s] = 0;que.push(s);while(!que.empty()){int v = que.front();que.pop();for(int i = 0;i<G[v].size();i++){edge& e = G[v][i];if(e.cap>0&&level[e.v]<0){level[e.v] = level[v]+1;que.push(v);}}}}int dfs(int v,int t,int f)//Dinic的dfs{if(v==t) return f;for(int& i = iter[v];i<G[v].size();i++){edge& e = G[v][i];if(e.cap>0&&level[e.v]==level[v]+1){int d = dfs(v,t,min(f,e.cap));if(d>0){G[e.v][e.rev].cap+=d;return d;}}}return 0;}int max_flow(int s,int t)//Dinic算法{int flow = 0;for(;;){bfs(s);if(level[t]<0){return flow;}memset(iter,0,sizeof(iter));int f;while(f=dfs(s,t,INF)>0){flow += f;}}}int N,K;//N,K为两个集合的点数bool can[max_n][max_n];//⼆分图中原有的边void solve(){//0~N-1是U中的点//N~N+K-1是V中的点int s = N+K;int t = s+1;for(int i = 0;i<N;i++)//s与U连边{add_edge(s,i,1);}for(int i = 0;i<K;i++)//t与V连边{add_edge(i+N,t,1);}for(int i = 0;i<N;i++){for(int j = 0;j<K;j++){if(can[i][j]){add_edge(i,j,1);//⼆分图原有边的链接}}}cout << max_flow(s,t) << endl;//求最⼤流即得最⼤匹配}int main(){cin >> N >> K;solve();return 0;}匈⽛利算法这个算法是专门处理⼆分图的最⼤匹配问题的，有很好的博客讲解，下⾯是推荐阅读⽅式：我上⾯的概念可能不太全，那就先来看看⼆分图的相关概念：可能还对增⼴路径不是很理解，什么是增⼴路，⾮配对配对交替什么的很混乱，那不妨先看看这个：现在到了算法流程了，在正式介绍前，先有个有趣⽽深刻的认识，下⾯是⼗分清晰的讲解：好了，该正式⼀点了，相信你也有了⼀定的了解：上⾯的代码其实已经够清晰了，如果还想看⼀下，就这篇吧：代码：#include <iostream>#include <memory.h>#define max_n 200005using namespace std;int n,m;int con_y[max_n];int visit[max_n];int head[max_n];struct edge{int v;int nxt;}e[max_n<<1];int cnt = 0;void add(int u,int v){++cnt;e[cnt].v = v;e[cnt].nxt = head[u];head[u] = cnt;}int dfs(int u){for(int i = head[u];i;i=e[i].nxt){int v = e[i].v;if(visit[v]==0){if(con_y[v]==-1||dfs(v))//结合上⾯算法流程部分的有趣博客再理解了⼀下这⾥的递归，好奇妙 {con_x[u] = v;con_y[v] = u;return 1;}}}return 0;}int Hungary(){memset(con_x,-1,sizeof(con_x));memset(con_y,-1,sizeof(con_y));int ans = 0;for(int i = 1;i<=n;i++){memset(visit,0,sizeof(visit));ans += dfs(i);}return ans;}int main(){cin >> n >> m;for(int i = 1;i<=m;i++){int a,b,c;cin >> a >> b;add(a,b);}cout << Hungary() << endl;return 0;}参考⽂章以上Processing math: 100%。
最大匹配算法匈牙利算法
经有的匹配做下修改，即和2进行匹配， 4
这样沿着已有匹配去寻找到
4‘
的新匹配叫增广路。
5
匈牙利算法
1.对于左边的每个点，看看右边有没有 增广路，如果有，那么进行增广，没有 就不添加新的匹配。
2.当对最后一个点做完增广路以后，整 个图就形成了一个最大匹配。
二分图的最小覆盖数
问最少画多少笔才能将所有的点全部盖 住
poj1422
最小路径覆盖
将n个点拆成2n个点，如1号变为1和1’， 1代表出边，1’代表进边。对于每个结点， 将与其相临的边连出来。
对已经连好的图求最大匹配数
最小路径覆盖
最小路径覆盖数=顶点数n-最大匹配数
Nkoj 1684 courses 1465 Taxi Cab Scheme 1681 Girls and boys 1070 信和信封的问题
poj 2239 Selecting Courses 1422 Air Raid 最小路径覆盖 1325 Machine Schedule 1719 Shooting Contest 2594 Treasure Exploration
2195 Going Home带权二分图(km算法) 2446 Chessboard 1904 King's Quest 3342 Party at Hali-Bula 3216 Repairing Company POJ3020 - Antenna Placement
一张残缺的棋盘，用1*2的矩形去覆盖它， 要求矩形不互相重叠。
求矩形最多可以放多少个。
二分图的最大独立数
将棋盘染成黑白相间，黑色方格作为左 边的点，白色方格作为右边的点，相邻 的黑白方格中间连一条边。
对已经建好的图求最大匹配
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用匈牙利算法求二分图的最大匹配
什么是二分图，什么是二分图的最大匹配，这些定义我就不讲了，网上随便都找得到。
二分图的最大匹配有两种求法，第一种是最大流（我在此假设读者已有网络流的知识）；第二种就是我现在要讲的匈牙利算法。
这个算法说白了就是最大流的算法，但是它跟据二分图匹配这个问题的特点，把最大流算法做了简化，提高了效率。
匈牙利算法其实很简单，但是网上搜不到什么说得清楚的文章。
所以我决定要写一下。
最大流算法的核心问题就是找增广路径（augment path）。
匈牙利算法也不例外，它的基本模式就是：
可见和最大流算法是一样的。
但是这里的增广路径就有它一定的特殊性，下面我来分析一下。
（注：匈牙利算法虽然根本上是最大流算法，但是它不需要建网络模型，所以图中不再需要源点和汇点，仅仅是一个二分图。
每条边也不需要有方向。
）
图1 图2
图1是我给出的二分图中的一个匹配：［1，5］和［2，6］。
图2就是在这个匹配的基础上找到的一条增广路径：3->6->2->5->1->4。
我们借由它来描述一下二分图中的增广路径的性质：
(1)有奇数条边。
(2)起点在二分图的左半边，终点在右半边。
(3)路径上的点一定是一个在左半边，一个在右半边，交替出现。
（其实二分图的性质就决定了这一点，因为二分图同一边的点之间没有边相连，不要忘记哦。
）
(4)整条路径上没有重复的点。
(5)起点和终点都是目前还没有配对的点，而其它所有点都是已经配好对的。
（如图1、图2所示，［1，5］和［2，6］在图1中是两对已经配好对的点；而起点3和终点4目前还没有与其它点配对。
）
(6)路径上的所有第奇数条边都不在原匹配中，所有第偶数条边都出现在原匹配中。
（如图1、图2所示，原有的匹配是［1，5］和［2，6］，这两条配匹的边在图2给出的增广路径中分边是第2和第4条边。
而增广路径的第1、3、5条边都没有出现在图1给出的匹配中。
）
(7)最后，也是最重要的一条，把增广路径上的所有第奇数条边加入到原匹配中去，并把增广路径中的所有第偶数条边从原匹配中删除（这个操作称为增广路径的取反），则新的匹配数就比原匹配数增加了1个。
（如图2所示，新的匹配就是所有蓝色的边，而所有红色的边则从原匹配中删除。
则新的匹配数为3。
）
不难想通，在最初始时，还没有任何匹配时，图1中的两条灰色的边本身也是增广路径。
因此在这张二分图中寻找最大配匹的过程可能如下：
(1)找到增广路径1->5，把它取反，则匹配数增加到1。
(2)找到增广路径2->6，把它取反，则匹配数增加到2。
(3)找到增广路径3->6->2->5->1->4，把它取反，则匹配数增加到3。
(4)再也找不到增广路径，结束。
当然，这只是一种可能的流程。
也可能有别的找增广路径的顺序，或者找到不同的增广路径，最终的匹配方案也可能不一样。
但是最大匹配数一定都是相同的。
对于增广路径还可以用一个递归的方法来描述。
这个描述不一定最准确，但是它揭示了寻找增广路径的一般方法：“从点A出发的增广路径”一定首先连向一个在原匹配中没有与点A配对的点B。
如果点B在原匹配中没有与任何点配对，则它就是这条增广路径的终点；反之，如果点B已与点C配对，那么这条增广路径就是从A到B，再从B 到C，再加上“从点C出发的增广路径”。
并且，这条从C出发的增广路径中不能与前半部分的增广路径有重复的点。
比如图2中，我们要寻找一条从3出发的增广路径，要做以下3步：
(1)首先从3出发，它能连到的点只有6，而6在图1中已经与2配对，所以目前的增广路径就是3->6->2再加上从2出发的增广路径。
(2)从2出发，它能连到的不与前半部分路径重复的点只有5，而且5确实在原匹配中没有与2配对。
所以从2连到5。
但5在图1中已经与1配对，所以目前的增广路径为3->6->2->5->1再加上从1出发的增广路径。
(3)从1出发，能连到的不与自已配对并且不与前半部分路径重复的点只有4。
因为4在图1中没有与任何点配对，所以它就是终点。
所以最终的增广路径是3->6->2->5->1->4。
但是严格地说，以上过程中从2出发的增广路径（2->5->1->4）和从1出发的增广路径（1->4）并不是真正的增广路径。
因为它们不符合前面讲过的增广路径的第5条性质，它们的起点都是已经配过对的点。
我们在这里称它们为“增广路径”只是为了方便说明整个搜寻的过程。
而这两条路径本身只能算是两个不为外界所知的子过程的返回结果。
显然，从上面的例子可以看出，搜寻增广路径的方法就是DFS，可以写成一个递归函数。
当然，用BFS也完全可以实现。
至此，理论基础部份讲完了。
但是要完成匈牙利算法，还需要一个重要的定理：
如果从一个点A出发，没有找到增广路径，那么无论再从别的点出发找到多少增广路径来改变现在的匹配，从A 出发都永远找不到增广路径。
要用文字来证明这个定理很繁，话很难说，要么我还得多画一张图，我在此就省了。
其实你自己画几个图，试图举两个反例，这个定理不难想通的。
（给个提示。
如果你试图举个反例来说明在找到了别的增广路径并改变了现有的匹配后，从A出发就能找到增广路径。
那么，在这种情况下，肯定在找到别的增广路径之前，就能从A出发找到增广路径。
这就与假设矛盾了。
）
如果二分图的左半边一共有n个点，那么最多找n条增广路径。
如果图中共有m条边，那么每找一条增广路径（DFS 或BFS）时最多把所有边遍历一遍，所花时间也就是m。
所以总的时间大概就是O（n * m）。
在UV A上，二分图匹配的题目有670和10080，祝好运。
匈牙利算法
链接：
USACO 4.2.2 The Perfect Stall 完美的牛栏 stall4
这是一种用增广路求二分图最大匹配的算法。
它由匈牙利数学家Edmonds于1965年提出，因而得名。
定义未盖点：设Vi是图G的一个顶点，如果Vi 不与任意一条属于匹配M的边相关联，就称Vi 是一个未盖点。
交错路：设P是图G的一条路，如果P的任意两条相邻的边一定是一条属于M而另一条不属于M，就称P是一条交错路。
可增广路：两个端点都是未盖点的交错路叫做可增广路。
流程图
伪代码：?
演示。