二分图最大匹配
Ku二分图最大权匹配(KM算法)hn
Maigo的KM算法讲解(的确精彩)顶点Ｙｉ的顶标为B［i]，顶点Xi与Yj之间的边权为w[ｉ,j]。
在算法执行过程中的任一时刻，对于任一条边(ｉ,j),A［i]+B[j]>=w［i,ｊ]始终成立。
KM 算法的正确性基于以下定理：* 若由二分图中所有满足A［i］+B[j]=ｗ[ｉ,ｊ］的边（i，ｊ)构成的子图（称做相等子图）有完备匹配,那么这个完备匹配就是二分图的最大权匹配。
这个定理是显然的。
因为对于二分图的任意一个匹配，如果它包含于相等子图,那么它的边权和等于所有顶点的顶标和；如果它有的边不包含于相等子图,那么它的边权和小于所有顶点的顶标和。
所以相等子图的完备匹配一定是二分图的最大权匹配。
初始时为了使A［ｉ]＋B[j]>=w[i,j]恒成立,令A[i]为所有与顶点Xi关联的边的最大权，Ｂ[ｊ］＝0。
如果当前的相等子图没有完备匹配,就按下面的方法修改顶标以使扩大相等子图，直到相等子图具有完备匹配为止。
我们求当前相等子图的完备匹配失败了,是因为对于某个Ｘ顶点,我们找不到一条从它出发的交错路。
这时我们获得了一棵交错树,它的叶子结点全部是X顶点。
现在我们把交错树中X顶点的顶标全都减小某个值ｄ,Y顶点的顶标全都增加同一个值d，那么我们会发现：两端都在交错树中的边(i，j）,A［i]+B[j]的值没有变化。
也就是说,它原来属于相等子图，现在仍属于相等子图。
两端都不在交错树中的边(ｉ，ｊ)，A[i］和B[j]都没有变化。
也就是说,它原来属于(或不属于)相等子图，现在仍属于(或不属于)相等子图。
X端不在交错树中，Y端在交错树中的边(i，ｊ)，它的Ａ［ｉ]+B[j]的值有所增大。
它原来不属于相等子图,现在仍不属于相等子图。
X端在交错树中,Ｙ端不在交错树中的边（i,j),它的A［ｉ]+B[j]的值有所减小。
也就说,它原来不属于相等子图，现在可能进入了相等子图,因而使相等子图得到了扩大。
现在的问题就是求d值了。
二分图匹配(匈牙利算法)
设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; //路径取反操作。
二分图相关问题
X X S X X
X X X X
X代表攻击范围，S代表骑 士
分析
对棋盘染色，设方格的坐标为(x,y)，x和y同奇 偶的方格对应X集合，不同奇偶的对应Y集合。 由于骑士沿着“日”字形路线攻击，所以每个 攻击肯定是处于X集合和Y集合之间，而不可 能在两个集合内部。 显然，转化后变为求二分图的最大独立集
匈牙利算法
简要说明：find函数用于判断从k点开始是否能 够找到一条交错路。对于每个可以与k匹配的 顶点j，假如它未被匹配，交错路就已经找到； 假如j已与某顶点x匹配，那么只需调用find(x) 来求证x是否可以与其它顶点匹配，如果返回 true的话，仍可以使j与k匹配；这就是一次 DFS。每次DFS时，要标记访问到的顶点 （cover[j]=true），以防死循环和重复计算。
例题分析
Hanoi Tower Troubles Again! (OIBH Contest)
ZOJ 1239 题目大意：给定柱子数N，按编号从小到大放球， 要求：如果该球不在最底数，则该球和它下面一个 球的编号之和必须为完全平方数。 问对于给定的N，最多能放多少球上去。 N<=50
例题分析
分析
铺放方法
1.2. .333 444. ..2.
Sample Output 4
分析
最小覆盖是覆盖所有的边，因此泥地对应边 建图方式类似于皇家卫士，也是利用行连通块 和列连通块做点，单位泥地对应二分图中的边 要求放最少的板覆盖全部的泥地，转化为求最 小覆盖
二分图最大独立集
图的独立集：寻找一个点集，其中任意两点在 图中无对应边 一般图的最大独立集是NP完全问题 二分图的最大独立集=图的点数-最大匹配数
二分图最小覆盖
图的覆盖：寻找一个点集，使得图中每一条边 至少有一点在该点集中
最大权匹配KM算法
最大权匹配KM算法
KM算法（Kuhn–Munkres算法，也称为匈牙利算法）是由Kuhn于
1955年和Munkres于1957年分别提出的，用于解决二分图最大匹配问题。
该算法的核心思想是基于匈牙利算法的增广路径，通过构建一个增广路径
来不断更新匹配，直到无法找到增广路径为止。
算法流程如下：
2.从G的每个未匹配顶点开始，通过增广路径将其标记为可增广点；
3.当存在增广路径时，将匹配的边进行反向操作，直到不存在增广路径；
4. 利用增广路径的反向操作可以修改lx和ly的值，使其满足特定
约束条件；
5.通过相等子图的扩展来实现增广路径的；
6.重复步骤3-5，直到不存在更多的增广路径；
7.返回找到的最大匹配。
具体实现时，对于增广路径的可以利用DFS或BFS等方法进行，当找
到一个增广路径时，通过反向操作修改匹配情况，并更新lx和ly的值。
同时，算法还可以使用增广路径来调整优化标号，以减少匹配时间。
KM算法是一种高效的解决最大权匹配问题的方法，其时间复杂度为
O(V^3)，其中V为图的顶点数。
算法的核心思想是利用二分图中的相等子
图来查找增广路径，并通过修改顶点的标号来实现最大匹配。
总之，最大权匹配KM算法是一个解决带权无向二分图最大匹配问题
的高效算法，通过不断寻找增广路径并调整顶点的标号来实现最大权匹配。
它的思想简单而有效，可以广泛应用于各种实际问题中。
二分图匹配
二分图匹配一、二分图的概念二分图又称作二部图，是图论中的一种特殊模型。
设G=(V,{R})是一个无向图。
如顶点集V可分割为两个互不相交的子集，并且图中每条边依附的两个顶点都分属两个不同的子集。
则称图G为二分图。
二、最大匹配给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。
选择这样的边数最大的子集称为图的最大匹配问题(maximal matching problem)如果一个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。
三、匈牙利算法求最大匹配的一种显而易见的算法是：先找出全部匹配，然后保留匹配数最多的。
但是这个算法的复杂度为边数的指数级函数。
因此，需要寻求一种更加高效的算法。
1、增广路的定义(也称增广轨或交错轨)：若P是图G中一条连通两个未匹配顶点的路径，并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径。
由增广路的定义可以推出下述三个结论：●P的路径长度必定为奇数，第一条边和最后一条边都不属于M。
●P经过取反操作可以得到一个更大的匹配M’。
●M为G的最大匹配当且仅当不存在相对于M的增广路径。
2、用增广路求最大匹配(称作匈牙利算法，匈牙利数学家Edmonds于1965年提出)。
算法轮廓：(1)置M为空(2)找出一条增广路径P，通过取反操作获得更大的匹配M’代替M(3)重复(2)操作直到找不出增广路径为止程序清单：Function find(k:integer):integer;var st,sf,i,j,t:integer;queue,father:array[1..100] of integer;beginqueue[1] := k; st := 1; sf := 1;fillchar(father,sizeof(father),0);repeatfor i:=1 to n doif (father[i]=0)and(a[queue[st],i]=1) thenbeginif match2[i]<>0 thenbegininc(sf);queue[sf] := match2[i];father[i] := queue[st];end elsebeginj := queue[st];while true dobegint := match1[j];match1[j] := i;match2[i] := j;if t = 0 then break;i := t; j := father[t];end;find := 1;exit;end;end;inc(st);until st>sf;find := 0;end;在主程序中调用下面的程序即可得出最大匹配数。
匈牙利匹配算法的原理
匈牙利匹配算法的原理匈牙利匹配算法（也被称为二分图匹配算法或者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，直到找不到可增广路径为止，此时我们得到了最大匹配。
最大二分图匹配（匈牙利算法）
最大二分图匹配（匈牙利算法）二分图指的是这样一种图：其所有的顶点分成两个集合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);}}。
konig 定理
konig 定理
Konig定理是图论中的一个重要定理，它是由匈牙利数学家Dénes Konig在1936年首次证明的。
这个定理主要应用于二分图（bipartite graph）的研究中，二分图是一种特殊的图，其中所有的顶点都可以被分成两个互不相交的子集，并且每一条边都连接这两个子集中的一个顶点。
Konig定理的表述如下：在一个二分图中，最大匹配数等于最小点覆盖数。
换句话说，一个图中的最大匹配数等于覆盖该图中所有顶点所需的最小边数。
为了更好地理解这个定理，我们可以先了解一下什么是匹配和点覆盖。
在图论中，一个匹配是一个边的集合，其中任意两条边都不共享一个顶点。
最大匹配是指一个匹配中包含的边数最多。
点覆盖是指一个顶点的集合，该集合中的任意顶点都是边的一个端点。
最小点覆盖是指覆盖所有顶点所需的最小顶点数。
根据Konig定理，在二分图中，最大匹配数等于最小点覆盖数。
这个定理的证明过程需要使用到一些图论中的技巧和结论，例如Kőnig-Egerváry定理和Hall定理等。
这个定理的应用非常广泛，它可以用于解决一些组合优化问题，例如最大匹配问题和最小点覆盖问题等。
此外，Konig定理还可以用于证明一些其他图论中的结论，例如Kőnig-Egerváry定理和Hall定理等。
二分图最大匹配及常用建图方法
算法———艺术二分图匹配剖析很多人说，算法是一种艺术。
但是对于初学者的我，对算法认识不是很深刻，但偶尔也能感受到他强大的魅力与活力。
这让我追求算法的脚步不能停止。
下面我通过分析匈牙利算法以及常用建图方式，与大家一起欣赏算法的美。
匈牙利算法匈牙利算法是用来解决最大二分图匹配问题的，所谓二分图即“一组点集可以分为两部分，且每部分内各点互不相连，两部分的点之间可以有边”。
所谓最大二分图匹配即”对于二分图的所有边，寻找一个子集，这个子集满足两个条件，1：任意两条边都不依赖于同一个点。
2：让这个子集里的边在满足条件一的情况下尽量多。
首先可以想到的是，我们可以通过搜索，找出所有的这样的满足上面条件的边集，然后从所有的边集中选出边数最多的那个集合，但是我们可以感觉到这个算法的时间复杂度是边数的指数级函数，因此我们有必要寻找更加高效的方法。
目前比较有效的方法有匈牙利算法和通过添加汇点和源点的网络流算法，对于点的个数都在200 到300 之间的数据，我们是采取匈牙利算法的，因为匈牙利算法实现起来要比网络流简单些。
下面具体说说匈牙利算法：介绍匈牙利之前，先说说“增广轨”。
定义：若P是图G中一条连通两个未匹配顶点的路径，并且属最大匹配边集M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广轨定义总是抽象的下面通过图来理解它。
图中的线段（2->3, 3->1, 1->4）便是上面所说的p路径，我们假定边（1,3）是以匹配的边，（2,3）（1,4）是未匹配的边，则边（4,1）边（1,3）和边（3,2）在路径p上交替的出现啦，那么p就是相对于M的一条增广轨，这样我们就可以用边1,4 和边2,3来替换边1,3 那么以匹配的边集数量就可以加1,。
匈牙利算法就是同过不断的寻找增广轨实现的。
很明显如果二分图的两部分点分别为n 和m，那么最大匹配的数目应该小于等于MIN（n,m）; 因此我们可以枚举任第一部分（的二部分也可以）里的每一个点，我们从每个点出发寻找增广轨，最后吧第一部分的点找完以后，就找到了最大匹配的数目，当然我们也可以通过记录找出这些边。
[hdu1533]二分图最大权匹配最小费用最大流
![[hdu1533]二分图最大权匹配最小费用最大流](https://img.taocdn.com/s3/m/306f8633bdd126fff705cc1755270722192e59a0.png)
[hdu1533]⼆分图最⼤权匹配最⼩费⽤最⼤流题意：给⼀个n*m的地图，'m'表⽰⼈，'H'表⽰房⼦，求所有⼈都回到房⼦所⾛的距离之和的最⼩值（距离为曼哈顿距离）。
思路：⽐较明显的⼆分图最⼤权匹配模型，将每个⼈向房⼦连⼀条边，边权为曼哈顿距离的相反数（由于是求最⼩，所以先取反后求最⼤，最后再取反回来即可），然后⽤KM算法跑⼀遍然后取反就是答案。
还可以⽤最⼩费⽤最⼤流做，⽅法是：从源点向每个⼈连⼀条边，容量为1，费⽤为0，从每个房⼦向汇点连⼀条边，容量为1，费⽤为0，从每个⼈向每个房⼦连⼀条边，容量为1，费⽤为曼哈顿距离的值，建好图后跑⼀遍最⼩费⽤最⼤流就是答案。
附上代码：（1）KM算法，40ms左右（2）最⼩费⽤最⼤流，400+ms（1）1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84/* ******************************************************************************** */#include <iostream> //#include <cstdio> //#include <cmath> //#include <cstdlib> //#include <cstring> //#include <vector> //#include <ctime> //#include <deque> //#include <queue> //#include <algorithm> //#include <map> //#include <cmath> //using namespace////#define pb push_back //#define mp make_pair //#define X first //#define Y second //#define all(a) (a).begin(), (a).end() //#define fillchar(a, x) memset(a, x, sizeof(a)) ////void int int for int scanf"%d"//void void int scanf"%d"template typename//void int void int int int//while scanf"%d"void template typename// void const template typename typename// void const const", "template typename//void int while", "////typedef int int//typedef long long//typedef long long////template typename bool const return false true// template typename bool const return false true// template typename//void const for int// template typename//void const for int////const double acos/////* -------------------------------------------------------------------------------- */structconst static intconst static intintintintintvoid int int intbool inttruefor intiftrueifreturn trueelse if//j属于B，且不在交错路径中return falseint int intthis thisintmemset sizeofmemset sizeofmemset sizeofforforforforwhile84858687888990919293949596979899 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135（2）12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849whilememset sizeofmemset sizeofif break//从i点出发找到交错路径则跳出循环for//取最⼩的slack[j]iffor//集合A中位于交错路径上的-diffor//集合B中位于交错路径上的+difelse//注意修改不在交错路径上的slack[j]intforif (~match[j])return//点从0开始编号intreturn abs absint#ifndef ONLINE_JUDGEfreopen"in.txt""r"#endif // ONLINE_JUDGEintwhilefor intcharscanf"%s"for intif'H'if'm'for intfor intreturn/* ******************************************************************************** *//* ******************************************************************************** */#include <iostream> //#include <cstdio> //#include <cmath> //#include <cstdlib> //#include <cstring> //#include <vector> //#include <ctime> //#include <deque> //#include <queue> //#include <algorithm> //#include <map> //#include <cmath> //using namespace////#define pb push_back //#define mp make_pair //#define X first //#define Y second //#define all(a) (a).begin(), (a).end() //#define fillchar(a, x) memset(a, x, sizeof(a)) ////void int int for int scanf"%d"//void void int scanf"%d"template typename//void int void int int int//while scanf"%d"void template typename// void const template typename typename// void const const", "template typename//void int while", "////typedef int int//typedef long long//typedef long long////template typename bool const return false true// template typename bool const return false true// template typename//void const for int// template typename//void const for int////const double acos/////* -------------------------------------------------------------------------------- */structconst static intconst static intstruct49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145structintint int int intintintintvoid intthisfor intvoid int int int intintbool int int int intfor intmemset sizeofintwhileintfor intififif return falseintwhilereturn trueint int intintwhilereturnintreturn abs absint#ifndef ONLINE_JUDGEfreopen"in.txt""r"#endif // ONLINE_JUDGEintwhilefor intcharscanf"%s"for intif'H'if'm'for intfor intfor intfor intreturn/* ******************************************************************************** */。
munkres函数
Munkres算法，也称为匈牙利算法，是一种用于解决二分图最大匹配问题的线性时间复杂度算法。
二分图最大匹配问题是在一个二分图中寻找最大的匹配，即找到最大的子集，使得图中的每条边都有一个与之匹配的顶点。
Munkres算法的基本思想是通过在原图中构造增广路径，并在增广路径上不断进行增广操作，最终得到最大匹配。
具体步骤如下：
1. 初始化：将所有未匹配的点标记为0，已匹配的点标记为无穷大。
2. 寻找增广路径：从任意一个未匹配的点开始，进行DFS或BFS 等搜索方法，直到找到一个增广路径。
增广路径是指从起点开始，沿着一条路径可以一直匹配到终点，但终点尚未匹配。
3. 进行增广操作：在增广路径上，将路径上的所有点与对应的未匹配点进行匹配，并将这些点标记为已匹配。
4. 重复步骤2和3，直到所有的点都已匹配或者找不到增广路径为止。
Munkres算法的时间复杂度为O(V^3)，其中V是顶点的数量。
这是因为在最坏的情况下，需要枚举所有可能的增广路径，而每条增广路径最多包含V个顶点。
因此，Munkres算法是一种非常高效的算法，被广泛应用于解决二分图最大匹配问题。
匈牙利算法详解
匈牙利算法详解
匈牙利算法是一种解决二分图最大匹配问题的经典算法，也叫做增广路算法。
它的基本思想是从左侧一端开始，依次匹配左侧点，直到无法添加匹配为止。
在匹配过程中，每次都通过BFS 寻找增广路径，即可以让已有的匹配变得更优或添加新的匹配。
增广路的长度必须为奇数，因为必须从未匹配的左侧点开始，交替经过已匹配的右侧点和未匹配的左侧点，最后再到达未匹配的右侧点。
当没有找到增广路径时，匹配结束。
匈牙利算法的具体实现可以使用DFS 或BFS，这里以BFS 为例。
算法步骤如下：
1. 从左侧一个未匹配的点开始，依次找增广路径。
如果找到，就将路径上的匹配状态翻转（即已匹配变未匹配，未匹配变已匹配），并继续找增广路径；如果找不到，就说明已经完成匹配。
2. 使用BFS 寻找增广路径。
从左侧的某个未匹配点开始，依次搜索路径中未匹配的右侧点。
如果找到右侧未匹配点，则说明找到了增广路径；否则，将已搜过的左侧点打上标记，以免重复搜索。
如果找到增广路径，就将路径的左侧和右侧点的匹配状态翻转。
3. 重复步骤1 和2，直到找不到增广路径为止。
匈牙利算法的时间复杂度为O(VE)，其中V 和E 分别为二分图中的左侧点数和右侧点数。
实际运行效率很高，可以处理百万级别的数据。
km算法原理
km算法原理KM算法原理：带权二分图最大权完美匹配KM算法全称为Kuhn-Munkres算法，是一种求解带权二分图最大权完美匹配的算法。
该算法的时间复杂度为O(n^3)，相较于暴力枚举的O(n!)和网络流的O(n^4)，其效率更高。
我们来了解一下什么是带权二分图。
带权二分图是指一个无向图G=(V, E)，其中V可以划分为两个集合X和Y，使得X和Y内部的点没有边相连，而X和Y之间的点有边相连，并且每条边都有一个权值。
我们的目标是找到X到Y的最大权匹配。
KM算法的思路是不断尝试寻找增广路，并将其加入当前匹配中。
增广路是指从未匹配的点开始，经过一系列已匹配的点，最终到达另一个未匹配的点的路径。
如果当前匹配中不存在增广路，那么我们就找到了最大权匹配。
具体实现时，我们需要使用两个数组：lx和ly。
lx[i]表示左边第i个点的最大权值，ly[j]表示右边第j个点的最大权值。
初始时，我们将lx[i]=max{w[i][j]}，其中w[i][j]表示左边第i个点到右边第j个点的边权值，ly[j]=0。
然后我们不断进行匹配，直到没有增广路为止。
匹配的过程中，我们需要使用一个vis数组记录右边第j个点是否被访问过。
如果右边第j个点未被访问，我们就尝试匹配左边第i个点和右边第j个点，如果匹配成功，就更新lx[i]和ly[j]的值。
如果匹配失败，我们就需要尝试将当前匹配中的某个点切换到另一个点上，以获得更大的权值。
这个过程可以通过递归实现。
我们得到的匹配就是带权二分图的最大权完美匹配。
KM算法的时间复杂度为O(n^3)，空间复杂度为O(n^2)。
KM算法是一种高效的求解带权二分图最大权完美匹配的算法。
它的思路简单，实现也不难，但需要注意细节和边界条件。
在实际应用中，KM算法可以用于匹配问题、优化问题等方面。
离散数学_二分图与匹配
二分图与匹配
满足如下条件的无向图G=<V，E>有非空集合X,Y:X∪Y=V,X∩Y=∅,且每个vᵢ ,vⱼ∈E,都有：vᵢ∈X∧vⱼ∈Y,或者vᵢ∈Y∧vⱼ∈X可以用G=<X,E,Y>表示二分图
完全二分图 : 如果X，Y中任意两个顶点之间都有边，则称为完全二分图
匹配 : 将E的子集M称作一个匹配
最大匹配 : 如果M中的任意两条边都没有公共端点边数最多的匹配称作最大匹配
完全匹配 : 如果X(Y)中的所有的顶点都出现在匹配M中,则称M是X(Y)-完全匹配 如果M既是X-完全匹配，又是Y-完全匹配，称M是完全匹配最大匹配匈牙利算法 : ①任意取一个匹配M (可以是空集或只有一条边) ②令S是非饱和点(尚未匹配的点)的集合 ③如果S=∅，则M已经是最大匹配 ④从S中取出一个非饱和点u₀作为起点，从此起点走交错路(交替属于M和非M的边构成的极大无重复点通路或回路)P ⑤如果P是一个增广路(P的终点也是非饱和点),则令M=M⊕P=(M-P)∪(P-M) ⑥如果P都不是增广路，则从S中去掉u₀，转到step3。
Kuhn-Munkres算法
Kuhn-Munkres算法（二分图最大权匹配）二分图最佳匹配（kuhn munkras 算法 O(m*m*n)).邻接矩阵形式。
返回最佳匹配值，传入二分图大小m,n邻接矩阵 mat ，表示权，match1,match2返回一个最佳匹配,为匹配顶点的match值为-1，一定注意m<=n，否则循环无法终止，最小权匹配可将全职取相反数。
初始化： for(i=0;i<MAXN;i++)for(j=0;j<MAXN;j++) mat[i][j]=-inf;对于存在的边：mat[i][j]=val;//注意不能负值********************************************************/#include<string.h>#define MAXN 310#define inf 1000000000 #define _clr(x) memset(x,-1,sizeof(int)*MAXN)int KM(int m,int n,int mat[][MAXN],int*match1,int *match2){int s[MAXN],t[MAXN],l1[MAXN],l2[MAXN];int p,q,i,j,k,ret=0;for(i=0;i<m;i++){l1[i]=-inf;for(j=0;j<n;j++)l1[i]=mat[i][j]>l1[i]?mat[i][j]:l1[i];if(l1[i]==-inf) return -1;}for(i=0;i<n;i++)l2[i]=0;_clr(match1);_clr(match2);for(i=0;i<m;i++){_clr(t);p=0;q=0;for(s[0]=i;p<=q&&match1[i]<0;p++){for(k=s[p],j=0;j<n&&match1[i]<0;j++){if(l1[k]+l2[j]==mat[k][j]&&t[j]<0){s[++q]=match2[j];t[j]=k;if(s[q]<0){for(p=j;p>=0;j=p){match2[j]=k=t[j];p=match1[k];match1[k]=j;}}}}}if(match1[i]<0){i--;p=inf;for(k=0;k<=q;k++){for(j=0;j<n;j++){if(t[j]<0&&l1[s[k]]+l2[j]-mat[s[k]][j]<p)p=l1[s[k]]+l2[j]-mat[s[k]][j];}}for(j=0;j<n;j++)l2[j]+=t[j]<0?0:p;for(k=0;k<=q;k++)l1[s[k]]-=p;}}for(i=0;i<m;i++)ret+=mat[i][match1[i]];return ret;}下面是从网上的博客摘抄的一些零散的总结。
二分图最大匹配算法的应用及Matlab实现
[num h] = maxnum(g);%g是二分图<ahref="https:///s?wd=%E9%82%BB%E6%8E%A5%E7%9F%A9%E 9%98%B5&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Y vnyPBnyR3nHNBnymYmhF-0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT 6K1TL0qnfK1TL0z5HD0IgF_5y9YIZ0lQzqlpA-bmyt8mh7GuZR8mvqVQL7dugP Ypyq8Q1nzPWfLnjfkrH0knWRknWfYPf" target="_blank"class="baidu-highlight">邻接矩阵</a>%调用了一个自己写maxnum函数，返回num就是最大值，h是hij(不唯一）以下是maxnum.m的内容，用的是匈牙利算法其中还用了一个递归的incpath函数，寻找增广路径function[num h] = maxnum(g)s=size(g);global G_h;%矩阵hij记录选中global G_g;%矩阵gij记录匹配global G_v;%记录当前一次路径访问过的节点G_h=false(s);%矩阵hij初始为空G_g=g;%矩阵gij就是传递进来的参数gfor i=1:s(1)G_v=false(1,s(2));%每次初始化径访问过的节点为空incpath(i);%从Ai开始寻找增广路径endh=G_h;num=sum(h(:));%输出最大匹配数，和匹配矩阵hclear global 'G_h';clear global 'G_g';endfunction OK = incpath(i)%从Ai开始global G_h;global G_g;global G_v;OK=false;j=find(~G_h(i,:)&G_g(i,:)&~G_v,1);%寻找合条件的Bjif isempty(j),return;end%找不到返回falseG_v(j)=true;%找到了，标记Bj为以访问节点ii=find(G_h(:,j));%寻找Bj在原来匹配中if isempty(ii)%如果不在原匹配中G_h(i,j)=true;OK=true;return;end%找到增广路径末端，返回trueok=incpath(ii);%如果在原来的匹配中，根据匹配对应的Aii递归调用incpath寻找if ok %如果递归寻找返回成功G_h(i,j)=~G_h(i,j);G_h(ii,j)=~G_h(ii,j);OK=true;return;end%路径反色返回trueend。
二分图最大匹配：匈牙利算法的python实现
⼆分图最⼤匹配：匈⽛利算法的python实现⼆分图匹配是很常见的算法问题，⼀般⽤匈⽛利算法解决⼆分图最⼤匹配问题，但是⽬前⽹上绝⼤多数都是C/C++实现版本，没有python版本，于是就⽤python实现了⼀下深度优先的匈⽛利算法，本⽂使⽤的是递归的⽅式以便于理解，然⽽迭代的⽅式会更好，各位可以⾃⾏实现。
1、⼆分图、最⼤匹配什么是⼆分图：⼆分图⼜称作⼆部图，是图论中的⼀种特殊模型。
设G=(V,E)是⼀个⽆向图，如果顶点V可分割为两个互不相交的⼦集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为⼀个⼆分图。
什么是匹配：把上图想象成3位⼯⼈和4种⼯作，连线代表⼯⼈愿意从事某项⼯作，但最终1个⼯⼈只能做⼀种⼯作，最终的配对结果连线就是⼀个匹配。
匹配可以是空。
什么是最⼤匹配：在愿意从事的基础上，能够最多配成⼏对。
现在要⽤匈⽛利算法找出最多能发展⼏对。
[color=green][size=medium]匈⽛利算法是解决寻找⼆分图最⼤匹配的。
更多⼆分图最⼤匹配的图解可以参考 /5576502/1297344以下是代码，为了图省事使⽤了类，实际上并不需要这样M=[]class DFS_hungary():def__init__(self, nx, ny, edge, cx, cy, visited):self.nx, self.ny=nx, nyself.edge = edgeself.cx, self.cy=cx,cyself.visited=visiteddef max_match(self):res=0for i in self.nx:if self.cx[i]==-1:for key in self.ny: # 将visited置0表⽰未访问过self.visited[key]=0res+=self.path(i)return resdef path(self, u):for v in self.ny:if self.edge[u][v] and (not self.visited[v]):self.visited[v]=1if self.cy[v]==-1:self.cx[u] = vself.cy[v] = uM.append((u,v))return 1else:M.remove((self.cy[v], v))if self.path(self.cy[v]):self.cx[u] = vself.cy[v] = uM.append((u, v))return 1return 0ok，接着测试⼀下：if__name__ == '__main__':nx, ny = ['A', 'B', 'C', 'D'], ['E', 'F', 'G', 'H']edge = {'A':{'E': 1, 'F': 0, 'G': 1, 'H':0}, 'B':{'E': 0, 'F': 1, 'G': 0, 'H':1}, 'C':{'E': 1, 'F': 0, 'G': 0, 'H':1}, 'D':{'E': 0, 'F': 0, 'G': 1, 'H':0}} # 1 表⽰可以匹配， 0 表⽰不能匹配cx, cy = {'A':-1,'B':-1,'C':-1,'D':-1}, {'E':-1,'F':-1,'G':-1,'H':-1}visited = {'E': 0, 'F': 0, 'G': 0,'H':0}print DFS_hungary(nx, ny, edge, cx, cy, visited).max_match()结果为4，是正确的。
主要定理二分图的最大匹配算法二分图的带权重的最大匹配
2021/2/13
山东大学 软件学院
22
时间复杂度分析
令|S| = m，|T| = n，假设 m n。 找一条增广路（或判断不能找到）标号算法最多进行 O(mn)
次检查（因为最多有这么多条边）。 初始匹配最多被增广 m 次。 所以，总的计算量为 O(m2n)。
2021/2/13
山东大学 软件学院
2021/2/13
山东大学 软件学院
17
例子
1
6
2
72
3
82
4
9
5
10
找到一条增广路(2, 8)。更新M。
2021/2/13
山东大学 软件学院
18
例子
1
63
2
7
3
83
4
93
5
10 3
找到一条增广路(3, 10)。更新M。
2021/2/13
山东大学 软件学院
19
例子
2021/2/13
1 2 10 3 4 5
2021/2/13
山东大学 软件学院
4
例子
2021/2/13
山东大学 软件学院
5
定理
定理：记G’上的最大流为f*，流值为|f*|。G上的最大匹配 为M*。则|f*| = |M*|。 证明：首先证|f*| |M*|。 给定最大匹配M*，令G’上M*中的边的流值为1，s到M*匹 配的V一侧点的各条边上流值为1，M*匹配的U一侧点到t的 各条边上流值为1，则构造了一个流值为|M*|的流f。 因此，显然有|f*| |M*|。 再证|f*| |M*|。 设f*为G’上的最大流。 由整流定理，G’上每条边上的流值为整数。由于每条边的 容量均为1，因此G’上每条边的流值不是0就是1。