二分图(匈牙利,KM算法详解)

匈⽛利算法解决⼆分图最⼤匹配预备知识 匈⽛利算法是由匈⽛利数学家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个剩⼥，每个⼈都可能对多名异性有好感（惊讶，-_-||暂时不考虑特殊的性取向） 如果⼀对男⼥互有好感，那么你就可以把这⼀对撮合在⼀起，现在让我们⽆视掉所有的单相思（好忧伤的感觉，快哭了），你拥有的⼤概就是下⾯这样⼀张关系图，每⼀条连线都表⽰互有好感。

前言：高中时候老师讲这个就听得迷迷糊糊，有一晚花了通宵看KM的Pascal代码，大概知道过程了，后来老师说不是重点，所以忘的差不多了。

都知道二分图匹配是个难点，我这周花了些时间研究了一下这两个算法，总结一下1.基本概念M代表匹配集合未盖点：不与任何一条属于M的边相连的点交错轨：属于M的边与不属于M的边交替出现的轨（链）可增广轨：两端点是未盖点的交错轨判断M是最大匹配的标准：M中不存在可增广轨2.最大匹配，匈牙利算法时间复杂度：O(|V||E|)原理：寻找M的可增广轨P，P包含2k+1条边，其中k条属于M，k+1条不属于M。

修改M 为M&P。

即这条轨进行与M进行对称差分运算。

所谓对称差分运算，就是比如X和Y都是集合，X&Y=(X并Y)-(x交Y)有一个定理是：M&P的边数是|M|+1，因此对称差分运算扩大了M实现：关于这个实现，有DFS和BFS两种方法。

先列出DFS的代码，带注释。

这段代码来自中山大学的教材核心部分在dfs(x)，来寻找可增广轨。

如果找到的话，在Hungarian()中，最大匹配数加一。

这是用了刚才提到的定理。

大家可以想想初始状态是什么，又是如何变化的view plaincopy to clipboardprint?第二种方法BFS，来自我的学长cnhawk核心步骤还是寻找可增广链，过程是：1.从左的一个未匹配点开始，把所有她相连的点加入队列2.如果在右边找到一个未匹配点，则找到可增广链3.如果在右边找到的是一个匹配的点，则看它是从左边哪个点匹配而来的，将那个点出发的所有右边点加入队列这么说还是不容易明白，看代码吧view plaincopy to clipboardprint?3.最佳匹配加权图中，权值最大的最大匹配KM算法：概念：f(v)是每个点的一个值，使得对任意u,v C V，f(u)+f(v)>=w[e u,v]集合H：一个边集，使得H中所有u,v满足f(u)+f(v)=w[e u,v]等价子图：G f(V,H)，标有f函数的G图理论：对于f和G f，如果有一个理想匹配集合M p，则M p最优。

⼆分图匹配--匈⽛利算法⼆分图匹配--匈⽛利算法⼆分图匹配匈⽛利算法基本定义：⼆分图 —— 对于⽆向图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)匈⽛利树匈⽛利树中从根节点到叶节点的路径均是交替路，且匈⽛利树的叶节点都是匹配点。

匈牙利匹配算法的原理匈牙利匹配算法（也被称为二分图匹配算法或者Kuhn-Munkres算法）是用于解决二分图最大匹配问题的经典算法。

该算法由匈牙利数学家Dénes Kőnig于1931年提出，并由James Munkres在1957年进行改进。

该算法的时间复杂度为O(V^3)，其中V是图的顶点数。

匹配问题定义：给定一个二分图G=(X,Y,E)，X和Y分别代表两个不相交的顶点集合，E表示连接X和Y的边集合。

图中的匹配是指一个边的集合M，其中任意两条边没有公共的顶点。

匹配的相关概念：1.可增广路径：在一个匹配中找到一条没有被占用的边，通过这条边可以将匹配中的边个数增加一个，即将不在匹配中的边添加进去。

2. 增广路径：一个可增广路径是一个交替序列P=v0e1v1e2v2...ekvk，其中v0属于X且不在匹配中，v1v2...vk属于Y且在匹配中，e1e2...ek在原图中的边。

3.增广轨：一个交替序列形如V0E1V1E2...EkVk，其中V0属于X且不在匹配中，V1V2...Vk属于Y且在匹配中，E1E2...Ek在原图中的边。

