可以直接用的匈牙利算法
最大化指派问题匈牙利算法
最大化指派问题匈牙利算法匈牙利算法，也称为Kuhn-Munkres算法，是用于解决最大化指派问题（Maximum Bipartite Matching Problem）的经典算法。
最大化指派问题是在一个二分图中，找到一个匹配（即边的集合），使得匹配的边权重之和最大。
下面我将从多个角度全面地介绍匈牙利算法。
1. 算法原理：匈牙利算法基于增广路径的思想，通过不断寻找增广路径来逐步扩展匹配集合，直到无法找到增广路径为止。
算法的基本步骤如下：初始化，将所有顶点的标记值设为0，将匹配集合初始化为空。
寻找增广路径，从未匹配的顶点开始，依次尝试匹配与其相邻的未匹配顶点。
如果找到增广路径，则更新匹配集合；如果无法找到增广路径，则进行下一步。
修改标记值，如果无法找到增广路径，则通过修改标记值的方式，使得下次寻找增广路径时能够扩大匹配集合。
重复步骤2和步骤3，直到无法找到增广路径为止。
2. 算法优势：匈牙利算法具有以下优势：时间复杂度较低，匈牙利算法的时间复杂度为O(V^3)，其中V是顶点的数量。
相比于其他解决最大化指派问题的算法，如线性规划算法，匈牙利算法具有更低的时间复杂度。
可以处理大规模问题，由于时间复杂度较低，匈牙利算法可以处理大规模的最大化指派问题，而不会因为问题规模的增加而导致计算时间大幅增加。
3. 算法应用：匈牙利算法在实际中有广泛的应用，例如：任务分配，在人力资源管理中，可以使用匈牙利算法将任务分配给员工，使得任务与员工之间的匹配最优。
项目分配，在项目管理中，可以使用匈牙利算法将项目分配给团队成员，以最大程度地提高团队成员与项目之间的匹配度。
资源调度，在物流调度中，可以使用匈牙利算法将货物分配给合适的运输车辆，使得货物与运输车辆之间的匹配最优。
4. 算法扩展：匈牙利算法也可以扩展到解决带权的最大化指派问题，即在二分图的边上赋予权重。
在这种情况下，匈牙利算法会寻找一个最优的匹配，使得匹配边的权重之和最大。
运筹学匈牙利法
运筹学匈牙利法运筹学匈牙利法（Hungarian Algorithm），也叫匈牙利算法，是解决二部图最大（小）权完美匹配（也称作二分图最大权匹配、二分图最小点覆盖）问题的经典算法，是由匈牙利数学家Kuhn和Harold W. Kuhn发明的，属于贪心算法的一种。
问题描述在一个二分图中，每个节点分别属于两个特定集合。
找到一种匹配，使得所有内部的节点对都有连边，并且找到一种匹配方案，使得该方案的边权和最大。
应用场景匈牙利算法的应用场景较为广泛，比如在生产调度、货车调度、学生对导师的指定、电影的推荐等领域内，都有广泛的应用。
算法流程匈牙利算法的伪代码描述如下：进行循环ɑ、选择一点未匹配的点a作为起点，它在二分图的左边β、找出a所有未匹配的点作为下一层节点ɣ、对下一层的每个节点，如果它在右边未匹配，直接匹配ɛ、如果遇到一个已经匹配的节点，进入下一圈，考虑和它匹配的情况δ、对已经匹配的点，将它已经匹配的点拿出来，作为下一层节点，标记这个点作为已被搜索过ε、将这个点作为当前层的虚拟点，没人配它，看能否为它找到和它匹配的点ζ、如果能匹配到它的伴侣，令它们成对被匹配最后输出最大权匹配。
算法优缺点优点：相比于暴力求解二分图最大权匹配来说，匈牙利算法具有优秀的解决效率和高效的时间复杂度，可以在多项式时间（O(n^3)）内解决二分图最大权匹配问题。
缺点：当二分图较大时，匈牙利算法还是有很大的计算复杂度，复杂度不佳，算法有效性差。
此时就需要改进算法或者使用其他算法。
总结匈牙利算法是一个常见的解决二分图最大权匹配问题的算法，由于其简洁、易用、效率优秀等特性，广泛应用于学术和实际问题中。
匈牙利算法虽然在处理较大规模问题时效率不佳，但仍然是一种值得掌握的经典算法。
匈牙利算法详细步骤例题
匈牙利算法详细步骤例题
嘿，朋友们！今天咱就来讲讲这神奇的匈牙利算法。
你可别小瞧它，这玩意儿在好多地方都大有用处呢！
咱先来看个具体的例子吧。
就说有一堆任务，还有一堆人，要把这
些任务分配给这些人，怎么分才能最合理呢？这时候匈牙利算法就闪
亮登场啦！
第一步，咱得弄个表格出来，把任务和人之间的关系都给标上。
比
如说，这个人干这个任务合适不合适呀，合适就标个高分，不合适就
标个低分。
这就好像给他们牵红线似的，得找到最合适的搭配。
然后呢，开始试着给任务找人。
从第一个任务开始，找个最合适的人。
要是这个人还没被别的任务占着，那太好了，直接就配对成功啦！要是已经被占了呢，那就得看看能不能换一换，让大家都更合适。
就好比是跳舞，你得找到最合适的舞伴，跳起来才带劲嘛！要是随
便找个人就跳，那多别扭呀。
这中间可能会遇到一些麻烦，比如好几个人都对同一个任务感兴趣，那可咋办？这就得好好琢磨琢磨啦，得权衡一下，谁更合适。
有时候你会发现，哎呀，怎么这么难呀，怎么都找不到最合适的搭配。
别急别急，慢慢来，就像解一道难题一样，得一点点分析。
咱再说说这算法的奇妙之处。
它就像是一个聪明的红娘，能把最合适的任务和人牵到一起。
你想啊，要是没有它，那咱不得乱点鸳鸯谱呀，那可不行，得把资源都好好利用起来才行呢。
比如说，有五个任务，五个。
求解指派问题的匈牙利算法.doc
3.2 求解指派问题的匈牙利算法由于指派问题的特殊性，又存在着由匈牙利数学家D.Konig 提出的更为简便的解法—匈牙利算法。
算法主要依据以下事实：如果系数矩阵)(ij c C =一行（或一列）中每一元素都加上或减去同一个数，得到一个新矩阵)(ij b B = ，则以C 或B 为系数矩阵的指派问题具有相同的最优指派。
利用上述性质，可将原系数阵C 变换为含零元素较多的新系数阵B ，而最优解不变。
若能在B 中找出n 个位于不同行不同列的零元素，令解矩阵中相应位置的元素取值为1，其它元素取值为零，则所得该解是以B 为系数阵的指派问题的最优解，从而也是原问题的最优解。
由C 到B 的转换可通过先让矩阵C 的每行元素均减去其所在行的最小元素得矩阵D ，D 的每列元素再减去其所在列的最小元素得以实现。
下面通过一例子来说明该算法。
例7 求解指派问题，其系数矩阵为⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡=16221917171822241819211722191516C 解 将第一行元素减去此行中的最小元素15，同样，第二行元素减去17，第三行元素减去17，最后一行的元素减去16，得⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡=06310157124074011B 再将第3列元素各减去1，得⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡=****20531005711407301B 以2B 为系数矩阵的指派问题有最优指派⎪⎪⎭⎫ ⎝⎛43124321 由等价性，它也是例7的最优指派。
有时问题会稍复杂一些。
例8 求解系数矩阵C 的指派问题⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=61071041066141512141217766698979712C 解：先作等价变换如下∨∨∨⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡→⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡----- 2636040*08957510*00*0032202*056107104106614151214121776669897971246767 容易看出，从变换后的矩阵中只能选出四个位于不同行不同列的零元素，但5=n ，最优指派还无法看出。
匈牙利算法——精选推荐
匈⽛利算法0 - 相关概念0.1 - 匈⽛利算法 匈⽛利算法是由匈⽛利数学家Edmonds于1965年提出，因⽽得名。
匈⽛利算法是基于Hall定理中充分性证明的思想，它是⼆部图匹配最常见的算法，该算法的核⼼就是寻找增⼴路径，它是⼀种⽤增⼴路径求⼆分图最⼤匹配的算法。
0.2 - ⼆分图 若图G的结点集合V(G)可以分成两个⾮空⼦集V1和V2，并且图G的任意边xy关联的两个结点x和y分别属于这两个⼦集，则G是⼆分图。
1 - 基本思想1. 找到当前结点a可以匹配的对象A，若该对象A已被匹配，则转⼊第3步，否则转⼊第2步2. 将该对象A的匹配对象记为当前对象a，转⼊第6步3. 寻找该对象A已经匹配的对象b，寻求其b是否可以匹配另外的对象B，如果可以，转⼊第4步，否则，转⼊第5步4. 将匹配对象b更新为另⼀个对象B，将对象A的匹配对象更新为a，转⼊第6步5. 结点a寻求下⼀个可以匹配的对象，如果存在，则转⼊第1步，否则说明当前结点a没有可以匹配的对象，转⼊第6步6. 转⼊下⼀结点再转⼊第1步2 - 样例解析 上⾯的基本思想看完肯定⼀头雾⽔（很⼤程度是受限于我的表达能⼒），下⾯通过来就匈⽛利算法做⼀个详细的样例解析。
2.1 - 题⽬⼤意 农场主John有N头奶⽜和M个畜栏，每⼀头奶⽜需要在特定的畜栏才能产奶。
第⼀⾏给出N和M，接下来N⾏每⾏代表对应编号的奶⽜，每⾏的第⼀个数值T表⽰该奶⽜可以在多少个畜栏产奶，⽽后的T个数值为对应畜栏的编号，最后输出⼀⾏，表⽰最多可以让多少头奶⽜产奶。
2.1 - 输⼊样例5522532342153125122.2 - 匈⽛利算法解题思路2.2.1 - 构造⼆分图 根据输⼊样例构造如下⼆分图，蓝⾊结点表⽰奶⽜，黄⾊结点表⽰畜栏，连线表⽰对应奶⽜能在对应畜栏产奶。
2.2.2 - 模拟算法流程为结点1（奶⽜）分配畜栏，分配畜栏2（如图(a)加粗红边所⽰）为结点2（奶⽜）分配畜栏，由于畜栏2已经被分配给结点1（奶⽜），所以寻求结点1（奶⽜）是否能够分配别的畜栏，以把畜栏2腾给结点2（奶⽜）。
利用匈牙利算法求完美匹配例题
一、概述匈牙利算法是一种用于求解二分图最大匹配的经典算法，它的时间复杂度为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)匈⽛利树匈⽛利树中从根节点到叶节点的路径均是交替路，且匈⽛利树的叶节点都是匹配点。
最大二分图匹配（匈牙利算法）
最大二分图匹配（匈牙利算法）二分图指的是这样一种图：其所有的顶点分成两个集合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);}}。
数学建模匈牙利算法
数学建模匈牙利算法
【最新版】
目录
一、匈牙利算法的概念与基本原理
二、匈牙利算法的应用实例
三、匈牙利算法的优缺点
正文
一、匈牙利算法的概念与基本原理
匈牙利算法（Hungarian algorithm）是一种求解二分图最大匹配问题的算法，由匈牙利数学家 Mátyásovszky 于 1937 年首次提出。
该算法的基本思想是：通过不断循环寻找图中的偶数长度路径，并将路径中的顶点依次匹配，直到找不到这样的路径为止。
此时，图中的所有顶点都已匹配，即得到了二分图的最大匹配。
二、匈牙利算法的应用实例
匈牙利算法广泛应用于任务分配、资源调度、数据融合等领域。
下面举一个简单的例子来说明匈牙利算法的应用。
假设有 5 个工人和 8 个任务，每个工人完成不同任务的效率不同。
我们需要为每个任务分配一个工人，使得总效率最大。
可以用一个二分图来表示这个问题，其中顶点分为两类：工人和任务。
边表示任务与工人之间的效率关系。
匈牙利算法可以用来求解这个问题，找到最优的任务分配方案。
三、匈牙利算法的优缺点
匈牙利算法的优点是简单、高效，可以解决二分图的最大匹配问题。
然而，它也存在一些缺点：
1.匈牙利算法只能解决无向图的匹配问题，对于有向图，需要将其转
换为无向图才能使用匈牙利算法。
2.当图中存在环时，匈牙利算法无法找到最大匹配。
这时需要使用其他算法，如 Euclidean algorithm（欧几里得算法）来解决。
3.匈牙利算法在实际应用中可能存在数值稳定性问题，即在计算过程中可能出现精度误差。
匈牙利算法求解原理的应用
匈牙利算法求解原理的应用什么是匈牙利算法匈牙利算法是一种用于解决二分图最大匹配问题的算法。
所谓二分图，就是一个节点集合可以分为两个不相交的子集，而且每个子集内的节点之间不存在边。
在二分图中，最大匹配问题就是寻找最大的边集合，使得每个节点都和边集合中的某条边相邻接。
匈牙利算法的原理是通过增广路径的方法来求解最大匹配问题。
其中增广路径是指在匹配图中的一条未被匹配的边交替经过未被匹配的节点，最终到达另一个未被匹配的节点的路径。
匈牙利算法的应用匈牙利算法有许多实际应用场景。
以下列举了一些典型的应用案例：1.婚姻匹配问题：假设有n个男人和n个女人，每个人都有一个倾向表，表明他们对各种婚姻选择的偏好程度。
那么如何进行匹配，使得每个人都得到一个满意度最高的选择，同时保证没有不合适的匹配？这就可以使用匈牙利算法进行求解。
2.任务分配问题：假设有m个任务和n个工人，每个任务对于每个工人都有不同的技能要求和报酬。
如何将任务分配给工人，使得任务总报酬最大化，并满足每个任务的要求？这也可以使用匈牙利算法进行求解。
3.运输问题：在某个地区有n个供应点和n个需求点，以及不同供应点到需求点之间的运输成本。
那么如何选择合适的运输方案，使得总运输成本最小？同样可以使用匈牙利算法进行求解。
4.社交网络匹配问题：在一个社交网络中，每个人都有一定的朋友圈和交往偏好。
如何将这些人进行匹配，使得每个人都能够找到最适合的交往对象？匈牙利算法也可以应用于这种情况。
匈牙利算法的实现步骤下面是匈牙利算法的具体实现步骤：1.在匹配图中选择一个未匹配的顶点作为起始点，并为其标记为已访问。
2.对于当前顶点的每一个邻接顶点，如果该邻接顶点未被匹配，则找到一条增广路径。
如果该邻接顶点已被匹配，但可以通过其他路径找到一条增广路径，则将该邻接顶点的匹配权转移到当前顶点的匹配边上。
3.继续选择下一个未匹配的顶点，重复步骤2，直到无法找到增广路径为止。
4.返回当前匹配图的最大匹配。
运筹学指派问题的匈牙利法
运筹学课程设计指派问题的匈牙利法专业：姓名：学号：1.算法思想：匈牙利算法的基本思想是修改效益矩阵的行或列，使得每一行或列中至少有一个为零的元素，经过修正后，直至在不同行、不同列中至少有一个零元素，从而得到与这些零元素相对应的一个完全分配方案。
当它用于效益矩阵时，这个完全分配方案就是一个最优分配，它使总的效益为最小。
这种方法总是在有限步內收敛于一个最优解。
该方法的理论基础是：在效益矩阵的任何行或列中，加上或减去一个常数后不会改变最优分配。
2.算法流程或步骤：1.将原始效益矩阵C的每行、每列各元素都依次减去该行、该列的最小元素，使每行、每列都至少出现一个0元素，以构成等价的效益矩阵C’。
2.圈0元素。
在C’中未被直线通过的含0元素最少的行（或列）中圈出一个0元素，通过这个0元素作一条竖（或横）线。
重复此步，若这样能圈出不同行不同列的n个0元素，转第四步，否则转第三步。
3.调整效益矩阵。
在C’中未被直线穿过的数集D中，找出最小的数d，D中所有数都减去d，C’中两条直线相交处的数都加的d。
去掉直线，组成新的等价效益矩阵仍叫C’，返回第二步。
X=0，这就是一种最优分配。
最低总4.令被圈0元素对应位置的X ij=1,其余ij耗费是C中使X=1的各位置上各元素的和。
ij算法流程图：3.算法源程序：#include<iostream.h>typedef struct matrix{float cost[101][101];int zeroelem[101][101];float costforout[101][101];int matrixsize;int personnumber;int jobnumber;}matrix;matrix sb;int result[501][2];void twozero(matrix &sb);void judge(matrix &sb,int result[501][2]);void refresh(matrix &sb);void circlezero(matrix &sb);matrix input();void output(int result[501][2],matrix sb);void zeroout(matrix &sb);matrix input(){matrix sb;int m;int pnumber,jnumber;int i,j;float k;char w;cout<<"指派问题的匈牙利解法:"<<endl;cout<<"求最大值，请输入1;求最小值，请输入0:"<<endl;cin>>m;while(m!=1&&m!=0){cout<<"请输入1或0:"<<endl;cin>>m;}cout<<"请输入人数(人数介于1和100之间):"<<endl;cin>>pnumber;while(pnumber<1||pnumber>100){cout<<"请输入合法数据:"<<endl;cin>>pnumber;}cout<<"请输入工作数(介于1和100之间):"<<endl;cin>>jnumber;while(jnumber<1||jnumber>100){cout<<"请输入合法数据:"<<endl;cin>>jnumber;}cout<<"请输入"<<pnumber<<"行"<<jnumber<<"列的矩阵,同一行内以空格间隔,不同行间以回车分隔,以$结束输入:\n";for(i=1;i<=pnumber;i++)for(j=1;j<=jnumber;j++){cin>>sb.cost[i][j];sb.costforout[i][j]=sb.cost[i][j];}cin>>w;if(jnumber>pnumber)for(i=pnumber+1;i<=jnumber;i++)for(j=1;j<=jnumber;j++){sb.cost[i][j]=0;sb.costforout[i][j]=0;}else{if(pnumber>jnumber)for(i=1;i<=pnumber;i++)for(j=jnumber+1;j<=pnumber;j++){sb.cost[i][j]=0;sb.costforout[i][j]=0;}}sb.matrixsize=pnumber;if(pnumber<jnumber)sb.matrixsize=jnumber;sb.personnumber=pnumber;sb.jobnumber=jnumber;if(m==1){k=0;for(i=1;i<=sb.matrixsize;i++)for(j=1;j<=sb.matrixsize;j++)if(sb.cost[i][j]>k)k=sb.cost[i][j];for(i=1;i<=sb.matrixsize;i++)for(j=1;j<=sb.matrixsize;j++)sb.cost[i][j]=k-sb.cost[i][j];}return sb;}void circlezero(matrix &sb){int i,j;float k;int p;for(i=0;i<=sb.matrixsize;i++)sb.cost[i][0]=0;for(j=1;j<=sb.matrixsize;j++)sb.cost[0][j]=0;for(i=1;i<=sb.matrixsize;i++)for(j=1;j<=sb.matrixsize;j++)if(sb.cost[i][j]==0){sb.cost[i][0]++;sb.cost[0][j]++;sb.cost[0][0]++;}for(i=0;i<=sb.matrixsize;i++)for(j=0;j<=sb.matrixsize;j++)sb.zeroelem[i][j]=0;k=sb.cost[0][0]+1;while(sb.cost[0][0]<k){k=sb.cost[0][0];for(i=1;i<=sb.matrixsize;i++){if(sb.cost[i][0]==1){for(j=1;j<=sb.matrixsize;j++)if(sb.cost[i][j]==0&&sb.zeroelem[i][j]==0)break;sb.zeroelem[i][j]=1;sb.cost[i][0]--;sb.cost[0][j]--;sb.cost[0][0]--;if(sb.cost[0][j]>0)for(p=1;p<=sb.matrixsize;p++)if(sb.cost[p][j]==0&&sb.zeroelem[p][j]==0){sb.zeroelem[p][j]=2;sb.cost[p][0]--;sb.cost[0][j]--;sb.cost[0][0]--;}}}for(j=1;j<=sb.matrixsize;j++){if(sb.cost[0][j]==1){for(i=1;i<=sb.matrixsize;i++)if(sb.cost[i][j]==0&&sb.zeroelem[i][j]==0)break;sb.zeroelem[i][j]=1;sb.cost[i][0]--;sb.cost[0][j]--;sb.cost[0][0]--;if(sb.cost[i][0]>0)for(p=1;p<=sb.matrixsize;p++)if(sb.cost[i][p]==0&&sb.zeroelem[i][p]==0){sb.zeroelem[i][p]=2;sb.cost[i][0]--;sb.cost[0][p]--;sb.cost[0][0]--;}}}}if(sb.cost[0][0]>0)twozero(sb);elsejudge(sb,result);}void twozero(matrix &sb){int i,j;int p,q;int m,n;float k;matrix st;for(i=1;i<=sb.matrixsize;i++)if(sb.cost[i][0]>0)break;if(i<=sb.matrixsize){for(j=1;j<=sb.matrixsize;j++){st=sb;if(sb.cost[i][j]==0&&sb.zeroelem[i][j]==0){sb.zeroelem[i][j]=1;sb.cost[i][0]--;sb.cost[0][j]--;sb.cost[0][0]--;for(q=1;q<=sb.matrixsize;q++)if(sb.cost[i][q]==0&&sb.zeroelem[i][q]==0){sb.zeroelem[i][q]=2;sb.cost[i][0]--;sb.cost[0][q]--;sb.cost[0][0]--;}for(p=1;p<=sb.matrixsize;p++)if(sb.cost[p][j]==0&&sb.zeroelem[p][j]==0){sb.zeroelem[p][j]=2;sb.cost[p][0]--;sb.cost[0][j]--;sb.cost[0][0]--;}k=sb.cost[0][0]+1;while(sb.cost[0][0]<k){k=sb.cost[0][0];for(p=i+1;p<=sb.matrixsize;p++){if(sb.cost[p][0]==1){for(q=1;q<=sb.matrixsize;q++)if(sb.cost[p][q]==0&&sb.zeroelem[p][q]==0)break;sb.zeroelem[p][q]=1;sb.cost[p][0]--;sb.cost[0][q]--;sb.cost[0][0]--;for(m=1;m<=sb.matrixsize;m++)if(sb.cost[m][q]=0&&sb.zeroelem[m][q]==0){sb.zeroelem[m][q]=2;sb.cost[m][0]--;sb.cost[0][q]--;sb.cost[0][0]--;}}}for(q=1;q<=sb.matrixsize;q++){if(sb.cost[0][q]==1){for(p=1;p<=sb.matrixsize;p++)if(sb.cost[p][q]==0&&sb.zeroelem[p][q]==0)break;sb.zeroelem[p][q]=1;sb.cost[p][q]--;sb.cost[0][q]--;sb.cost[0][0]--;for(n=1;n<=sb.matrixsize;n++)if(sb.cost[p][n]==0&&sb.zeroelem[p][n]==0){sb.zeroelem[p][n]=2;sb.cost[p][0]--;sb.cost[0][n]--;sb.cost[0][0]--;}}}}if(sb.cost[0][0]>0)twozero(sb);elsejudge(sb,result);}sb=st;}}}void judge(matrix &sb,int result[501][2]){int i,j;int m;int n;int k;m=0;for(i=1;i<=sb.matrixsize;i++)for(j=1;j<=sb.matrixsize;j++)if(sb.zeroelem[i][j]==1)m++;if(m==sb.matrixsize){k=1;for(n=1;n<=result[0][0];n++){for(i=1;i<=sb.matrixsize;i++){for(j=1;j<=sb.matrixsize;j++)if(sb.zeroelem[i][j]==1)break;if(i<=sb.personnumber&&j<=sb.jobnumber)if(j!=result[k][1])break;k++;}if(i==sb.matrixsize+1)break;elsek=n*sb.matrixsize+1;}if(n>result[0][0]){k=result[0][0]*sb.matrixsize+1;for(i=1;i<=sb.matrixsize;i++)for(j=1;j<=sb.matrixsize;j++)if(sb.zeroelem[i][j]==1){result[k][0]=i;result[k++][1]=j;}result[0][0]++;}}else{refresh(sb);}}void refresh(matrix &sb){int i,j;float k;int p;k=0;for(i=1;i<=sb.matrixsize;i++){for(j=1;j<=sb.matrixsize;j++)if(sb.zeroelem[i][j]==1){sb.zeroelem[i][0]=1;break;}}while(k==0){k=1;for(i=1;i<=sb.matrixsize;i++)if(sb.zeroelem[i][0]==0){sb.zeroelem[i][0]=2;for(j=1;j<=sb.matrixsize;j++)if(sb.zeroelem[i][j]==2){sb.zeroelem[0][j]=1;}}for(j=1;j<=sb.matrixsize;j++){if(sb.zeroelem[0][j]==1){sb.zeroelem[0][j]=2;for(i=1;i<=sb.matrixsize;i++)if(sb.zeroelem[i][j]==1){sb.zeroelem[i][0]=0;k=0;}}}}p=0;k=0;for(i=1;i<=sb.matrixsize;i++){if(sb.zeroelem[i][0]==2){for(j=1;j<=sb.matrixsize;j++){if(sb.zeroelem[0][j]!=2)if(p==0){k=sb.cost[i][j];p=1;}else{if(sb.cost[i][j]<k)k=sb.cost[i][j];}}}}for(i=1;i<=sb.matrixsize;i++){if(sb.zeroelem[i][0]==2)for(j=1;j<=sb.matrixsize;j++)sb.cost[i][j]=sb.cost[i][j]-k;}for(j=1;j<=sb.matrixsize;j++){if(sb.zeroelem[0][j]==2)for(i=1;i<=sb.matrixsize;i++)sb.cost[i][j]=sb.cost[i][j]+k;}for(i=0;i<=sb.matrixsize;i++)for(j=0;j<=sb.matrixsize;j++)sb.zeroelem[i][j]=0;circlezero(sb);}void zeroout(matrix &sb){int i,j;float k;for(i=1;i<=sb.matrixsize;i++){k=sb.cost[i][1];for(j=2;j<=sb.matrixsize;j++)if(sb.cost[i][j]<k)k=sb.cost[i][j];for(j=1;j<=sb.matrixsize;j++)sb.cost[i][j]=sb.cost[i][j]-k;}for(j=1;j<=sb.matrixsize;j++){k=sb.cost[1][j];for(i=2;i<=sb.matrixsize;i++)if(sb.cost[i][j]<k)k=sb.cost[i][j];for(i=1;i<=sb.matrixsize;i++)sb.cost[i][j]=sb.cost[i][j]-k;}}void output(int result[501][2],matrix sb) {int k;int i;int j;int p;char w;float v;v=0;for(i=1;i<=sb.matrixsize;i++){v=v+sb.costforout[i][result[i][1]];}cout<<"最优解的目标函数值为"<<v;k=result[0][0];if(k>5){cout<<"解的个数超过了限制."<<endl;k=5;}for(i=1;i<=k;i++){cout<<"输入任意字符后输出第"<<i<<"种解."<<endl;cin>>w;p=(i-1)*sb.matrixsize+1;for(j=p;j<p+sb.matrixsize;j++)if(result[j][0]<=sb.personnumber&&result[j][1]<=sb.jobnumber)cout<<"第"<<result[j][0]<<"个人做第"<<result[j][1]<<"件工作."<<endl;}}void main(){result[0][0]=0;sb=input();zeroout(sb);circlezero(sb);output(result,sb);}4. 算例和结果：自己运算结果为：->⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡3302102512010321->⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡330110241200032034526635546967562543----⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡可以看出：第1人做第4件工作；第2人做第1件工作；第3人做第3件工作；第4人做第2件工作。
匈牙利算法——精选推荐
二分图最优匹配：对于二分图的每条边都有一个权（非负），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最优完备匹配。
（特殊的，当所有边的权为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匹配点加入匈牙利树继续尝试增广。
匈牙利算法示例
(1) 从（cij）的每行元素都减去该行的最小元素； (2) 再从所得新系数矩阵的每列元素中减去该列的最 小元素。
1
第二步：进行试指派，以寻求最优解。 在(bij)中找尽可能多的独立0元素，若能找出n个独
2
6
0
0
0 0 0 1
1
0
0
0
0 1 0 0
0
0
1
0
1152
练习：
费 工作
用
人员
A
B
C
D
E
甲
7
5
9
8
11
乙
9
12
7
11
9
丙
8
5
4
6
8
丁
7
3
6
9
6
戊
4
6
7
5
11
13
7 5 9 8 11 5
9 12
7 11
9
7
8 5 4 6 9 4
7
3
6
9
6
3
4 6 7 5 11 4
2 0 4 3 6
2
◎0 2
3
Ø0
0Ø 4 4 0◎ 6
22
Ø0 Ø0 3 ◎0 3
1
6
0Ø 2
◎0
3 2 0◎ 0Ø 3
2
◎0 2
3
Ø0
0◎ 4 4 0Ø 6
23
用匈牙利法求解下列指派问题，已知效率矩 阵分别如下：
7 9 10 12
1
3
匈牙利算法 描述
匈牙利算法描述
摘要：
1.匈牙利算法简介
2.匈牙利算法的应用背景
3.匈牙利算法的基本思想
4.匈牙利算法的实现步骤
5.匈牙利算法的优缺点分析
6.结论
正文：
匈牙利算法是一种解决匈牙利问题的图论算法，也被称为Munkres算法。
它主要用于解决最大匹配问题和最小生成树问题。
匈牙利算法在运筹学、计算机科学、通信网络等领域具有广泛的应用背景。
匈牙利算法的基本思想是：通过不断地寻找增广路径来寻找最大匹配。
增广路径是指一条从已匹配顶点出发，到达未匹配顶点的路径。
算法的基本流程如下：
1.初始化未匹配顶点和已匹配顶点集合。
2.遍历所有未匹配顶点，找到一条增广路径。
3.将增广路径上的所有顶点标记为已匹配。
4.重复步骤2和3，直到找不到增广路径为止。
匈牙利算法的实现步骤如下：
1.初始化一个长度与顶点数相同的数组，用于记录每个顶点所在的连通分
量。
2.遍历所有边，对于每条边，如果两个顶点不在同一连通分量，则将它们合并到同一个连通分量中。
3.遍历所有顶点，如果一个顶点所在的连通分量只有一个顶点，则将其标记为已匹配。
4.重复步骤3，直到找不到未匹配顶点为止。
匈牙利算法的优缺点分析：
优点：
1.匈牙利算法的时间复杂度为O(nm)，其中n和m分别为顶点数和边数。
2.匈牙利算法可以保证找到最大匹配。
缺点：
1.匈牙利算法需要额外的存储空间来记录顶点所在的连通分量。
2.匈牙利算法不能保证找到最优解，因为可能存在多个最大匹配。
匈牙利解法
匈牙利解法1. 什么是匈牙利解法匈牙利解法，又被称为马尔科夫链匈牙利算法，是一种用于求解带权二部图最优的数学算法，该算法是Hungarianmathematician D.Kőnig在1930年发表的，是组合优化领域里最著名的算法之一，引起了众多数学家重视。
2. 匈牙利解法的基本概念简单地说，匈牙利解法可以把求解最优匹配的问题转换成一个线性规划问题，根据求出的最优值，可以得出最大权重的匹配方案。
匈牙利解法的核心思想是将人和工作、机器和工序之间的捆绑情况视为一个矩阵，根据权重进行分析。
解决矩阵匹配问题的方法就是在较小的花销下找出一个最优的权重，并使用这个最优的权重来进行匹配，从而实现满足要求的任务。
3. 匈牙利解法的主要步骤（1）确定矩阵尺寸：根据需要建立一个矩阵，由需要匹配的两组元素来构成，将矩阵中的每一元素都赋有相应的能力值，并确定矩阵的尺寸。
（2）确定最小权重：对矩阵的每一行，求出其中的最小值，并从该行中减去它；同样的，求出每一列的最小值，并从该列中减去它。
（3）求出最小权重：经过上述操作后，得出的矩阵里的元素，就是权重的最小值。
（4）得出最优结果：根据得到的最小权重值，来构建一个二部图，即使用一列最小值来匹配另一列，使得总权重最小。
4. 应用匈牙利解法可以用来解决很多实际上的问题，例如以最少花费排派最多的人，把人和机器配对，最终得到一个最优的解决方案；可以用来测定一篇文章中两个语料库之间的最大重合度，以及字频排序等。
匈牙利解法也可以用于最小距离网络流等问题，所以它是一种十分灵活且有效的数学计算算法。
二分图(匈牙利-KM算法详解)
KM算法
定理：如果一个相等子图中包含完备匹配，那 么这个匹配就是最优匹配
证明：由于在算法过程一直保持顶标的可行性， 所以任意一个匹配的权值和肯定小于等于所有 结点的顶标之和，则相等子图中的完备匹配肯 定是最优匹配
KM算法
算法流程 设顶点Xi的顶标为a[i]，顶点Yi的顶标为b[i] ⅰ.初始时，a[i]为与Xi相关联的边的最大权值，
man
31
3 5
4
32
2
4
home b 10
2 1 找到最优匹配
63
7
31
回到例题:PKU2195
题目是说有N个人跟N个房子,每个人跟房子都有一
定的距离,现在要让这N个人全部回到N个房子里面
去,要求所有人回去的距离最短.
那么求的就是最小权匹配了,那么
如果我们把所有边的权值取反,如图所示,求其最大
匹ma配n ,那么结ho果me就是我们要的了.问题解ma决n .
Input: 3 34 13 23
Output: 2
1
1’
1
4
2
2’
3
3’
2
3
4
4’
二分图的最大独立集
最大独立集问题： 在Ｎ个点的图G中选出m个点，使 这m个点两两之间没有边．求m最大值．
记住一个重要的结论： 二分图的最大独立集数=节点数(n)-最大匹配数
黑色点即为一个最大独立集
可以这样理解，在总的点集中，去掉最少的点， 使得剩下的点相互之间没有边。用最少的点去 覆盖所有的边，也就是最小覆盖。
二分图匹配
Bi-partite graph
二分图的定义：
二分图是这样的一个图，它的顶点可以 分为两个集合X和Y。所有的边关联的两个顶点 中，恰好一个属于集合X，一个属于集合Y。
整数规划解法-匈牙利 算法部分
max Z=CX
maxZ=CX (B) AX=b X 0
AX=b
(A) X 0
X为整数 (B)为(A)的松弛问题。
3
（2）替代问题的求解 max Z=CX
(B)
AX=b X 0
采用相应的方法（如图解法）求解出替代问题的 最优解，观察其是否满足整数解的要求。如其最 优解就为整数，则结束；如含有分数，则需要进 行分支定界操作。
实际含义：从事情的角度来考虑，表示此事分配给此人效率最高。
24
min
步骤二：继续产生零元素 方法：再找出矩阵每列的最小元素，再分 别从各列中减去它。
0 8 7 5 0 8 11 0 10 4 11 0 2 3 5 0 2 3 0 11 9 5 0 11
31
问
题
2 5 (0) 8 11 (0) 5 4 2 3 (0) 0 0 11 4 5
只能对三个零元素进行标定（代表独立的零 元素只有三个），后续如何操作？
32
非直观法-步骤3（第一种情形）
(3) 重复(1)、(2)两个步骤，可能出现三种 情况： ① 效率矩阵每行都有一个打( )号的零元 素，很显然，按上述步骤得到的打( )号 的零元素都位于不同行不同列，只要令 对应打( )号零元素对应的决策变量xij=1 就找到了问题的最优解；
人
从人的 角度看 从任务 角度看
工作 译成英文 译成日文 译成德文 译成俄文
甲 2 15 13 4
乙 10 4 14 15
丙 9 14 16 13
丁 7 8 11 9
12
指派问题的一般模型
假设： [aij]表示指派问题的效率矩阵 xij表示决策变量，决策变量的取值：
匈牙利算法
匈牙利算法
一、计算步骤
1、列出单价运算表。
2、找出各个行中的最小值，分别每行分别减去该行的最小值；其次，找出各个列的最小值，每一列减去该列相对应的最小值。
3、通过第二步，会得到一部分的0值，我们对这一部分的0值，进行运算即：找出唯一只有一个0的行，将这个0圈出，并将有这个0的这一列划去，对剩余部分的找出唯一只有一个0的列，将这个0圈出，将有0的这一行划去。
4、重复步骤三，知道所有0都被找出。
5、若被圈出0的个数与行（列）数m相同即为最优解。
6、若小于m，找出剩余数中的最小值k，没被划去的每行的ui=k，其余为0，没被划去的每列的vj=0，其余为-k，用每一个值减去对应行列的ui,vj.
7、重复步骤6，直至被圈出0的个数等于m，即找到最优解。
二、例题
有一份说明书, 要分别译成英、日、德、俄四种文字, 交甲乙丙丁四个人去完成. 因各人专长不同, 他们完成翻译不同文字所需的时间如表所示. 应如何分配, 使这四人分别完成这四项任务总的时间最少.。
匈牙利算法———Hopcroft-Karp算法
匈牙利算法———Hopcroft-Karp算法（转）一、匈牙利算法算法的思路是不停的找增广轨,并增加匹配的个数,增广轨顾名思义是指一条可以使匹配数变多的路径,在匹配问题中,增广轨的表现形式是一条"交错轨",也就是说这条由图的边组成的路径,它的第一条边是目前还没有参与匹配的,第二条边参与了匹配,第三条边没有..最后一条边没有参与匹配,并且始点和终点还没有被选择过.这样交错进行,显然他有奇数条边.那么对于这样一条路径,我们可以将第一条边改为已匹配,第二条边改为未匹配...以此类推.也就是将所有的边进行"反色",容易发现这样修改以后,匹配仍然是合法的,但是匹配数增加了一对.另外,单独的一条连接两个未匹配点的边显然也是交错轨.可以证明,当不能再找到增广轨时,就得到了一个最大匹配.这也就是匈牙利算法的思路.二、二分图最大匹配二分图最大匹配的经典匈牙利算法是由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年提出的，该算法的主要思想是在每次增广的时候不是找一条增广路而是同时找几条不相交的最短增广路，形成极大增广路集，随后可以沿着这几条增广路同时进行增广。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
将xyl程序存入M文件，在matlab中先写入邻接矩阵marix，而后再写function [z,ans]=xyl(marix) 回车得出结果
程序文件 xyl.m
function [z,ans]=xyl(marix)
%输入效率矩阵 marix 为方阵;
%若效率矩阵中有 M,则用一充分大的数代替;
%输出z为最优解，ans为最优分配矩阵；
%//////////////////////////////////////////////////
a=marix;
b=a;
%确定矩阵维数
s=length(a);
%确定矩阵行最小值，进行行减
ml=min(a');
for i=1:s
a(i,:)=a(i,:)-ml(i);
end
%确定矩阵列最小值，进行列减
mr=min(a);
for j=1:s
a(:,j)=a(:,j)-mr(j);
end
% start working
num=0;
while(num~=s) %终止条件是“（0）”的个数与矩阵的维数相同
%index用以标记矩阵中的零元素，若a(i,j)=0，则index(i,j)=1,否则index(i,j)=0
index=ones(s);
index=a&index;
index=~index;
%flag用以标记划线位，flag=0 表示未被划线，
%flag=1 表示有划线过，flag=2 表示为两直线交点
%ans用以记录 a 中“（0）”的位置
%循环后重新初始化flag,ans
flag = zeros(s);
ans = zeros(s);
%一次循环划线全过程，终止条件是所有的零元素均被直线覆盖，
%即在flag>0位,index=0
while(sum(sum(index)))
%按行找出“（0）”所在位置，并对“（0）”所在列划线，
%即设置flag,同时修改index,将结果填入ans
for i=1:s
t=0;
l=0;
for j=1:s
if(flag(i,j)==0&&index(i,j)==1)
l=l+1;
t=j;
end
end
if(l==1)
flag(:,t)=flag(:,t)+1;
index(:,t)=0;
ans(i,t)=1;
end
end
%按列找出“（0）”所在位置，并对“（0）”所在行划线， %即设置flag,同时修改index,将结果填入ans
for j=1:s
t=0;
r=0;
for i=1:s
if(flag(i,j)==0&&index(i,j)==1)
r=r+1;
t=i;
end
end
if(r==1)
flag(t,:)=flag(t,:)+1;
index(t,:)=0;
ans(t,j)=1;
end
end
end %对 while(sum(sum(index)))
%处理过程
%计数器：计算ans中1的个数，用num表示
num=sum(sum(ans));
% 判断是否可以终止，若可以则跳出循环
if(s==num)
break;
end
%否则，进行下一步处理
%确定未被划线的最小元素，用m表示
m=max(max(a));
for i=1:s
for j=1:s
if(flag(i,j)==0)
if(a(i,j)<m)
m=a(i,j);
end
end
end
end
%未被划线，即flag=0处减去m；线交点，即flag=2处加上m for i=1:s
for j=1:s
if(flag(i,j)==0)
a(i,j)=a(i,j)-m;
end
if(flag(i,j)==2)
a(i,j)=a(i,j)+m;
end
end
end
end %对while(num~=s)
%计算最优（min）值
zm=ans.*b;
z=0;
z=sum(sum(zm));。