匈牙利算法示例
匈牙利算法
C实现(作者BYVoid) CPP
#include <stdio.h> #include <string.h> #define MAX 102 long n,n1,match; long adjl[MAX][MAX]; long mat[MAX]; bool used[MAX]; FILE *fi,*fo; void readfile() { fi=fopen("flyer.in","r"); fo=fopen("flyer.out","w"); fscanf(fi,"%ld%ld",&n,&n1); long a,b; while (fscanf(fi,"%ld%ld",&a,&b)!=EOF) adjl[a][ ++adjl[a][0] ]=b; match=0; }
未盖点：设Vi是图G的一个顶点，如果Vi 不与任 未盖点 意一条属于匹配M的边相关联，就称Vi 是一个未 盖点。
交错路：设P是图G的一条路，如 交错路 果P的任意两条相邻的边一定是一 条属于M而另一条不属于M，就称 P是一条交错路。 可增广路：两个端点都是未盖点 可增广路 的交错路叫做可增广路。
---匈牙利算法(by_Beyond_the_Void)
procedure hungary; var i:longint; begin fillchar(b,sizeof(b),0); for i:=1 to m do begin fillchar(c,sizeof(c),0); if path(i) then inc(ans); end; end; begin fillchar(a,sizeof(a),0); readln(m,n,k); for i:=1 to k do begin readln(x,y); a[x,y]:=true; end; ans:=0; hungary; writeln(ans); end.
匈牙利算法解决二分图最大匹配
匈⽛利算法解决⼆分图最⼤匹配预备知识 匈⽛利算法是由匈⽛利数学家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个剩⼥，每个⼈都可能对多名异性有好感（惊讶，-_-||暂时不考虑特殊的性取向） 如果⼀对男⼥互有好感，那么你就可以把这⼀对撮合在⼀起，现在让我们⽆视掉所有的单相思（好忧伤的感觉，快哭了），你拥有的⼤概就是下⾯这样⼀张关系图，每⼀条连线都表⽰互有好感。
匈牙利法求解指派问题
然后划去所在的列的其他0 元素，记作Ø。
Ø 13 7 0 6 6 9 5 3 2 Ø1 0 0
➢给只有一个0元素的列的0 元素加圈，记。
Ø 13 7 0 6 6 9 5 3 2 Ø 1 0
然后划去所在的行的其他0元 素，记作Ø
Ø 13 7 0 6 6 9 5 3 2 Ø 1 Ø
➢给最后一个0元素加圈， 记。
Ø 13 7 6 6 9 5 3 2 Ø 1 Ø
可见m=n=4,得到最优解。
0001 0100 1000 0010
即甲译俄文、乙译日文、丙 译英文、丁译德文所需时间 最少。Z=28小时
例6 分配问题效率矩阵
任务 A B C D E 人员
甲 12 7 9 7 9 乙8 9 6 6 6 丙 7 17 12 14 9 丁 15 14 6 6 10 戊 4 10 7 10 9
12 7 9 7 9 7 89666 6 7 17 12 14 9 7 15 14 6 6 10 6 4 10 7 10 9 4
50202 23000 0 10 5 7 2 98004 06365
➢从只有一个0元素的行开始，给 这个0元素加圈，记
50202 23000
10 5 7 2
98004 06365
然后划去所在的列的其他0元素，记 作Ø。
70202 4 3 000 Ø 8350 11 8 0 0 4 4 1 4 3
➢从只有一个0元素的行开始，给这个0 元素加圈，记
70202 4 3 000 Ø 8 3 5 11 8 0 0 4 4 1 4 3
然后划去所在的列的其他0元素，记 作Ø。
70202 4 3 00Ø Ø 8 3 5 11 8 0 0 4 4 1 4 3
匈牙利算法详细步骤例题
匈牙利算法详细步骤例题
嘿，朋友们！今天咱就来讲讲这神奇的匈牙利算法。
你可别小瞧它，这玩意儿在好多地方都大有用处呢！
咱先来看个具体的例子吧。
就说有一堆任务，还有一堆人，要把这
些任务分配给这些人，怎么分才能最合理呢？这时候匈牙利算法就闪
亮登场啦！
第一步，咱得弄个表格出来，把任务和人之间的关系都给标上。
比
如说，这个人干这个任务合适不合适呀，合适就标个高分，不合适就
标个低分。
这就好像给他们牵红线似的，得找到最合适的搭配。
然后呢，开始试着给任务找人。
从第一个任务开始，找个最合适的人。
要是这个人还没被别的任务占着，那太好了，直接就配对成功啦！要是已经被占了呢，那就得看看能不能换一换，让大家都更合适。
就好比是跳舞，你得找到最合适的舞伴，跳起来才带劲嘛！要是随
便找个人就跳，那多别扭呀。
这中间可能会遇到一些麻烦，比如好几个人都对同一个任务感兴趣，那可咋办？这就得好好琢磨琢磨啦，得权衡一下，谁更合适。
有时候你会发现，哎呀，怎么这么难呀，怎么都找不到最合适的搭配。
别急别急，慢慢来，就像解一道难题一样，得一点点分析。
咱再说说这算法的奇妙之处。
它就像是一个聪明的红娘，能把最合适的任务和人牵到一起。
你想啊，要是没有它，那咱不得乱点鸳鸯谱呀，那可不行，得把资源都好好利用起来才行呢。
比如说，有五个任务，五个。
匈牙利算法步骤和公式
匈牙利算法是一种求解指派问题的算法，其步骤如下：对指派问题的系数矩阵进行变换，使每行每列至少有一个元素为“0”。
具体做法是让系数矩阵的每行元素去减去该行的最小元素，再让系数矩阵的每列元素减去该列的最小元素。
从第一行开始，若该行只有一个零元素，就对这个零元素加括号，对加括号的零元素所在的列画一条线覆盖该列。
若该行没有零元素或者有两个以上零元素（已划去的不算在内），则转下一行，依次进行到最后一行。
从第一列开始，若该列只有一个零元素。
就对这个零元素加括号（同样不、考虑已划去的零元素）。
再对加括号的零元素所在行画一条直线覆盖该列。
若该列没有零元素或有两个以上零元素，则转下一列，依次进行到最后一列为止。
重复上述步骤（1）和（2）可能出现3种情况：（5）按定理进行如下变换：①从矩阵未被直线覆盖的数字中找出一个最小的k；②当矩阵中的第i行有直线覆盖时，令；无直线覆盖时。
最大二分图匹配（匈牙利算法）
最大二分图匹配（匈牙利算法）二分图指的是这样一种图：其所有的顶点分成两个集合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);}}。
匈牙利算法
匈牙利算法(Edmonds算法)步聚：(1)首先用（*）标记X中所有的非M顶点，然后交替进行步骤（2），（3）。
(2)选取一个刚标记（用（*）或在步骤（3）中用（y i）标记）过的X中顶点，例如顶点x，如果x i与y为同一非匹配边的两端点，且在本步骤中y尚未被标记过,则用（x i）i去标记Y中顶点y。
重复步骤(2)，直至对刚标记过的X中顶点全部完成一遍上述过程。
(3)选取一个刚标记（在步骤(2)中用(x i)标记）过的Y中结点，例如y i，如果y i与x为同一匹配边的两端点，且在本步骤中x尚未被标记过，则用(y i)去标记X中结点x。
重复步骤(3)，直至对刚标记过的Y中结点全部完成一遍上述过程。
(2),(3)交替执行，直到下述情况之一出现为止：(I)标记到一个Y中顶点y，它不是M顶点。
这时从y出发循标记回溯，直到（*）标记的X中顶点x，我们求得一条交替链。
设其长度为2k+1，显然其中k条是匹配边，k+1条是非匹配边。
(II)步骤(2)或(3)找不到可标记结点，而又不是情况(I)。
(4)当(2),(3)步骤中断于情况(I)，则将交替链中非匹配边改为匹配边，原匹配边改为非匹配边(从而得到一个比原匹配多一条边的新匹配)，回到步骤(1)，同时消除一切现有标记。
(5)对一切可能,(2)和(3)步骤均中断于情况(II),或步骤(1)无可标记结点,算法终止(算法找不到交替链).以上算法说穿了，就是从二分图中找出一条路径来，让路径的起点和终点都是还没有匹配过的点，并且路径经过的连线是一条没被匹配、一条已经匹配过交替出现。
找到这样的路径后，显然路径里没被匹配的连线比已经匹配了的连线多一条，于是修改匹配图，把路径里所有匹配过的连线去掉匹配关系，把没有匹配的连线变成匹配的，这样匹配数就比原来多1个。
不断执行上述操作，直到找不到这样的路径为止。
下面给出此算法的一个例子：（1）置M = 空，对x1-x6标记（*）。
（2）找到交替链（x1, y1）（由标记（x1），（*）回溯得），置M = {(x1, y1)}。
匈牙利算法示例范文
匈牙利算法示例范文匈牙利算法是一种解决二分图最大匹配问题的经典算法，也称为增广路径算法。
它的核心思想是通过不断寻找增广路径来不断增加匹配数，直到无法找到新的增广路径为止。
下面我将通过一个示例来详细介绍匈牙利算法的流程和原理。
假设有一个二分图G=(V,E)，其中V={U,V}是图的两个顶点集合，E 是边集合。
我们的目标是找到一个最大的匹配M，即图中不存在更多的边可以加入到匹配中。
首先，我们需要为每个顶点u∈U找到一个能和它相连的顶点v∈V，这个过程称为初始化匹配。
我们可以将所有的顶点u初始化为null，表示还没有和它相连的顶点v。
然后，我们选择一个u∈U的顶点作为起始点，尝试寻找一条增广路径。
增广路径是指一条交替经过未匹配边和已匹配边的路径。
我们从起始点u开始，按照深度优先的方式扩展路径，不断寻找下一个可以加入路径的顶点v。
1. 如果u没有和任何顶点相连，那么说明找到了一条增广路径。
我们将路径上的未匹配边变为已匹配边，已匹配边变为未匹配边，然后返回true，表示找到了一条增广路径。
2. 如果u有和一些顶点v相连，但是v还没有和其他顶点相连，即v的匹配点为null，那么说明找到了一条增广路径。
我们将路径上的未匹配边变为已匹配边，已匹配边变为未匹配边，并将v设置为u的匹配点。
然后返回true，表示找到了一条增广路径。
3. 如果v已经和其他顶点相连，那么我们尝试寻找一条从v的匹配点u'出发的增广路径。
如果找到了一条增广路径，我们将路径上的未匹配边变为已匹配边，已匹配边变为未匹配边，并将v设置为u'的匹配点。
然后返回true，表示找到了一条增广路径。
4. 如果无法找到可行的增广路径，返回false。
通过不断重复上述过程，直到无法找到新的增广路径为止。
此时，我们得到的匹配M就是最大匹配。
下面我们通过一个具体的例子来演示匈牙利算法的运行过程。
假设我们有一个二分图，U={1,2,3}，V={4,5,6}，边集E={(1,4),(1,5),(2,4),(3,5),(3,6)}。
匈牙利算法
0 0 1 0
( )xij
44
=
1 0
0 0
0 0
0 1
0 1 0 0
或：
0 0 1 0
( )xij
44
=
0 0
0 1
0 0
1 0
1 0 0 0
Z=20
▪特殊指派问题的处理
➢目标取极大（MaxZ）：令：C’ij =M- Cij ，转化为MinS.
➢“人多于事”（m>n）：处理：加（m-n）件虚事，Ci虚＝0 ➢“事多于人”（m<n）：处理：加（n - m ）个虚人，C虚j＝0
小结：
本
章
1、指派问题最优解的性质
小 2、应用匈牙利法注意之点
结 （1）系数矩阵元素非负
（2）与表上作业法的联系与差别
3、其它情形的特殊指派问题的处理
对所有打号的列 画纵线
3 2 (00) (00) 3 2 1 (00) 2 0 1 2
＋1
0 1 -1 0 2 -1
( ) 4 2 (0) 0
b (0) 2 1 0 = ij 44
2 0 2 (00) 0 (0) 1 1
或：
4 2 (00) 0 0 2 1 (0) 2 (00) 2 0 (00) 0 1 1
4.4 匈牙利算法
➢算法原理
[cij]n×n
不同行（列）减去最小元素
[ bij]n×n
有相同的最优指派
装卸组 待卸车
P1
P2
P3
P4
A
4
3
4
1
B
2
3
6
5
Hale Waihona Puke C435
4
D
匈牙利算法——精选推荐
二分图最优匹配：对于二分图的每条边都有一个权（非负），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最优完备匹配。
（特殊的，当所有边的权为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.数学建模与匈牙利算法简介
2.匈牙利算法的基本原理
3.匈牙利算法的应用实例
4.结论
正文：
一、数学建模与匈牙利算法简介
数学建模是一种利用数学方法解决实际问题的科学研究方法，其主要目的是通过建立数学模型，揭示问题的本质，从而为问题求解提供理论依据。
匈牙利算法是解决数学建模中整数规划问题的一种有效方法，它主要用于求解二分图的最大匹配问题。
二、匈牙利算法的基本原理
1.互斥约束
在整数规划问题中，如果约束条件是互斥约束，可以新增一个决策变量y （取值为0 或1），并新增一个无穷大M。
2.匈牙利算法的基本思想
匈牙利算法的基本思想是依次寻找图中的匹配边，并将非匹配边加入到图中，直到找不到匹配边为止。
算法的执行过程可以分为两个阶段：第一阶段是构造阶段，主要目的是找到一个可行解；第二阶段是优化阶段，主要目的是通过交替寻找匹配边和非匹配边，逐步改善解的质量，直至找到最优解。
三、匈牙利算法的应用实例
匈牙利算法在实际应用中具有广泛的应用，其中最典型的应用是求解二分图的最大匹配问题。
例如，在任务分配、资源调度、数据融合等领域，都可以通过匈牙利算法来找到最优解。
四、结论
匈牙利算法是解决整数规划问题的一种有效方法，它具有计算简便、效率高等优点。
匈牙利算法示例
(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
匈牙利算法matlab源程序及实例（适合各种矩阵）
匈牙利算法matlab源程序及实例（适合各种矩阵）function [Matching,Cost] = Edmonds(a)Matching = zeros(size(a));num_y = sum(~isinf(a),1);num_x = sum(~isinf(a),2);x_con = find(num_x~=0);y_con = find(num_y~=0);P_size = max(length(x_con),length(y_con));P_cond = zeros(P_size);P_cond(1:length(x_con),1:length(y_con)) = a(x_con,y_con); if isempty(P_cond)Cost = 0;returnendEdge = P_cond;Edge(P_cond~=Inf) = 0;cnum = min_line_cover(Edge);Pmax = max(max(P_cond(P_cond~=Inf)));P_size = length(P_cond)+cnum;P_cond = ones(P_size)*Pmax;P_cond(1:length(x_con),1:length(y_con)) = a(x_con,y_con); exit_flag = 1;stepnum = 1;while exit_flagswitch stepnumcase 1[P_cond,stepnum] = step1(P_cond);case 2[r_cov,c_cov,M,stepnum] = step2(P_cond);case 3[c_cov,stepnum] = step3(M,P_size);case 4[M,r_cov,c_cov,Z_r,Z_c,stepnum] = step4(P_cond,r_cov,c_cov,M);case 5[M,r_cov,c_cov,stepnum] = step5(M,Z_r,Z_c,r_cov,c_cov);case 6[P_cond,stepnum] = step6(P_cond,r_cov,c_cov);case 7exit_flag = 0;endendMatching(x_con,y_con) = M(1:length(x_con),1:length(y_con));Cost = sum(sum(a(Matching==1)));function [P_cond,stepnum] = step1(P_cond)P_size = length(P_cond);for ii = 1:P_sizermin = min(P_cond(ii,:));P_cond(ii,:) = P_cond(ii,:)-rmin;endstepnum = 2;function [r_cov,c_cov,M,stepnum] = step2(P_cond)P_size = length(P_cond);r_cov = zeros(P_size,1);c_cov = zeros(P_size,1);M = zeros(P_size);for ii = 1:P_sizefor jj = 1:P_sizeif P_cond(ii,jj) == 0 && r_cov(ii) == 0 && c_cov(jj) == 0M(ii,jj) = 1;r_cov(ii) = 1;c_cov(jj) = 1;endendendr_cov = zeros(P_size,1); % A vector that shows if a row is coveredc_cov = zeros(P_size,1); % A vector that shows if a column is coveredstepnum = 3;function [c_cov,stepnum] = step3(M,P_size)c_cov = sum(M,1);if sum(c_cov) == P_sizestepnum = 7;elsestepnum = 4;endfunction [M,r_cov,c_cov,Z_r,Z_c,stepnum] = step4(P_cond,r_cov,c_cov,M)P_size = length(P_cond);zflag = 1;while zflagrow = 0; col = 0; exit_flag = 1;ii = 1; jj = 1;while exit_flagif P_cond(ii,jj) == 0 && r_cov(ii) == 0 && c_cov(jj) == 0row = ii;col = jj;exit_flag = 0;endjj = jj + 1;if jj > P_size; jj = 1; ii = ii+1; endif ii > P_size; exit_flag = 0; endendif row == 0stepnum = 6;zflag = 0;Z_r = 0;Z_c = 0;elseM(row,col) = 2;if sum(find(M(row,:)==1)) ~= 0r_cov(row) = 1;zcol = find(M(row,:)==1);c_cov(zcol) = 0;elsestepnum = 5;zflag = 0;Z_r = row;Z_c = col;endendendfunction [M,r_cov,c_cov,stepnum] = step5(M,Z_r,Z_c,r_cov,c_cov)zflag = 1;ii = 1;while zflagrindex = find(M(:,Z_c(ii))==1);if rindex > 0ii = ii+1;Z_r(ii,1) = rindex;Z_c(ii,1) = Z_c(ii-1);elsezflag = 0;endif zflag == 1;cindex = find(M(Z_r(ii),:)==2);ii = ii+1;Z_r(ii,1) = Z_r(ii-1);Z_c(ii,1) = cindex;endendfor ii = 1:length(Z_r)if M(Z_r(ii),Z_c(ii)) == 1M(Z_r(ii),Z_c(ii)) = 0;elseM(Z_r(ii),Z_c(ii)) = 1;endendr_cov = r_cov.*0;c_cov = c_cov.*0;M(M==2) = 0;stepnum = 3;function [P_cond,stepnum] = step6(P_cond,r_cov,c_cov)a = find(r_cov == 0);b = find(c_cov == 0);minval = min(min(P_cond(a,b)));P_cond(find(r_cov == 1),:) = P_cond(find(r_cov == 1),:) +minval;P_cond(:,find(c_cov == 0)) = P_cond(:,find(c_cov == 0)) - minval;stepnum = 4;function cnum = min_line_cover(Edge)[r_cov,c_cov,M,stepnum] = step2(Edge);[c_cov,stepnum] = step3(M,length(Edge));[M,r_cov,c_cov,Z_r,Z_c,stepnum] = step4(Edge,r_cov,c_cov,M);cnum = length(Edge)-sum(r_cov)-sum(c_cov);》a=[0.9400 0.9700 0.8600 0.9700 0.9680 0.9480 0.9680 0.98000.8600 0.9300 0.9200 0.9300 0.9680 0.9680 0.9880 0.96000.9000 0.9300 0.9400 0.9500 0.9080 0.9480 0.9680 0.96000.9400 0.9300 0.9400 0.9500 0.9680 0.9080 0.9880 0.92000.8600 0.8900 0.9200 0.9500 0.9880 0.9480 0.9680 0.92000.9200 0.9300 0.9200 0.9500 0.9080 0.9480 0.9880 0.92000.9400 0.9700 0.9000 0.9300 0.9680 0.9480 0.9680 1.00000.9200 0.9700 0.9200 0.9300 0.9880 0.9880 0.9480 0.96000.9400 0.9700 0.9000 0.9700 0.9680 0.9480 0.9480 0.96000.9200 0.9500 0.9200 0.9700 0.9480 0.9480 0.9480 0.9800];》[z,ans]=Edmonds(a)运行结果：z =0 0 1 0 0 0 0 01 0 0 0 0 0 0 00 0 0 0 1 0 0 00 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0ans =7.2240。
匈牙利算法模板
匈⽛利算法模板 匈⽛利算法可以求解最⼤匹配数，其基本思路是不断地寻找增⼴路，由于增⼴路肯定是奇数个边，并且⾮匹配边⽐匹配边多⼀条，因此找到增⼴路以后调换匹配边和⾮匹配边的就可以使匹配边多⼀条，不断重复这个过程即可。
模板如下：第⼆次整理：struct Hungarian{int n; //顶点的数量int match[maxn];int check[maxn];vector<int> G[maxn];void init(){for(int i=0; i<=n; i++) G[i].clear();}void add_edge(int u, int v){G[u].push_back(v);G[v].push_back(u);}bool dfs(int u){for(int i=0; i<G[u].size(); i++){int v = G[u][i];if(!check[v]){check[v] = 1;if(match[v]==-1 || dfs(match[v])){match[u] = v;match[v] = u;return true;}}}return false;}int hungarian(){int ans = 0;memset(match, -1, sizeof(match));for(int u=1; u<=n; u++){if(match[u] == -1){memset(check, 0, sizeof(check));if(dfs(u)) ++ans;}}return ans;}}hun;const int maxn = 1000 + 10;struct Hungarian{int n; //顶点的数量int match[maxn];int check[maxn];vector<int> G[maxn]; //点的连接关系void Init(){for(int i=0; i<=n; i++)G[i].clear();}void AddEdge(int u, int v){G[u].push_back(v);G[v].push_back(u);}bool dfs(int u){for(int i=0; i<G[u].size(); i++){int v = G[u][i];if(!check[v]) //不在增⼴路中{check[v] = 1;if(match[v]==-1 || dfs(match[v])) {match[u] = v;match[v] = u;return true;}}}return false; //不存在增⼴路}int hungarian(){int ans = 0;memset(match, -1, sizeof(match));for(int u=1; u<=n; u++){if(match[u] == -1){memset(check, 0, sizeof(check));if(dfs(u))++ans;}}return ans;}}hun;应⽤实例：USACO stall4/*ID: m1500293LANG: C++PROG: stall4*/#include <cstdio>#include <cstring>#include <algorithm>#include <vector>using namespace std;const int maxn = 1000 + 10;struct Hungarian{int n; //顶点的数量int match[maxn];int check[maxn];vector<int> G[maxn]; //点的连接关系void Init(){for(int i=0; i<=n; i++)G[i].clear();}void AddEdge(int u, int v){G[u].push_back(v);G[v].push_back(u);}bool dfs(int u){for(int i=0; i<G[u].size(); i++){int v = G[u][i];if(!check[v]) //不在增⼴路中{check[v] = 1;if(match[v]==-1 || dfs(match[v])) {match[u] = v;match[v] = u;return true;}}}return false; //不存在增⼴路}int hungarian(){int ans = 0;memset(match, -1, sizeof(match));for(int u=1; u<=n; u++){if(match[u] == -1){memset(check, 0, sizeof(check));if(dfs(u))++ans;}}return ans;}}hun;int main(){freopen("stall4.in", "r", stdin);freopen("stall4.out", "w", stdout);int N, M; //N个奶⽜ M个围栏scanf("%d%d", &N, &M);hun.n = N+M;hun.Init();for(int i=1; i<=N; i++){int num;scanf("%d", &num);while(num--){int t;scanf("%d", &t);hun.AddEdge(i, N+t);}}printf("%d\n", hun.hungarian());return0;}。
匈牙利算法（二分图）
匈⽛利算法（⼆分图）---------------------------------------------------------------------题材⼤多来⾃⽹络，本篇由神犇整理基本概念—⼆分图⼆分图：是图论中的⼀种特殊模型。
若能将⽆向图G=(V,E)的顶点V划分为两个交集为空的顶点集，并且任意边的两个端点都分属于两个集合，则称图G为⼀个为⼆分图。
匹配：⼀个匹配即⼀个包含若⼲条边的集合，且其中任意两条边没有公共端点。
如下图，图3的红边即为图2的⼀个匹配。
1 最⼤匹配在G的⼀个⼦图M中，M的边集中的任意两条边都不依附于同⼀个顶点，则称M是⼀个匹配。
选择这样的边数最⼤的⼦集称为图的最⼤匹配问题,最⼤匹配的边数称为最⼤匹配数.如果⼀个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。
如果在左右两边加上源汇点后，图G等价于⼀个⽹络流，最⼤匹配问题可以转为最⼤流的问题。
解决此问的匈⽛利算法的本质就是寻找最⼤流的增⼴路径。
上图中的最⼤匹配如下图红边所⽰：2 最优匹配最优匹配⼜称为带权最⼤匹配，是指在带有权值边的⼆分图中，求⼀个匹配使得匹配边上的权值和最⼤。
⼀般X和Y集合顶点个数相同，最优匹配也是⼀个完备匹配，即每个顶点都被匹配。
如果个数不相等，可以通过补点加0边实现转化。
⼀般使⽤KM算法解决该问题。
3 最⼩覆盖⼆分图的最⼩覆盖分为最⼩顶点覆盖和最⼩路径覆盖：①最⼩顶点覆盖是指最少的顶点数使得⼆分图G中的每条边都⾄少与其中⼀个点相关联，⼆分图的最⼩顶点覆盖数=⼆分图的最⼤匹配数；②最⼩路径覆盖也称为最⼩边覆盖，是指⽤尽量少的不相交简单路径覆盖⼆分图中的所有顶点。
⼆分图的最⼩路径覆盖数=|V|-⼆分图的最⼤匹配数；4 最⼤独⽴集最⼤独⽴集是指寻找⼀个点集，使得其中任意两点在图中⽆对应边。
对于⼀般图来说，最⼤独⽴集是⼀个NP完全问题，对于⼆分图来说最⼤独⽴集=|V|-⼆分图的最⼤匹配数。
匈牙利算法 浅析 带例子
什么是二分图，什么是二分图的最大匹配，二分图的最大匹配有两种求法，第一种是最大流（我在此假设读者已有网络流的知识）；第二种就是我现在要讲的匈牙利算法。
这个算法说白了就是最大流的算法，但是它跟据二分图匹配这个问题的特点，把最大流算法做了简化，提高了效率。
匈牙利算法其实很简单，但是网上搜不到什么说得清楚的文章。
所以我决定要写一下。
最大流算法的核心问题就是找增广路径（augment path）。
匈牙利算法也不例外，它的基本模式就是：初始时最大匹配为空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个。
最大匹配算法匈牙利算法
经有的匹配做下修改，即和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.匈牙利算法在计算机题目中的应用实例4.如何利用匈牙利算法解决计算机题目正文匈牙利算法是一种解决组合优化问题的算法，特别是在图论中寻找最大匹配问题方面具有广泛的应用。
匈牙利算法在计算机科学领域也具有重要意义，很多计算机题目都可以通过匈牙利算法来解决。
本文将从以下几个方面详细介绍匈牙利算法在计算机题目中的应用。
首先，让我们了解一下匈牙利算法的基本原理。
匈牙利算法是一种贪心算法，它通过不断迭代寻找图中的匹配点对，从而找到一个最大匹配。
匈牙利算法的核心思想是尽可能地找到一条 augmenting path（增广路径），通过这条路径可以改进现有的匹配，从而得到一个更大的匹配。
在计算机题目中，匈牙利算法可以应用于很多问题，例如任务分配、资源调度、数据融合等。
这些问题往往可以抽象为图论中的最大匹配问题。
通过匈牙利算法，我们可以在较短的时间内找到一个较优的解决方案。
下面我们通过一个具体的实例来说明如何利用匈牙利算法解决计算机题目。
假设有一个任务分配问题，需要为一组任务分配一组工人。
每个工人完成不同任务的效率不同，我们希望在保证所有任务都能完成的前提下，使得总效率最大。
这个问题可以抽象为一个图，其中节点表示任务和工人，边表示任务与工人之间的效率关系。
匈牙利算法可以帮助我们找到一个最优的任务分配方案，使得总效率最大。
总之，匈牙利算法作为一种解决组合优化问题的算法，在计算机题目中具有广泛的应用。
通过匈牙利算法，我们可以在较短的时间内找到一个较优的解决方案。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
0 0 0 1 1 0 0 0
15
3 ◎ 2 2
3 ◎ Ø 5 1 ◎ 4 4 6 ◎ Ø 4
得到4个独 立零元素， 所以最优解 矩阵为：
练习：
费 工作 用 人员
A
7
B
5
C
9
D
8
E
11
甲
乙
丙 丁 戊
9
8 7 4
12
5 3 6
7
4 6 7
11
6 9 5
0 13 11 2 6 0 10 11 0 5 7 4 0 1 4 2
4 2
0 13 7 0 6 0 6 9 0 5 3 2 0 1 0 0
Ø 0 0 13 7 ◎ 6 0 6 9 ◎ ◎ 0 5 3 2 ◎ Ø 0 0 1 0 Ø
0 0 1 0
0 0 1 1 0 0 0 0 0 0 1 0
例二、 有一份中文说明书，需译成英、日、德、俄四种 文字，分别记作A、B、C、D。现有甲、乙、丙、丁四 人，他们将中文说明书译成不同语种的说明书所需时 间如下表所示，问如何分派任务，可使总时间最少？
任务
人员
例一：
任务
人员
A 2
10 9 7
B 15
4 14 8
C 13
14 16 11
D 4
15 13 9
甲
乙 丙 丁
2 10 9 7
15 13 4 4 14 15 14 16 13 8 11 9
2 4
9
7
0 13 11 2 6 0 10 11 0 5 7 4 0 1 4 2
2 2 4 4 ◎ 0
◎
0 4 2 4 5 Ø 3 ◎ 0 0 1 ◎ 1 3 0 Ø 3 5 1 0 Ø 2 3 0 5
√
√
√ l =m=4 < n=5
2 2 4 4 ◎ 0
◎
0 4 2 4 5 Ø 3 ◎ 0 0 1 ◎ 1 3 0 Ø 3 5 1 0 Ø 2 3 0 5
第三步，作最少的直线覆盖所有0元素：
4 ◎ 2 3 4 ◎ √ 1 Ø 4 ◎ 4 3 √ 7 1 Ø √ 5
独立零元素的个数m等于最少直线数l，即l＝m=3<n=4； 第四步，变换矩阵(bij)以增加0元素：没有被直线 覆盖的所有元素中的最小元素为1，然后打√各行都减 去1；打√各列都加上1，得如下矩阵，并转第二步进 行试指派：
5 9 0 1 5 4 0 9 3 7 6 0 －5
4 0 2 3
5 4 0 1 0 4 0 4 3 7 1 0
4 ◎ 2 3
4 ◎ 1 Ø 4 ◎ 4 3 找到 3 个独立零元素 Ø 但 m = 3 < n = 4 7 1 5
√
0 1 3 2 0
0 3 0 3 6 0 2 0 2 0 0 3 0 2 3 0 4 4 0 6
Ø 0 1 3 2 ◎ 0
◎
0 3 0 3 பைடு நூலகம் ◎ 6 0 2 Ø 0 Ø ◎ 2 0 0 3 Ø 2 3 ◎ 0 0 Ø 4 4 0 6
4 ◎ 2 3
4 ◎ √ Ø 4 1 ◎ 4 3 √ 7 1 Ø √ 5
3 ◎ 2 2
3 ◎ 1 Ø 5 ◎ 4 4 6 0 Ø 4
3 4 0 1 2 0 2 6
0 1 0 0 0 0 1 0
3 0 0 5 4 4 0 0
√ √
√ √ √ √
√
l =m=4 < n=5
1 2 4 3 ◎ 0
◎
0 3 1 3 6 ◎ 3 Ø 0 0 2 Ø 1 3 0 Ø 2 4 ◎ 0 0 3 3 Ø 5 0
√ √
√ √ √ √
0 1 3 2 0
0 3 0 3 6 0 2 0 2 0 0 3 0 2 3 0 4 4 0 6
9
8 6 11
7 9 8 7 4
5 9 8 11 5 7 12 7 11 9 5 4 6 94 3 6 9 63 6 7 5 11 4
2 2 4 4 0
0 4 3 6 5 0 4 2 1 0 2 5 0 3 6 3 2 3 1 7
第三步：作最少的直线覆盖所有0元素。 (1)对没有◎的行打√号； (2)对已打√号的行中所有含Ø元素的列打√号； (3)再对打有√号的列中含◎ 元素的行打√号；
(4)重复(2)，(3)直到得不出新的打√号的行、列为止； (5)对没有打√号的行画横线，有打√号的列画纵线， 这就得到覆盖所有0元素的最少直线数 l 。l 应等于m， 若不相等，说明试指派过程有误，回到第二步(4)，另 行试指派；若 l＝m < n，须再变换当前的系数矩阵， 以找到n个独立的0元素，为此转第四步。 第四步：变换矩阵(bij)以增加0元素。 在没有被直线覆盖的所有元素中找出最小元素，然后 打√各行都减去这最小元素；打√各列都加上这最小元 素（以保证系数矩阵中不出现负元素）。新系数矩阵 的最优解和原问题仍相同。转回第二步。
1 2 4 3 0
0 3 1 3 6 0 3 0 2 0 1 3 0 2 4 0 3 3 0 5
1 2 4 3 0
0 3 1 3 6 0 3 0 2 0 1 3 0 2 4 0 3 3 0 5
1 2 4 3 ◎ 0
28
此问题有多个最优解
◎ 0 1 3 2 0 Ø
Ø 0
3
Ø 0
◎ 0
Ø 0
6 2
◎
2
Ø 0
0 4
2 4
3
◎ 0
3 ◎ 0 3 Ø 0 6
0 Ø 1 3 2 ◎ 0
Ø
0 6 2
3
Ø 0
◎ 0
◎
0 2
Ø 0
◎
0 4
2 4
3
Ø 0
3 ◎ 0 3 Ø 0 6
A
6 4 3
B
7 5 1
C
11 9 10
D
2 8 4
甲 乙 丙
丁
5
9
8
2
求解过程如下：
第一步，变换系数矩阵：
6 4 (c ij ) 3 5 7 11 2 2 4 5 9 8 1 10 4 1 9 8 2 2
4 0 2 3
第二步，试指派：
◎
0 3 1 3 √ √ 6 ◎ 3 Ø 0 0 2 Ø 1 3 √ 0 √ Ø 2 4 ◎ 0 0 3 3 Ø 5 0
√ √
√
1 2 4 3 ◎ 0
◎
0 3 1 3 6 ◎ 3 Ø 0 0 2 Ø 1 3 0 0 0 Ø 2 4 ◎ 3 3 Ø 5 0
匈牙利算法示例
（二）、解题步骤： 指派问题是0-1 规划的特例，也是运输问题的特例， 当然可用整数规划，0-1 规划或运输问题的解法去求 解，这就如同用单纯型法求解运输问题一样是不合算 的。利用指派问题的特点可有更简便的解法，这就是 匈牙利法，即系数矩阵中独立 0 元素的最多个数等于 能覆盖所有 0 元素的最少直线数。
-1 -2
2 2 4 4 0
0 4 2 4 5 0 3 0 1 0 1 3 0 3 5 1 2 3 0 5
2 2 4 4 ◎ 0
◎
0 4 2 4 5 Ø 3 ◎ 0 0 1 ◎ 1 3 0 Ø 3 5 1 0 Ø 2 3 0 5
第一步：变换指派问题的系数矩阵（cij ）为(bij)，使 在(bij)的各行各列中都出现0元素，即 (1) 从（cij）的每行元素都减去该行的最小元素； (2) 再从所得新系数矩阵的每列元素中减去该列的最 小元素。
第二步：进行试指派，以寻求最优解。 在(bij)中找尽可能多的独立0元素，若能找出n个独 立0元素，就以这n个独立0元素对应解矩阵(xij)中的元 素为1，其余为0，这就得到最优解。找独立0元素，常 用的步骤为： (1)从只有一个0元素的行(列)开始，给这个0元素加 圈，记作◎ 。然后划去◎ 所在列(行)的其它0元素，记 作Ø ；这表示这列所代表的任务已指派完，不必再考 虑别人了。 (2)给只有一个0元素的列(行)中的0元素加圈，记作 ◎；然后划去◎ 所在行的0元素，记作Ø ． (3)反复进行(1)，(2)两步，直到尽可能多的0元素都 被圈出和划掉为止。
(4)若仍有没有划圈的0元素，且同行(列)的0元素至 少有两个，则从剩有0元素最少的行(列)开始，比较这 行各0元素所在列中0元素的数目，选择0元素少的那列 的这个0元素加圈(表示选择性多的要“礼让”选择性 少的)。然后划掉同行同列的其它0元素。可反复进行， 直到所有0元素都已圈出和划掉为止。
（5）若◎ 元素的数目m 等于矩阵的阶数n，那么这指 派问题的最优解已得到。若m < n, 则转入下一步。
用匈牙利法求解下列指派问题，已知效率矩 阵分别如下：
7 13 15 11
9 10 12 12 16 17 16 14 15 12 15 16
3 8 8 7 6 4 8 4 9 10
2 10 2 2 2 6 9 7 3 9
3 7 5 5 10