增广轨是一条路径的特例，它是一条从X到Y的交替序列。

1.初始时，所有的边都不在匹配中。

2.在X中选择一个点v0，如果v0已经在匹配中，则找到与v0相连的在Y中的顶点v1、如果v1不在匹配中，则(v0,v1)是可增广路径的第一条边。

3. 如果v1在匹配中，则找到与v1相连的在X中的顶点v2，判断v2是否在匹配中。

依此类推，直到找到一个不在匹配中的点vn。

4.此时，如果n是奇数，则(n-1)条边在匹配中，这意味着我们找到了一条增广路径。

如果n是偶数，则(n-1)条边在匹配中，需要进行进一步的处理。

5.如果n是偶数，则将匹配中的边和非匹配中的边进行颠倒，得到一个新的匹配。

6.对于颠倒后的匹配，我们再次从第2步开始，继续寻找增广路径。

7.重复步骤2到步骤6，直到找不到可增广路径为止，此时我们得到了最大匹配。

⼆分图的最⼤匹配—匈⽛利算法【基本概念】：⼆分图：⼆分图⼆分图⼜称作⼆部图，是图论中的⼀种特殊模型。

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

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

最⼤匹配最⼤匹配：给定⼀个⼆分图G，在G的⼀个⼦图M中，M的边集中的任意两条边都不依附于同⼀个顶点，则称M是⼀个匹配. 选择这样的边数最⼤的⼦集称为图的最⼤匹配问题，如果⼀个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配.最⼩覆盖：最⼩覆盖要求⽤最少的点（Ｘ集合或Ｙ集合的都⾏）让每条边都⾄少和其中⼀个点关联。

可以证明：最少的点（即覆盖数）＝最⼤匹配数最⼩路径覆盖：⽤尽量少的不相交简单路径覆盖有向⽆环图Ｇ的所有结点。

解决此类问题可以建⽴⼀个⼆分图模型。

把所有顶点i拆成两个：Ｘ结点集中的i 和Y结点集中的i',如果有边i->j，则在⼆分图中引⼊边i->j'，设⼆分图最⼤匹配为m,则结果就是n-m。

增⼴路（增⼴轨）：（增⼴轨）：增⼴路若P是图G中⼀条连通两个未匹配顶点的路径，并且属于M的边和不属于M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的⼀条增⼴路径（举例来说，有A、B集合，增⼴路由A中⼀个点通向B中⼀个点，再由B中这个点通向A中⼀个点……交替进⾏）。

增⼴路径的性质：1 有奇数条边。

2 起点在⼆分图的左半边，终点在右半边。

3 路径上的点⼀定是⼀个在左半边，⼀个在右半边，交替出现。

（其实⼆分图的性质就决定了这⼀点，因为⼆分图同⼀边的点之间没有边相连，不要忘记哦。

）4 整条路径上没有重复的点。

5 起点和终点都是⽬前还没有配对的点，⽽其它所有点都是已经配好对的。

二分图的最优匹配（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时，就是最大完备匹配问题）解二分图最优匹配问题可用穷举的方法，但穷举的效率=n！，所以我们需要更加优秀的算法。

先说一个定理：设M是一个带权完全二分图G的一个完备匹配，给每个顶点一个可行顶标(第i个x顶点的可行标用lx[i]表示，第j个y顶点的可行标用ly[j]表示)，如果对所有的边(i,j) in G,都有lx[i]+ly[j]>=w[i,j]成立(w[i,j]表示边的权)，且对所有的边(i,j) in M,都有lx[i]+ly[j]=w[i,j]成立，则M是图G的一个最优匹配。

Kuhn－Munkras算法（即KM算法）流程：v(1)初始化可行顶标的值v(2)用匈牙利算法寻找完备匹配v(3)若未找到完备匹配则修改可行顶标的值v(4)重复(2)(3)直到找到相等子图的完备匹配为止KM算法主要就是控制怎样修改可行顶标的策略使得最终可以达到一个完美匹配，首先任意设置可行顶标（如每个X节点的可行顶标设为它出发的所有弧的最大权，Y节点的可行顶标设为0），然后在相等子图中寻找增广路，找到增广路就沿着增广路增广。

而如果没有找到增广路呢，那么就考虑所有现在在匈牙利树中的X节点（记为S集合），所有现在在匈牙利树中的Y节点（记为T 集合），考察所有一段在S集合，一段在not T集合中的弧，取delta = min {l(xi)+l(yj)-w(xi,yj) , | xi in S, yj in not T} 。

