指派问题的匈牙利解法
指派问题的匈牙利法
第三步：作最少的直线覆盖所有0元素。 (1)对没有◎的行打√号； (2)对已打√号的行中所有含Ø元素的列打√号； (3)再对打有√号的列中含◎ 元素的行打√号；
(4)重复(2)，(3)直到得不出新的打√号的行、列为止； (5)对没有打√号的行画横线，有打√号的列画纵线， 这就得到覆盖所有0元素的最少直线数 l 。l 应等于m， 若不相等，说明试指派过程有误，回到第二步(4)，另 行试指派；若 l＝m < n，须再变换当前的系数矩阵， 以找到n个独立的0元素，为此转第四步。
√
l =m=4 < n=5
2 ◎0 4 2 4 2 5 Ø0 3 ◎0 4 1 ◎0 1 3 4 Ø0 3 5 1 ◎0 2 3 0Ø 5
1 0 3 1 3 2 6 0 3 0 4 2 0 1 3 3 0 2 4 0 0 3 3 0 5
1 0 3 1 3 2 6 0 3 0 4 2 0 1 3 3 0 2 4 0 0 3 3 0 5
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
28
此问题有多个最优解
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
Ø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
15 14 6 6 10
4 10 7 10 9
减去最小元素
5 0 2 0 2
2
3
0
0
指派问题的匈牙利算法
摘要在企业、公司的运营与管理中，管理者总是希望把人员最佳分派以发挥其最大工作效率，从而降低成本、提高效益。
然而，如果没有科学的方法是很难实现优化管理的，由此我们引入了指派问题。
指派问题多是求项目的工时最少，而很多情况下人们并不关心项目总工时的多少，而只关心项目能否在最短的时间内完成，即历时最少的指派问题。
这类问题研究的是n个人执行n项任务，执行每项任务的人数以及总的指派人项数均有限制，要求最优指派。
在运筹学中求解整数规划的指派问题通常是通过匈牙利算法来求解，但指派问题也可以归结为一个0-1整数规划问题，本文先对指派问题进行陈述，引出对实际问题的求解。
在指派问题的背景、描述中充分理解该问题，先运用匈牙利算法实现指派问题，然后再建立一个0-1整数规划模型，并运用matlab和lingo编译程序对问题进行编译，运用软件解决模型问题，最终实现指派问题在实际问题中的运用。
通过运用匈牙利算法和0-1整数规划同时对指派问题求解，我们发现用0-1整数规划的方法来求解可以更简单，也更方便程序的阅读和理解。
与此同时，我们还对0-1整数规划问题由整数数据深入研究到小数数据。
最后通过实例来说明运用matlab，lingo编译程序来解决整数规划问题的简便和有效性。
关键词：指派问题；匈牙利算法；0-1整数规划；matlab模型；lingo模型AbstractIn business, the company's operations and management, managers always want the best distribution of the staff to maximize their efficiency, reduce costs and improve efficiency. However, if there is no scientific method is difficult to achieve optimal management, which we introduced the assignment problem. Multi-assignment problem is to get the project working hours at least, and in many cases people do not care about how much the total project work, but only care about whether the project can be completed within the shortest possible time, that lasted for at least the assignment problem. Such problems is the n individual execution of tasks n, the number of people to perform each task and assign the total number of items are restricted to two people, requiring the optimal assignment. Integer programming in operations research for solving the assignment problem is usually solved by Hungarian algorithm, but the assignment problem can be reduced to a 0-1 integer programming problem, this paper first to make a statement on the assignment problem, leads to the solution of practical problems. Assignment problem in the background to fully understand the problem description, the first assignment problem using Hungarian algorithm, and then a 0-1 integer programming model and compiler using matlab and the lingo of the problem to be compiled using the software solution model problem Ultimately in the assignment of the application in practical problems. By using the Hungarian algorithm and the 0-1 integer programming to solve assignment problems simultaneously, we found that 0-1 integer programming method to solve a more simple and easier to read and understand the program. At the same time, we also 0-1 integer programming problem in-depth study by the integer data to a decimal data. Finally, an example to illustrate the use of matlab, lingo compiler to solve the integer programming problem is simple and effective.Keywords:assignment problem; Hungarian algorithm; 0-1 integer programming;matlab model; lingo model目录1. 问题陈述 (1)2. 指派问题的背景 (1)3. 指派问题的描述 (1)3.1 指派问题的一般形式 (1)3.2 问题的数学模型一般形式 (2)3.3 目标函数极大化的指派问题 (2)4．指派问题实现 (3)4.1 匈牙利算法 (3)4.1.1 匈牙利算法的理论基础 (3)4.1.2 匈牙利算法的实现步骤 (3)4.1.3 匈牙利算法实现指派问题 (4)4.2 0-1整数规划 (5)4.2.1 模型假设 (6)4.2.2 模型建立 (6)4.2.3 模型求解 (7)5. 问题的深入（0-1整数规划） (10)5.1 模型建立 (10)5.2 模型求解 (11)5.2.1 用matlab求解问题 (11)5.2.2 用lingo求解问题 (12)6. 结论 (14)6.1 总结概论 (14)6.2 具体分工.................................. 错误！未定义书签。
匈牙利法求解指派问题
然后划去所在的列的其他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行有直线覆盖时，令；无直线覆盖时。
指派问题匈牙利算法最大值
指派问题匈牙利算法最大值
指派问题是一个优化问题，旨在确定如何将 n 个任务分配给 n 个人员，以便完成总成本最小或总利润最大。
匈牙利算法是解决指派问题的经典算法之一，通过寻找增广路径来找到最大权值的匹配。
在指派问题中，我们有一个 n x n 的成本矩阵，其中的每个元素表
示将特定任务分配给特定人员的成本或利润。
问题的目标是找到一种分配方式，使得总成本最小或总利润最大。
匈牙利算法是一种基于图论的算法，它通过构建二分图和寻找增广路径来解决指派问题。
算法的核心思想是通过不断改进当前的匹配，直到找到最优解。
具体来说，匈牙利算法的步骤如下：
1. 初始化一个空的匹配集合。
2. 对于每个任务，找到一个未被分配的人员，并将其分配给该任务。
如果该任务没有未被分配的人员，则考虑将其他任务分配给当前人员，并将当前任务分配给其它人员。
3. 如果存在一个未被匹配的任务，寻找一条从该任务出发的增广路径。
增广路径是一条交替经过匹配边和非匹配边的路径，起点和终点都是未匹配的任务。
4. 如果存在增广路径，则改进当前的匹配，即通过将增广路径上的
非匹配边变为匹配边，并将增广路径上的匹配边变为非匹配边。
5. 重复步骤3和步骤4，直到不存在增广路径为止。
匈牙利算法的运行时间复杂度为 O(n^3)，其中 n 是任务或人员的数量。
该算法可以找到指派问题的最优解，并且在实践中表现良好。
总之，指派问题是一个重要的优化问题，而匈牙利算法是一种解决指派问题的经典算法。
通过构建二分图并寻找增广路径，匈牙利算法可以找到指派问题的最优解。
指派问题的最优解法
指派问题的最优解法指派问题是一个最优化问题，在给定若干个任务和执行者（或机器）的情况下，要求将每个任务指派给一个执行者，并使得总体的执行成本或者效益最优。
指派问题可以用匈牙利算法（Hungarian algorithm）或者KM算法（Kuhn-Munkres algorithm）来求解，这两个算法是目前被广泛采用的指派问题求解方法。
匈牙利算法是一个具有全局优势的贪心算法，它通过不断优化当前的局部选择，最终得到全局最优解。
其基本思想是通过给任务和执行者之间的边标注权重，然后选取最小权重的边进行指派，如果发现某个任务或者执行者已经被指派，就将其它相关的边进行更新，并继续寻找最小权重的边进行指派，直到所有的任务都得到指派。
KM算法是匈牙利算法的一种更加高效的变体。
它首先将指派问题转化为一个最大权匹配问题，然后通过不断调整边的权重，使得每次迭代都可以找到一个指派边的增广路径，并更新相应的匹配结果。
KM算法的核心思想是通过对匹配结果进行调整，减小局部优势并增加全局优势。
无论是匈牙利算法还是KM算法，在最坏情况下的时间复杂度都是O(n^3)，其中n表示任务和执行者的数量。
这两个算法的主要区别在于实现的复杂度和算法的效率，KM算法相对于匈牙利算法来说具有更好的性能。
除了匈牙利算法和KM算法之外，还有一些其他的指派问题求解方法，例如启发式搜索、遗传算法等。
这些方法一般适用于指派问题的规模比较大、复杂度比较高的情况下，但是相对于匈牙利算法和KM算法，它们的效率和准确性可能会有所降低。
总之，指派问题的最优解法可以通过匈牙利算法或者KM算法来求解，具体选择哪一种方法可以根据问题的规模和复杂度来决定。
求解指派问题的匈牙利算法.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 ，最优指派还无法看出。
指派问题的匈牙利法
4 0 2 3
5 9 0 1 5 4 0 9 3 7 6 0
4 0 2 3
5 4 0 1 0 4 0 4 3 7 1 0
第二步，试指派： 第二步，试指派：
－5
举例说明 1）表上作业法 2）匈牙利法
例 有四个工人和四台不同的机床，每位工人在不 同的机床上完成给定的任务的工时如表5.12所示， 问安排哪位工人操作哪一台机床可使总工时最少？
任务1 工人1 工人2 工人3 工人4 2 15 13 4
任务2 10 4 14 7
任务3 3 14 16 13
任务4 7 8 11 9
0 0 1 0
0 0 1 1 0 0 0 0 0 0 1 0
例二、 例二、 有一份中文说明书，需译成英、 有一份中文说明书，需译成英、日、德、俄四种
文字，分别记作A、 、 、 。现有甲、 文字，分别记作 、B、C、D。现有甲、乙、丙、丁四 人，他们将中文说明书译成不同语种的说明书所需时 间如下表所示，问如何分派任务，可使总时间最少？ 间如下表所示，问如何分派任务，可使总时间最少？
再看一例
请求解如下矩阵表达的指派问题
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
Байду номын сангаас
减去最小元素
5 0 2 0 2 2 3 0 0 0 0 10 5 7 2 9 8 0 0 10 0 6 3 6 5
√
调整可行解
7 4 0 11 0
0 2 0 3 0 0 8 3 5 8 0 0 4 1 4
2 0 0 10 3
指派问题与匈牙利算法
当人数m小于工作数n时，加上n－m个人，例如
7 0 C ′＝ 8 4
0 19 2 8 17 0 7 11 0 0 10 2
0 9 2 8 7 0 7 1 0 0 0 2
1 1 最优解： 最优解： X＝ 1 1
即甲安排做第二项工作、乙做第三项、丙做第四项、丁做第三项。 总分为： ＝ ＋ ＋ ＋ ＝ 总分为：Z＝92＋95＋90＋80＝357
§5.5 指派问题 Assignment Problem
Ch5 Integer Programming
2011年5月9日星期一 Page 6 of 12
用匈牙利法求解：
10 3 22 0 8 17 C ′＝ 13 12 16 9 5 15 7 0 C ′＝ 8 4
5 0 5 7
则 与
′ m w = ∑∑cij xij in
i j
m z = ∑∑cij xij ax
i j
的最优解相同。
§5.5 指派问题 Assignment Problem
Ch5 Integer Programming
2011年5月9日星期一 Page 5 of 12
【例】某人事部门拟招聘4人任职4项工作，对他们综合考评的 例 得分如下表（满分100分），如何安排工作使总分最多。
2011年5月9日星期一 Page 4 of 12
求最大值的指派问题 匈牙利法的条件是：模型求最小值、效率cij≥0 设C=(cij)m×m 对应的模型是求最大值 将其变换为求最小值 令
指派问题匈牙利算法步骤
匈牙利算法是解决二分图最大匹配问题的经典算法。
以下是匈牙利算法的步骤：
初始化：创建一个二分图，并将所有边的匹配状态初始化为未匹配。
选择一个未匹配的左侧顶点作为起始点，开始进行增广路径的寻找。
在增广路径的寻找过程中，首先选择一个未访问的左侧顶点作为当前路径的起点。
针对当前路径的起点，依次遍历与其相邻的右侧顶点。
对于每个右侧顶点，如果该顶点未被访问过，则标记为已访问，并判断该顶点是否已匹配。
如果该右侧顶点未匹配，则找到了一条增广路径，结束路径的寻找过程。
如果该右侧顶点已匹配，将其与之匹配的左侧顶点标记为已访问，并继续寻找与该左侧顶点相邻的右侧顶点，构建新的路径。
如果当前路径无法找到增广路径，则回溯到上一个路径的起点，并继续寻找其他路径。
当所有的路径都无法找到增广路径时，算法结束。
根据最终得到的匹配结果，即可得到二分图的最大匹配。
这些步骤描述了匈牙利算法的基本流程。
具体实现时，可以采用递归或迭代的方式来寻找增广路径，通过标记顶点的访问状态来进行路径的选择和回溯。
算法的时间复杂度为O(V*E)，其中V是顶点的数量，E是边的数量。
运筹学指派问题的匈牙利法
运筹学课程设计指派问题的匈牙利法专业：姓名：学号：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、 把各行元素分别减去本行元素的最小值；然后在此基础上再把每列元素减去本列中的最小值。
⎪⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⇒⎪⎪⎪⎪⎪⎪⎭⎫ ⎝⎛0 4 3 2 04 0 5 0 01 2 3 2 03 7 7 1 08 11 0 3 06 10 12 9 610 6 14 7 67 8 12 9 61014 17 9 712 15 7 8 4 此时每行及每列中肯定都有0元素了。
2、 确定独立零元素，并作标记。
（1）、首先逐行判断是否有含有独立0元素的行，如果有，则按行继续处理；如没有，则要逐列判断是否有含有独立0元素的列，若有，则按列继续处理。
若既没有含有独立0元素的行，也没有含有独立0元素的列，则仍然按行继续处理。
（2）在按行处理时，若某行有独立0元素，把该0元素标记为a ，把该0所在的列中的其余0元素标记为b ；否则，暂时越过本行，处理后面的行。
把所有含有独立0元素的行处理完毕后，再回来处理含有2个以及2个以上的0元素的行：任选一个0做a 标记，再把该0所在行中的其余0元素及所在列中的其余0元素都标记为b 。
（3）在按列处理时，若某列有独立0元素，把该0元素标记为a ，把该0所在的行中的其余0元素标记为b ；否则，暂时越过本列，处理后面的列。
把所有含有独立0元素的列处理完毕后，再回来处理含有2个以及2个以上的0元素的列：任选一个0做a 标记，再把该0所在列中的其余0元素及所在行中的其余0元素都标记为b 。
（4）、重复上述过程，即得到独立零元素（标记a 的“0”）⎪⎪⎪⎪⎪⎪⎭⎫ ⎝⎛a b b a b b a 04 3 2 04 05 0 01 2 3 2 037 7 1 08 11 0 3 0a b 3、 若独立零元素等于矩阵阶数，则已经得到最优解，若小于矩阵阶数，则继续以下步骤：（1）、对没有标记a 的行作标记c（2）、在已作标记c 的行中，对标记b 所在列作标记c（3）、在已作标记c 的列中，对标记a 所在的行作标记c（4）、对没有标记c 的行划线，对有标记c 的列划线4、 在未被直线覆盖的所有元素中找出一个最小元素（Xmin ），未被直线覆盖的行（或列）中所有元素都减去这个数。
指派问题匈牙利算法最大值
指派问题匈牙利算法最大值
匈牙利算法(匈牙利算法,也被称为“插入-删除算法”或“排序算法”)是一种整数排序算法,在指派问题中可以将一个整数数组按照一定规则排序,使得所有指派中最大的元素出现的位置都不相同。
以下是匈牙利算法在解决指派问题的最大值问题的步骤:
1. 将数组分为两个部分,左半部分尽可能地小,右半部分尽可能地大。
2. 从右半部分开始,将一个元素与它的指派对象的最大值进行
比较。
如果两个元素之间的指派关系不符合要求,就将它们交换位置。
3. 接下来,从左边半部分开始,将一个元素与它的指派对象的最大值进行比较。
如果两个元素之间的指派关系不符合要求,就将它们交换位置。
4. 重复步骤2和步骤3,直到左半部分的最大值与右半部分的最大值相等。
5. 在最右半部分找到最大的元素,将它与左半部分的最大值交换。
6. 重复步骤1到步骤5,直到数组中的所有元素都被排序。
匈牙利算法的时间复杂度为O(nlogn),其中n为数组的长度。
在实际应用中,该算法通常用于小规模数据的排序,对于大规模数据的
排序则需要使用更高效的算法。
指派问题与匈牙利解法
指派问题与匈⽛利解法指派问题概述：实际中，会遇到这样的问题，有n项不同的任务，需要n个⼈分别完成其中的1项，每个⼈完成任务的时间不⼀样。
于是就有⼀个问题，如何分配任务使得花费时间最少。
通俗来讲，就是n*n矩阵中，选取n个元素，每⾏每列各有1个元素，使得和最⼩。
如下图：指派问题性质：指派问题的最优解有这样⼀个性质，若从矩阵的⼀⾏(列)各元素中分别减去该⾏(列)的最⼩元素，得到归约矩阵，其最优解和原矩阵的最优解相同．匈⽛利法：12797989666717121491514661041071091.⾏归约：每⾏元素减去该⾏的最⼩元素502022300001057298004063652.列归约：每列元素减去该列的最⼩元素502022300001057298004063653.试指派：(1)找到未被画线的含0元素最少的⾏列，即，遍历所有未被画线的0元素，看下该0元素所在的⾏列⼀共有多少个0，最终选取最少个数的那个0元素。
(2)找到该⾏列中未被画线的0元素，这就是⼀个独⽴0元素。
对该0元素所在⾏和列画线。
50202230000105729800406365502022300001057298004063655020223000010572980040636550202230000105729800406365(3)暂时不看被线覆盖的元素，重复(1)(2)直到没有线可以画。
(4)根据(2)找到的0元素个数判断，找到n个独⽴0元素则Success，⼩于n个则Fail.（本例⼦中，n=5，可以看到，第⼀次试指派之后，独⽴0元素有4个，不符合）4.画盖0线：⽬标：做最少的直线数覆盖所有0元素，直线数就是独⽴0元素的个数。
注意：这跟3的线不同；不能⽤贪⼼法去画线，⽐如1 0 01 1 01 0 1若先画横的，则得画3条线，实际只需2条；若先画竖的，将矩阵转置后同理。
步骤3得出的独⽴0元素的位置50202230000105729800406365(1)对没有独⽴0元素的⾏打勾、(2)对打勾的⾏所含0元素的列打勾(3)对所有打勾的列中所含独⽴0元素的⾏打勾(4)重复(2)(3)直到没有不能再打勾(5)对打勾的列和没有打勾的⾏画画线，这就是最⼩盖0线。
匈牙利法解决人数与任务数不等的指派问题1
匈牙利法解决人数与任务数不等的指派问题于凯重庆科技学院经济管理学院物流专业重庆沙坪坝区摘要：本文将讨论运筹学中的指派问题，而且属于非标准指派问题，即人数与任务数不相等的指派问题，应当视为一个多目标决策问题，首先要求指派给个人任务数目两两之间相差不能超过1，其次要求所需总时间最少，并且给出了该类问题的求解方法。
关键词：运筹学指派问题匈牙利算法系数矩阵解矩阵引言：在日常的生产生活中常遇到这样的问题：有n项任务，有n个人员可以去承担这n 项任务，但由于每位人员的特点与专长不同，各对象完成各项任务所用的时间费用或效益不同；有因任务性质要求和管理上需要等原因，每项任务只能由一个人员承担来完成，这就涉及到应该指派哪个人员去完成哪项任务，才能使完成n项任务花费总时间最短，总费用最少，产生的总效益最佳。
我们把这类最优匹配问题称为指派问题或分配问题。
1.指派问题的解法——匈牙利法早在1955年库恩（w.w.ku.hn）就提出了指派问题的解法，该方法是以匈牙利数学家康尼格（koning）提出的一个关于矩阵中0元素的定理为基础，因此得名匈牙利法（The Hungonrian Method of Assignment）1.1匈牙利解法的基本原理和解题思路直观的讲，求指派问题的最优方案就是要在n阶系数矩阵中找出n个分布于不用行不同列的元素使得他们的和最小。
而指派问题的最优解又有这样的性质：若从系数矩阵C（ij）的一行（列）各元素都减去该行（列）的最小元素，得到新矩阵CB（ij），那么以CB（ij）为系数矩阵求得的最优解和原系数矩阵C（ij）求得的最优解相同。
由于经过初等变换得到的新矩阵CB（ij）中每行（列）的最小元素均为“○”，因此求原指派问题C（ij）的最优方案就等于在新矩阵CB（ij）中找出n个分布于不同行不同列的“○”元素（简称为“独立○元素”），这些独立○元素就是CB（ij）的最优解，同时与其对应的原系数矩阵的最优解。
python的scipy(匈牙利算法)解决教学任务指派问题
python的scipy（匈牙利算法）解决教学任务指派问题python的scipy（匈牙利算法）解决教学任务指派问题参考资料：匈牙利算法求解教学任务指派问题指派问题组合优化理论里的第六章_指派问题的课件问题简介在生活中经常遇到这样的问题，某单位需完成n项任务，恰好有n个人可承担这些任务。
由于每人的专长不同，各人完成任务不同(或所费时间)，效率也不同。
于是产生应指派哪个人去完成哪项任务，使完成n项任务的总效率最高(或所需总时间最小)。
这类问题称为指派问题或分派问题。
教学任务指派问题为指派问题中的一种，考虑教师对课程的擅长程度，教学任务饱满序列和学生对教师的满意度，通过匈牙利算法求得最优课程指派。
算法指派问题一般模型：匈牙利算法：教师与课程一样多把求最大值变为求最小值问题：矩阵C=20-擅长矩阵。
再进行匈牙利算法操作：如果得不到解，则：程序实现：import numpy as npfrom scipy.optimize import linear_sum_assignmentdefprintf(row_ind,col_ind):print("最优教师课程指派：")for i inrange(len(row_ind)):print("教师",row_ind[i],"->课程",col_ind[i],end='; ')print() goodAt=np.array([[18,5,7,16],[10,16,6,5],[11,6,4,7],[13,12,9 ,11]])weakAt=20-goodAtrow_ind,col_ind=linear_sum_assignment(weakAt)print(row _ind)print(col_ind)print(goodAt[row_ind,col_ind])print (goodAt[row_ind,col_ind].sum())printf(row_ind,col_ind)输出结果：教师少与课程多把求最大值变为求最小值问题：矩阵C=10-擅长矩阵。
2023年运筹学指派问题的匈牙利法实验报告
2023年运筹学指派问题的匈牙利法实验报告一、前言运筹学是一门涉及多学科交叉的学科，其主要研究通过数学模型和计算机技术来提高生产和管理效率的方法和技术。
其中，指派问题是运筹学中的重要研究方向之一。
针对指派问题，传统的解决方法是匈牙利法。
本文将基于匈牙利法，通过实验的方法来探讨2023年指派问题的发展。
二、指派问题1.定义指派问题是指在一个矩阵中指定每一行和每一列只选一个数，使得多个行和列没有相同的数，而且总和最小。
2.传统算法匈牙利算法是一种经典的用于解决指派问题的算法。
该算法基于图论的思想，用于寻找最大匹配问题中的最大流。
匈牙利算法的时间复杂度为 $O(n^3)$，但是，该算法仍然被广泛应用于实际问题求解。
三、实验设计1.实验目的本实验旨在探究匈牙利算法在指派问题中的应用以及其发展趋势，同时，通过对比算法运行速度来评估其效率和实用性。
2.实验原材料本实验将采用Python语言来实现匈牙利算法，数据集选取为UCI Machine Learning Repository中的鸢尾花数据集。
3.实验步骤步骤1：导入数据集，并进行数据预处理。
步骤2：计算每个样本在所有类别中的得分，并选取得分最高的类别作为预测结果。
步骤3：使用匈牙利算法对预测结果进行优化，以求得更优的分类方案。
步骤4：对比优化前后的分类结果，评估算法的实用性和效率。
四、实验结果本实验的最终结果表明，匈牙利算法在指派问题中的应用具有很好的效果。
实验数据表明，经过匈牙利算法优化后，分类器的准确率有了显著提高，分类结果更加精确。
同时，通过对比算法运行时间，也发现该算法具有较高的运行速度和效率。
五、实验结论本实验通过大量数据实验表明，匈牙利算法在指派问题中的应用具有很高的效率和精度。
将算法运用到实际生产和管理中，可有效地提高生产效率和管理水平。
但是，由于算法的时间复杂度比较高，因此在实际运用过程中需要合理选择算法，并对算法进行优化，以确保其效率达到最大化。
指派问题——匈牙利法
指派问题的匈牙利解法
为 m，令矩阵 B (bij )nn , bij m cij ，则 以 B为效率矩阵的最小化指派问题和以C为 效率矩阵的原最大化指派问题有相同的最优
解；
非标准形式的指派问题
(2) 资源数量(人数等)与事件数不等的指派
•若资源少，事件多，则增加一些虚拟的 资源点，这些虚拟的资源做事件的效率 系数为0，可理解为这些费用(成本)实际 上不会发生；
若◎元素的数目m=n，则该指派问题的最优 解已经得到，否则转入Step 3；
13
指派问题的匈牙利解法——步骤（续）
Step 3. 设有 m<n 个◎, 找最少覆盖所有0的直线 1) 对没有◎的行打√ 2) 对已打√行中含所在列打√ 3) 对已打√列中含◎所在行打√ 4) 重复2)~3), 直至没有要打√的行和列为止 5) 对没有打√的行划横线, 对打√的列划竖线 得到最少覆盖所有0的直线数l。
nn
n
n
cijxij ckjx kj (s) x kj
i1 j1
j1
j1
ik
nn
n
cijxij ckjx kj (s)
i1 j1
j1
ik
z (s)
指派问题的匈牙利解法
• 根据此定理，可以对 做如下改变，目的是 找出C 中的 n个不同行不同列的0元素：
0
第6章指派问题与旅行商问题
第6章 指派问题与旅行商问题一、指派问题的匈牙利算法1、最小化指派效益矩阵（或费用矩阵）的每一行各元素分别减去该行中的最小元素；→新效益矩阵（或新费用矩阵）的每一列各元素分别减去该列中的最小元素；→判别：如果找出n 个在不同行不同列的0元素，停止运算，最优解即为这些“0”对应位置，否则→标记每一行或列只有一个“0”元素为“*0”，一旦标记，就划去“*0”所在的行或列； →在剩下的矩阵中重复前面步骤。
冲刺模拟试卷（一）第11题冲刺模拟试卷（四）第11题冲刺模拟试卷（五）第11题冲刺模拟试卷（八）第11、12题2、最大化指派在最大化的效益矩阵中，用最大的那个元素分别减去矩阵中的所有元素；→利用上面得“最小化指派”运算即可。
冲刺模拟试卷（三）第11题冲刺模拟试卷（七）第11题二、旅行商问题的匈牙利算法1、问题描述：从点0v 出发经n v v v ,....,,21点各一次，最后返回0v 的路径最短者。
2、求解：利用“最小化指派”运算→读取结果：从0v 开始，从第一行中找出“*0”对应的列i v ，得到i v v →0；从i v 开始，从第二行中找出“*0”对应的列j v ，得到j i v v →；当出现断裂时，选择小集合进行重新调整，选择最短的！冲刺模拟试卷（一）第12题冲刺模拟试卷（二）第7、14题冲刺模拟试卷（四）第12题冲刺模拟试卷（五）第12、13题冲刺模拟试卷（六）第12题冲刺模拟试卷（七）第12题三、哥尼斯堡七桥问题1、欧拉图：联通图中没有奇点存在；联通的非欧拉图：一定会有偶数个奇点。
2、从一般图到最优的欧拉图：相邻的奇点直接增加一条连线；圈上的连线长不过圈的一半；两点之间不能出现重叠（只能有1条或2条连线）。
冲刺模拟试卷（一）第10,、13题冲刺模拟试卷（二）第9、15题冲刺模拟试卷（四）第13题冲刺模拟试卷（六）第10题冲刺模拟试卷（七）第14题冲刺模拟试卷（八）第14题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
指派问题的匈牙利解法
1、 把各行元素分别减去本行元素的最小值；然后在此基础上再把每列元素减去本列中的最小值。
⎪⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⇒⎪⎪⎪⎪⎪⎪⎭⎫ ⎝
⎛0 4 3 2 04 0 5 0 01 2 3 2 03 7 7 1 08 11 0 3 06 10 12 9 610 6 14 7 67 8 12 9 610
14 17 9 712 15 7 8 4 此时每行及每列中肯定都有0元素了。
2、 确定独立零元素，并作标记。
（1）、首先逐行判断是否有含有独立0元素的行，如果有，则按行继续处理；如没有，则要逐列判断是否有含有独立0元素的列，若有，则按列继续处理。
若既没有含有独立0元素的行，也没有含有独立0元素的列，则仍然按行继续处理。
（2）在按行处理时，若某行有独立0元素，把该0元素标记为a ，把该0所在的列中的其余0元素标记为b ；否则，暂时越过本行，处理后面的行。
把所有含有独立0元素的行处理完毕后，再回来处理含有2个以及2个以上的0元素的行：任选一个0做a 标记，再把该0所在行中的其余0元素及所在列中的其余0元素都标记为b 。
（3）在按列处理时，若某列有独立0元素，把该0元素标记为a ，把该0所在的行中的其余0元素标记为b ；否则，暂时越过本列，处理后面的列。
把所有含有独立0元素的列处理完毕后，再回来处理含有2个以及2个以上的0元素的列：任选一个0做a 标记，再把该0所在列中的其余0元素及所在行中的其余0元素都标记为b 。
（4）、重复上述过程，即得到独立零元素（标记a 的“0”）
⎪⎪⎪⎪⎪⎪⎭⎫ ⎝⎛a b b a b b a 0
4 3 2 04 0
5 0 01 2 3 2 03
7 7 1 08 11 0 3 0a b 3、 若独立零元素等于矩阵阶数，则已经得到最优解，若小于
矩阵阶数，则继续以下步骤：
（1）、对没有标记a 的行作标记c
（2）、在已作标记c 的行中，对标记b 所在列作标记c
（3）、在已作标记c 的列中，对标记a 所在的行作标记c
（4）、对没有标记c 的行划线，对有标记c 的列划线
⎪⎪⎪⎪⎫ ⎛1232037710811030 / / \/ \/
4、 在未被直线覆盖的所有元素中找出一个最小元素（Xmin ），
未被直线覆盖的行（或列）中所有元素都减去这个数。
（注：若未被直线覆盖部分是行数<列数，则是按行减，反之则按列）。
⎪⎪⎪⎪⎪⎪⎭
⎫ ⎝⎛--04320405000121126601
811030 5、 这样必然出现负元素，所以对负元素所在列（或行）中各
元素都加上这一最小元素（Xmin ）以消除负数。
这样，再返回步骤2，确定独立零元素个数。
重复上述操作，直到找出最优解。
特殊问题：
1、
若人数和工作数不等，则用“0”来补全空位 2、 若一个人可作几件事，则可化为相同的“几个人”来接受指派，费用系数相同。
⎪⎪⎪⎪⎪⎪⎪⎭
⎫ ⎝⎛0 4 3 2 14 0 5 0 1 0 1 2 102 6 6 0 08 11 0 3 0/ / /。