明显的，当我们把所有S集合中的l(xi)减少delta之后，一定会有至少一条属于(S, not T)的边进入相等子图，进而可以继续扩展匈牙利树，为了保证原来属于(S,T )的边不退出相等子图，把所有在T 集合中的点的可行顶标增加delta。

随后匈牙利树继续扩展，如果新加入匈牙利树的Y节点是未盖点，那么找到增广路，否则把该节点的对应的X匹配点加入匈牙利树继续尝试增广。

KM算法详解+模板解析KM算法用来求二分图最大权完美匹配。

本文配合【导师实操追-女视频】该博文服用更佳：趣写算法系列之--匈牙利算法本文没有【扣扣】给出KM算法的原理，只是模拟了一遍算法的过程。

另【⒈】，博主水平较差，发现问题欢迎指出，谢谢！！！！现在有N【０】男N女，有些男生和女生之间互相有好感，我们将其好感【１】程度定义为好感度，我们希望把他们两两配对，并且最后希【б】望好感度和最大。

怎么选择【９】最优的配对方法呢？首先，每【⒌】个女生会有一个期望值，就是与她有好感度的男生中最【２】大的好感度。

男生呢，期望值为0，就是……只要有一个妹子【６】就可以啦，不挑~~这样，我们把每个人的期望值标出来。

接下来，开始配对。

配对方法：我们从第一个女生开始，分别为每一个女生找对象。

每次都从第一个男生开始，选择一个男生，使男女两人的期望和要等于两人之间的好感度。

注意：每一轮匹配，每个男生只会被尝试匹配一次！具体匹配过程：==============为女1找对象===============（此时无人配对成功）根据“男女两人的期望和要等于两人之间的好感度”的规则女1-男1：4+0 != 3女1-男3：4+0 == 4所以女1选择了男3女1找对象成功==============为女1找对象成功==========================为女2找对象===============（此时女1—男3）根据配对原则，女2选择男3男3有主女1，女1尝试换人我们尝试让女1去找别人尝试失败为女2找对象失败！==============为女2找对象失败============这一轮参与匹配的人有：女1，女2，男3。

怎么办？？？很容易想到的，这两个女生只能降低一下期望值了，降低多少呢？比如：女1选择男1，期望值要降低1。

女2选择男1，期望值要降低1。

女2选择男2，期望值要降低2。

于是，只要期望值降低1，就有妹子可能选择其他人。

匈⽛利算法（⼆分图）---------------------------------------------------------------------题材⼤多来⾃⽹络，本篇由神犇整理基本概念—⼆分图⼆分图：是图论中的⼀种特殊模型。

若能将⽆向图G=(V,E)的顶点V划分为两个交集为空的顶点集，并且任意边的两个端点都分属于两个集合，则称图G为⼀个为⼆分图。

匹配：⼀个匹配即⼀个包含若⼲条边的集合，且其中任意两条边没有公共端点。

如下图，图3的红边即为图2的⼀个匹配。

1 最⼤匹配在G的⼀个⼦图M中，M的边集中的任意两条边都不依附于同⼀个顶点，则称M是⼀个匹配。

选择这样的边数最⼤的⼦集称为图的最⼤匹配问题,最⼤匹配的边数称为最⼤匹配数.如果⼀个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。

如果在左右两边加上源汇点后，图G等价于⼀个⽹络流，最⼤匹配问题可以转为最⼤流的问题。

解决此问的匈⽛利算法的本质就是寻找最⼤流的增⼴路径。

上图中的最⼤匹配如下图红边所⽰：2 最优匹配最优匹配⼜称为带权最⼤匹配，是指在带有权值边的⼆分图中，求⼀个匹配使得匹配边上的权值和最⼤。

⼀般X和Y集合顶点个数相同，最优匹配也是⼀个完备匹配，即每个顶点都被匹配。

如果个数不相等，可以通过补点加0边实现转化。

⼀般使⽤KM算法解决该问题。

3 最⼩覆盖⼆分图的最⼩覆盖分为最⼩顶点覆盖和最⼩路径覆盖：①最⼩顶点覆盖是指最少的顶点数使得⼆分图G中的每条边都⾄少与其中⼀个点相关联，⼆分图的最⼩顶点覆盖数=⼆分图的最⼤匹配数；②最⼩路径覆盖也称为最⼩边覆盖，是指⽤尽量少的不相交简单路径覆盖⼆分图中的所有顶点。

⼆分图的最⼩路径覆盖数=|V|-⼆分图的最⼤匹配数；4 最⼤独⽴集最⼤独⽴集是指寻找⼀个点集，使得其中任意两点在图中⽆对应边。

对于⼀般图来说，最⼤独⽴集是⼀个NP完全问题，对于⼆分图来说最⼤独⽴集=|V|-⼆分图的最⼤匹配数。

⼆分图匹配算法（最⼤流匈⽛利）⼆分图匹配相关概念⽆向⼆分图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%。

km(kuhn-munkres)算法的具体表达KM算法，即Kuhn-Munkres算法（又称为匈牙利算法），是一种用于求解二分图最大权匹配问题的经典算法。

它由Eugene L. Lawler于1960年首次提出，后来由James Munkres在1957年独立发表，因此常称为Kuhn-Munkres算法。

二分图最大权匹配问题是指给定一个带权二分图，要求在图中选取权重之和最大的边集合，使得任意两条边不属于同一个顶点。

其中，带权二分图是指图的每条边都带有一个非负权重。

KM算法使用了两个关键的概念：交错树和相等子图。

交错树是指一个T=（S，P）的有向树，其中S是原二分图的所有顶点的集合，P是树中的边集合。

相等子图是指原二分图的一个子图，其中T中所有入树边的权重之和等于所有出树边的权重之和。

KM算法具体的步骤如下：1.初始化：将图中所有边的权重初始化为0，构建了一个初始的交错树T=（X，Y）（其中X，Y分别表示两个顶点集合）。

2.判断相等子图：对于T中的每个顶点x，如果存在一条满足lx+ly=W（其中lx是x在T中所有入树边的权重之和，ly是x在T中所有出树边的权重之和，W是x在原图G中的权重），则把x加入到相等子图中。

3.寻找未匹配节点：在相等子图中寻找未匹配节点，并标记为未父节点。

4.寻找增广路：如果存在未匹配节点，则从中选择一个起始节点，寻找一条与之交替出现的边构成的路径，使路径的最后一个边是一条与未匹配节点关联的边。

这样的路径称为增广路。

5.修改标号：对于相等子图中的每个顶点x，从已匹配节点中选择一个与之关联的顶点y，并计算d=min(lx+ly-w)（其中w是x和y之间的边的权重），为了使增广路更优，将T中所有x节点的入树边的权重减去d，将T中所有y节点的出树边的权重加上d。

6.更新交错树：将增广路中的所有边和T中的所有非树边进行调整，得到新的交错树。

7.重复步骤3-6，直到没有未匹配节点为止。

KM算法详解（例题为HDU2255 带权二分图的最优匹配）：希望你在阅读此篇博客时，你已经学会了匈牙利算法，这样会对你更有帮助哦！！！！！对于KM算法自己的通俗理解与代码详解：注：KM算法：就是在匈牙利基础上加了权值的束缚！那么，为了达到权值和最大，或者最小，就不能简单的去算最多的边数。

步骤：（以HDU2255 例题为例）1.首先要找到所有居民愿意花钱最多的那个房子。

题目中用到lx,ly数组，是为了同时调节两个数组，使得权值和最大。

或者说当要松弛的时候使得本来最大的矛盾权值和尽可能的损失小一些来得到满足条件的最大权值和！2.（lx[x]+ly[y]-w[x][y]=0）条件下进行匈牙利算法。

lx[x]+ly[y]-w[x][y]这个条件十分巧妙:（算法精髓）1.即可以只让指定居民找到它愿意付最多钱的房子。

2.又可以在发生多居民抢一个房子时，用它来得到该居民到其它房子的松弛量！（即该居民到其它房子比到这个用钱最多的房子愿意花的钱数上差的值。

）那么我们就要把发生矛盾的居民到其它房子的松弛量的最小值求出来。

再用它去松弛，就可以让原本矛盾的最大权值和，损失最小而得到满足条件的最大权值和对于每个居民有4个基本问题：1.这个房子访问过没有？2.这个房子能不能满足他的条件3.这个房子是否被别人住了4.被别人住了能不能得到调配代码如下：#include iostream#includecstdio#includecstringusing namespace std;#define MAX 310#define INF 125#define clr(x) memset(x,0,sizeof(x))int w[MAX][MAX];int lx[MAX],ly[MAX]; -***lx[i]初始化为A集合中 i 点能到B集合某一点的最大权值, ly[i] 初始化0;***-int link[MAX];int slack[MAX];int visx[MAX],visy[MAX];bool find(int x)visx[x]=1; -****得到发生矛盾的居民集合****-for(int y=1;y=n;y++) -**这个居民，每个房子都去试一试!(找到就退出)**-if(visy[y]) -****一个房子不需要重复访问****-continue;int t=lx[x]+ly[y]-w[x][y];-****按这个标准去用-匈牙利算法***- if(t==0) -**t==0标志这个房子可以给这位居民**-visy[y]=1;if(link[y]==0||find(link[y])) -****这房子没人住或可以让住这个房子的人去找另外的房子住****-link[y]=x;return true; -**那么就可以让这位居民住进来**-else if(slack[y]t) -**否则这个房子不能给这位居民！**-slack[y]=t; -***就要找到这个房子要松弛多少才能够给这位居民***--***且当有多个居民都对这个房子有松弛量时，要找到最小的。

最大权匹配KM算法KM 算法（Kuhn–Munkres 算法）又被称为匈牙利算法或者二分图最佳匹配算法，是用来解决二分图最大权匹配问题的一种有效算法。

它的时间复杂度为 O(n^3)，其中 n 是二分图中的顶点数。

在二分图最大权匹配问题中，给定一个二分图，找到一种边的匹配方式，使得所有边的权重之和达到最大。

其中，二分图是一种图，其顶点可以分为两个不相交的集合U和V，并且图中的每条边都连接U和V中的两个顶点之一KM 算法的主要思想是通过设置两个顶标数组 lx 和 ly 来记录每个顶点的可行匹配权值。

算法的基本步骤如下：1. 初始化顶标数组 lx 和 ly 为 0。

2. 对于每个顶点 u 属于集合 U，找出 u 在集合 V 中的邻接顶点 v，计算顶点 u 和 v 之间的权值与当前顶标数组的差值 delta，如果 delta 大于顶点 v 的顶标，则更新顶标 lx[u] 为 delta。

3.从集合U中选择一个顶点u，对于该顶点u在集合V中的每个邻接顶点v，如果u和v当前没有匹配，则尝试将u和v进行匹配，并将顶点u标记为已匹配。

4. 如果存在未匹配的顶点，则尝试改变标号以寻找更大的匹配权重。

具体操作是分别减小顶标 lx[u] 和增加顶标 ly[v]，保持所有匹配的边不变。

5.重复步骤2-4，直到无法找到更大权重的匹配。

KM 算法的关键在于通过改变顶标数组 lx 和 ly，以及不断改变已匹配的顶点来寻找更大的权重匹配。

当顶标数组不再改变时，即找到了最大权匹配。

需要注意的是，KM算法只能解决二分图的最大权匹配，如果给定的图不是二分图，需要先进行二分图的判定。

此外，KM算法也可以用来解决最小权匹配问题，只需要将边的权重取相反数即可。

总结来说，KM算法通过设置顶标数组和不断改变匹配的顶点来寻找二分图的最大权匹配。

它是一种时间复杂度较低、效率较高的算法，有着广泛的应用场景，例如任务分配、资源分配等问题。

⼆分图匹配之最佳匹配——KM算法今天也⼤致学了下KM算法，⽤于求⼆分图匹配的最佳匹配。

何为最佳？我们能⽤匈⽛利算法对⼆分图进⾏最⼤匹配，但匹配的⽅式不唯⼀，如果我们假设每条边有权值，那么⼀定会存在⼀个最⼤权值的匹配情况，但对于KM算法的话这个情况有点特殊，这个匹配情况是要在完全匹配（就是各个点都能⼀⼀对应另⼀个点）情况下的前提。

⾃然，KM算法跟匈⽛利算法有相似之处。

其算法步骤如下：1.⽤邻接矩阵（或其他⽅法也⾏啦）来储存图，注意：如果只是想求最⼤权值匹配⽽不要求是完全匹配的话，请把各个不相连的边的权值设置为0。

2.运⽤贪⼼算法初始化标杆。

3.运⽤匈⽛利算法找到完备匹配。

4.如果找不到，则通过修改标杆，增加⼀些边。

5.重复3，4的步骤，直到完全匹配时可结束。

⼀⾔不合地冒出了个标杆？？标杆是什么？？？在解释这个问题之前，我们先来假设⼀个很简单的情况，⽤我们⼈类伟⼤的智能思维去思考思考。

如上的⼀个⼆分图，我们要求它的最⼤权值匹配（最佳匹配）我们可以思索思索⼆分图最佳匹配还是⼆分图匹配，所以跟和匈⽛利算法思路差不多⼆分图是特殊的⽹络流，最佳匹配相当于求最⼤（⼩）费⽤最⼤流，所以FF⽅法也能实现所以我们可以把这匈⽛利算法和FF⽅法结合起来FF⽅法⾥⾯，我们每次是找最长（短）路进⾏通流所以⼆分图匹配⾥⾯我们也找最⼤边进⾏连边!但是遇到某个点被匹配了两次怎么办？那就⽤匈⽛利算法进⾏更改匹配！这就是KM算法的思路了：尽量找最⼤的边进⾏连边，如果不能则换⼀条较⼤的。

所以，根据KM算法的思路，我们⼀开始要对边权值最⼤的进⾏连线，那问题就来了，我们如何让计算机知道该点对应的权值最⼤的边是哪⼀条？或许我们可以通过某种⽅式记录边的另⼀端点，但是呢，后⾯还要涉及改边，⼜要记录边权值总和，⽽这个记录端点⽅法似乎有点⿇烦，于是KM采⽤了⼀种⼗分巧妙的办法（也是KM算法思想的精髓）：添加标杆（顶标）是怎样⼦呢？我们对左边每个点Xi和右边每个点Yi添加标杆Cx和Cy。

二分图最大权匹配 KM算法KM算法的正确性基于以下定理：若由二分图中所有满足A[i]+B[i]=w[i][j]的边C（i，j）构成的子图（即相等子图）有完备匹配，那么这个完备匹配就是二分图的最大权匹配基本概念1.完备匹配设G=V1,V2,E为二分图，|V1|=|V2|,M为G中的一个最大匹配，且|M|=V1,则称M为V1到V2的完备匹配。

通俗的理解，就是把V1中所有的点都匹配完2.可行顶标对于左边的点设为LX[maxn]数组，右边的点设为LY[maxn]数组，w[i][j]表示 v[i] 到 v[j] 的权值3.相等子图相等子图为完备匹配中所有的匹配，即全部V1中的点和与V1中的点匹配的V2中的点，但是边只包含 LX[i]+LY[j]=W[i][j]的边4.最优完备匹配最优完备匹配就是在完备匹配的条件下求解权值最大或者最小，若由二分图中所有满足A[i]+B[i]=W[i][j]的边C（i，j）构成的相等子图有完备匹配，那么这个完备匹配就是二分图的最大权匹配因为对于二分图的任意一个匹配，如果它包含相等子图，那么它的边权和等于所有顶点的顶标和；如果它有边不包含于相等子图，那么它的边权和小于所有顶点的顶标和，所以相等子图的完备匹配，一定是二分图的最大权匹配。

5.交错树对V1中的一个顶点进行匹配的时候，所标记过的V1，V2中的点以及连线，形成一个树状的图KM算法原理1.基本原理该算法是通过给每个顶点一个标号(叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题。

设顶点V1的顶标lx[i]，V2顶点的顶标为LY[j],顶点V1的i与V2的j之间的边权为V(i,j)。

在算法执行的过程中，对于任一条边C(i,j)，LX[i]+LY[i]=V[i,j]始终成立2.基本流程（1）初始化时为了使 LX[i] + LY[j] = V [i,j]恒成立，将V1的点的标号记为与其相连的最大边权值，V2的点标号记为0 （2）用匈牙利算法在相等子图寻找完备匹配（3）若未找到完备匹配，则修改可行顶标的值，扩充相等子图（4）重复（2）（3）直到找到相等子图的完备匹配为止3.这里值得注意的是找完备匹配不难理解，主要是进行可行顶标的修改扩充相等子图朴素的实现方法：时间复杂度为O(n4)——需要找O(n)次增广路，每次增广最多需要修改O(n)次顶标，每次修改顶标时由于要枚举边来求d值，复杂度为O(n2)。