分配问题与匈牙利法说课讲解
【算法题】任务分配问题---匈牙利算法
【算法题】任务分配问题---匈⽛利算法⼀、问题描述问题描述：N个⼈分配N项任务，⼀个⼈只能分配⼀项任务，⼀项任务只能分配给⼀个⼈，将⼀项任务分配给⼀个⼈是需要⽀付报酬，如何分配任务，保证⽀付的报酬总数最⼩。
问题数学描述：⼆、实例分析---穷举法在讲将匈⽛利算法解决任务问题之前，先分析⼏个具体实例。
以3个⼯作⼈员和3项任务为实例，下图为薪酬图表和根据薪酬图表所得的cost矩阵。
利⽤最简单的⽅法(穷举法)进⾏求解，计算出所有分配情况的总薪酬开销，然后求最⼩值。
total_cost1 = 250 + 600 + 250 = 1100; x00 = 1,x11 = 1,x22 = 1;total_cost2 = 250 + 350 + 400 = 1000; x00 = 1,x12 = 1,x21 = 1;total_cost3 = 400 + 400 + 250 = 1050; x01 = 1,x10 = 1,x22 = 1;total_cost4 = 400 + 350 + 200 = 950; x01 = 1,x12 = 1,x20 = 1; //最优分配total_cost5 = 350 + 400 + 400 = 1150; x02 = 1,x10 = 1,x21 = 1;total_cost6 = 350 + 600 + 250 = 1150; x02 = 1,x11 = 1,x22 = 1;对于任务数和⼈员数较少时，可利⽤穷举法计算结果。
若将N任务分配给N个⼈员，其包含的所有分配情况数⽬为N!，N增⼤时，穷举法将难以完成任务。
三、匈⽛利算法下⾯简要介绍匈⽛利算法。
其基本的理论基础是针对cost矩阵，将cost矩阵的⼀⾏或⼀列数据加上或减去⼀个数，其最优任务分配求解问题不变。
算法的基本步骤如下：四、实例分析---匈⽛利算法下⾯结合具体实例，分析匈⽛利算法如何解决任务分配问题。
以N = 4为实例，下图为cost列表和cost矩阵。
§2 分配问题与匈牙利法
第二步：寻找独立0元素
50202 23000 0 10 5 7 2 -2 98004 0 6 3 6 5 -2
+2
最小元素为 min{10,5,7,2,6,3,6,5}=2
70202
43000 08350 11 8 0 0 4 04143
它有5个独立0元，得到最优解相应的解矩阵为
（1）任务E必须完成，其他4项中任选3项 完成；
任务 A B C D E 人员
甲
25 29 31 42 37
乙
39 38 26 20 33
丙
34 27 28 40 32
丁
24 42 36 23 45
戊
0 0 0 0M
（2）其中有一人完成两项，其他每人完成一项；
任务 A B C D E 人员
甲
25 29 31 42 37
第二步：在B中寻找位于不同行、不同列的 0元素。
（1）检查B的每行每列，从中找出未加标 记的0元素最少的一排（即行列的统称）， 在该排用()标出一个0元，若该排有多个0 元，则任意标出一个即可；
（2）把刚得到()号标记的0元所在的行、列中 的其余0元划去，用表示；
（3）凡是(0)， 就成为加了标记的0元，返 回（1）重复（1）、（2）、 （ 3），直到所 有0元都加上标记为止。若得到的加()号的0元 素个数等于n，则结束；否则转第三步
0 13 7 0 6069 0532 0100
0 13 11 2 6 0 10 11 0574 0142
0042
独立0元素
0 13 7 0 6069 0532 0100
得解矩阵
0 0 0 1
X
0
1
1 0
整数规划---匈牙利法
x1 (1) 1 0 0 0 x2 0 (1) 1 0 0 x3 0 1 0 0 (1) x4 0 0 (1) 0 0 x5 0 0 1 (1) 1
y1
y2
y3
y4
y5
但礼让原则未必都能得到最大 匹配，其次礼让原则当规模大 时无法使用，且无法用计算机 实现
z' = ∑∑C'ij xij =∑∑Cij xij − a∑xij + b∑xij = ∑Cij xij − a + b = z − a + b
j =1 i =1 n n
利用这个性质，可使原效益矩阵变换为含有很多零 元素的新的矩阵(即每行减去该行的最小值，再每列 也类似)，其余C’ij ≥0. 如果C=(C’ij)有n个不同行，不同列的零元素，以下 简称为独立的零元素，则令矩阵x=( xij )中，对这n个独 立的零元素位置取１，其余取０，代入目标函数得z’＝ ０，它一定是最小（因为C’ij ≥0 ）
Step4:增加(转移)零元素 a．求出未被直线覆盖的元素中的最小值k(本例中 k=2)． b．对打√行减去k，对打√列加上k go to step2
2 (0) 8 11 (0) 5 2 3 (0) 0 13 4
√
5 √ 4 0 √ 5
0 (0) 6 13 (0) 5 4 3 (0) 0 11 2
进一步考虑
指派问题用匈牙利法计算，模型需要满足的形式： （1）目标函数是求最小值 （2）效益矩阵必须是n阶方阵 （3）效益矩阵中每个元素Cij ≥0，且是常数
如人员分配问题：
x1 x2 x3 x4 x5 y1 y2 y3 y4 y5
x1 x2 A = (aij ) = x3 x4 x5 1 0 0 0 0
运筹学指派问题的匈牙利法
运筹学课程设计指派问题的匈牙利法专业：姓名：学号：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件工作。
分配问题与Hungarian算法
分配问题与Hungarian算法分配问题与Hungarian算法分配问题指派问题匈⽛利算法匈⽛利⽅法是⼀种能够在多项式时间内解决分配问题(assignment problem)的组合优化算法。
它由Harold Kuhn 与1955年发展并提出，由于该算法很⼤程度上依赖于先前两位匈⽛利数学家:Denes Konig 和 Jeno Egervary,所以被命名为“匈⽛利⽅法”。
1957年James Munkres重新审视了这个⽅法，证明发现该⽅法是严格polynomial的，所以之后该⽅法也被称为Kuhn-Munkres 算法或者Munkres分配算法。
原始的匈⽛利算法的时间复杂度是,然⽽之后Edmonds和Karp，以及Tomizawa独⽴发现经过⼀定的修改，该算法能改达到的时间复杂度。
Ford和Fulkerson将该⽅法扩展到⼀般运输问题的求解上。
2006年，研究发现Carl Custav Jacobi在19实际就解决了assignment问题，并且在其逝世后的1890年求解过程被以拉丁语形式发表。
指派问题匈⽛利法解决的指派问题应该具有两个约束条件workes 和tasks的数⽬应该相同，即o2o问题。
求解的是最⼩化问题，如⼯作时间的最⼩化、费⽤的最⼩化等等指派问题⽰例：有三个workers: Jim, Steve和Alan，现在有3个⼯作：clean the bathroom, sweep the floors和wash the windows需要交给这三个⼈，每个⼈只能完成⼀个任务，对应的cost matrix如下---Clean bathroom Sweep floors Wash windowsJim$2$3$3Steve$3$2$3Alan$3$3$2那么如何分配任务是开销最⼩就是⼀个指派问题匈⽛利法步骤问题： 假定某单位有甲、⼄、丙、丁、戊五个员⼯，现需要完成A、B、C、D、E五项任务，每个员⼯完成某项任务的时间如下图所⽰，应该如何分配任务，才能保证完成任务所需要的时间开销最⼩？1476015762594.jpg解：1. 写出系数矩阵2. 更新系数矩阵，使系数矩阵的每⼀⾏每⼀列都减去该⾏该列的最⼩值，保证每⼀⾏每⼀列都有0元素出现,参见定理2.3. 选择只有⼀个0元素的⾏或列将该0元素标注为独⽴0元素，并将该0元素所在的列或⾏中0元素划掉，直⾄找不到满⾜条件的⾏或列，需要注意的是在循环时，划掉的0元素不再视为0元素。
分配问题与匈牙利法
7 8 11 9
第一步：初始变换
2 15 13 4 2 10 4 14 15 4 9 14 16 13 9 7 8 11 9 7
0 13 11 2 6 0 10 11 0574 0142
0042
0 13 7 0 6069 0532 0100
找独立0元素
0 13 7 0 6069 0532 0100
（2）操作简单，应用性强。 在当今国际化的市场 竞争中，企业成本和利
润成为衡量其经营绩效的重要参考指标，企业经 营的目标都是以最小化的成本换回最大化的利润 回报。随着现代科技的飞速发展，企业必须适应 时代的潮流，不断进行技术创新和产品研发，在 此过程中，科学合理的决策方案将成为影响企业 发展的重要因素。 匈牙利法不仅可以为企业人事 决策提供可靠的政策建议，同时可以预测和估算 出企业未来一段时期的成本和收益总量，而且操 作方便，应用性强，受到了现代企业管理者的青 睐。
设 1 xij 0
分配第i人完成第j项任务 未分配第i人完成第j项任务
nn
min z
aij xij
i 1 j 1
n
xij 1,
i 1, 2, ..., n
j1
n
s.t . xij 1, j 1, 2, ..., n
i 1
xij
1或0
二
分配问题的匈牙利解法
定义1 效率矩阵
处理方法：用效率矩阵中的最大元素减去矩阵 中的各个元素得到一个新的矩阵，对这个新的 矩阵用匈牙利方法求解。
四
《基于匈牙利法的企业员工任务分配问 题研究》
基金项目：国家社科基金资助项目（06BZZ022） 统计与决策2011年第5期
摘 要： 现代企业的发展，必须依托科学高效的
《运筹学匈牙利法》课件
总结
匈牙利算法的优缺点和适 用范围
匈牙利算法具有较高的精度和效 率，但受数据结构限制，应用对 象有一定局限性。
匈牙利算法的进一步研究 方向
运筹学在日常生活中的重 要性和应用前景
未来可继续深入探究匈牙利算法 和其他优化算法在实际问题中的 应用，完善算法理论和算法应用。
随着科技的不断发展，运筹学在 日常生活中的应用前景越来越广 泛，对提高效率和优化资源分配 具有重要意义。
的权值之和达到最大。
解决方案
匈牙利算法
匈牙利算法是解决二分图匹 配问题最经典的算法之一， 在求解最大权匹配和最小路 径覆盖问题方面都有广泛应 用。
拓展匈牙利算法
拓展匈牙利算法是一种扩展 了匈牙利算法的新算法，可 以有效解决复杂数据结构中 的匹配问题。
Байду номын сангаас
应用案例分析
将匈牙利算法应用于实际问 题的案例分析，深入了解如 何应用该算法求解实际问题， 加深理解和应用。
匈牙利法的目的和意义
匈牙利法可以帮助我们有效解决 二分图匹配问题，例如任务分配、 稳定婚姻问题等。
问题解析
1
最小路径覆盖问题
指在一个有向无环图（DAG）里选出尽
最大权匹配问题
2
可能少的路径，这些路径覆盖了DAG图 上的每个点恰好一次。
是一类用二分图描述的优化问题，给定
一个二分图，找到一个匹配使得匹配边
《运筹学匈牙利法》PPT 课件
运筹学匈牙利法是一种优化算法，用于解决二分图匹配问题。本课件将介绍 匈牙利法的背景、意义、解析以及应用案例分析。
背景介绍
运筹学在实际生活中的应用 匈牙利法的提出背景
运筹学的方法广泛应用于物流、 交通、能源、金融等领域，帮助 优化资源分配，提高效率。
第五讲 分配问题(指派问题)与匈牙利法
n 件工作
y1 ， y2 ， … ， yn 。 已 知 工 人 xi 完 成 工 作 yj 所 需 时 间 为 cij
分派方案满足下述两个条件： 分派方案满足下述两个条件：
1.任一个工人都不能去做两件或两件以上的工作 1.任一个工人都不能去做两件或两件以上的工作 2.任一件工作都不能同时接受两个及以上的工人去做 2.任一件工作都不能同时接受两个及以上的工人去做
min
4 7 6 6 6
8 7 15 12 4 0 4 3 11 8 0 3 0 11 8 9 17 14 10 7 0 2 10 7 3 0 1 7 7 3 9 12 8 7 6 ⇒ 0 3 6 2 1 ⇒ 0 2 3 2 1 7 14 6 10 6 0 1 8 0 4 0 0 5 0 4 0 3 6 4 0 0 2 3 4 0 9 12 10 6 6 min 0 1 3 0 0
5 0 2 0 2 3 0 0 0 10 5 7 9 8 0 0 0 6 3 6
9 8 5 4 0
尝试对所有零元素做标记，确定独立零元素。 尝试对所有零元素做标记，确定独立零元素。 标记 独立零元素
（2）逐列检验 ）
与行检验类似：对只有一个未标记的零元素的列 用记号O将该 与行检验类似：对只有一个未标记的零元素的列，用记号 将该 零元素圈起，然后将被圈起的零元素所在行 零元素圈起，然后将被圈起的零元素所在行的其他未标记的零元 素用记号/划去 划去。 素用记号 划去。 重复列检验，直到没有未被标记的零元素或至少有两个未被标记 没有未被标记的零元素 重复列检验，直到没有未被标记的零元素或 的零元素为止。 的零元素为止。
分配问题（指派问题） 第5讲 分配问题（指派问题）与匈牙利法
4.2-分配问题和匈牙利法
nn
策变量xij=0,则 z cij xij 可取到最小值0,即该分配方案最
优. 如：
i1 j1
0 14 9 3
C
9
20
0 23
23 0 3 8
0
12
14
0
1 0 0 0
X
[ xij ]44
0 0
0 1
1 0
0
0
0
0
0
1
❖ 匈牙利法
匈牙利法的计算步骤
➢ 第一步:找出效率矩阵每行的最小元素,并分别从每行 中减去;
37.7
43.4
C 33.3 29.2
0
32.9 33.1 28.5 26.4
0
38.8 42.2 38.9 29.6
0
37.0 34.7 30.4 28.5
0
35.4
41.8
33.6 31.1
0
执行匈牙利法第一步和第二步：
4.8 0 5.9 4.1 2.5
10.3 0
9.1
1.6
8.7
C 4.8 0 10.4 1.9 5.1
C
[ci ]j n
n
c
c21
22
c
2
n
cn1cn
2
cnn
因此,我们可 得分配问题 的系数矩阵
效率矩阵
❖ 分配问题的标准形式及其数学模型
为了建立标准分配问题的数学模型,我们引入n²个 0－1变量,并且得到该问题的数学模型.
1 xij 0
若若指不派指第派i第人i做人第做j第项j任项务任务（i, j 1, 2,
队员 赵 钱 张 王 周
项目
仰泳 37.7 32.9 38.8 37.0 35.4 蛙泳 43.4 33.1 42.2 34.7 41.8 蝶泳 33.3 28.5 38.9 30.4 33.6 自由泳 29.2 26.4 29.6 28.5 31.1
演示文稿第二题指派问题课件
1 6 0◎ 2 Ø0
3 2 0Ø 0◎ 3
2 Ø0 2 3 ◎0
◎0
4
4
0Ø
总费用为
6 =5+7+6+6+4=28
注：此问题有多个最优解
第十五页，共23页。
分配问题与匈牙利法
第十六页，共23页。
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
总费用为=7+9+4+3+5=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
总费用为=8+9+4+3+4=28
第十七页，共23页。
分配问题与匈牙利法
课堂练习：用匈牙利法求解下列指派问题。
练习1：
练习2：
7 9 10 12
人员
A
B
C
D
E
甲
25
29
31
4237ຫໍສະໝຸດ 乙3938
26
20
33
丙
34
27
28
40
32
丁
24
42
36
23
45
戊
0
0
0
0
M
第二页，共23页。
分配问题与匈牙利法
用匈牙利法求出最优指派方案为：
0 1 0 0 0
0 0 0 1 0
0 0 0 0 1
1 0 0 0 0
0 0 1 0 0
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
0 13 11 2
10 4 14 15 4
9 14 16 13 9
7 8 11 9 7
6 0 10 11
0 5 7 4
0 1
4
2
2）试指派（找独立0元素） 4 2
0 13 7 0
6 0 6 9
0 5 3 2
0 1 0 0
0Ø 13 7 ◎0
6 ◎0 6 9
0◎ 5 3 2
0Ø
分配问题与匈牙利法
Page 1
指派问题的数学模型的标准形式： 设n 个人被分配去做n 件工作，规定每个人只做一件工作，
每件工作只有一个人去做。已知第i个人去做第j 件工作的效率 （ 时间或费用）为Cij(i=1.2…n;j=1.2…n)并假设Cij ≥0。问应 如何分配才能使总效率（ 时间或费用）最高？ 设决策变量
若仍有没有划圈的0元素，且同行(列)的0元素至少有两个，比 较这行各0元素所在列中0元素的数目，选择0元素少这个0元素加 圈(表示选择性多的要“礼让”选择性少的)。然后划掉同行同列 的其它0元素。可反复进行，直到所有0元素都已圈出和划掉为止。
分配问题与匈牙利法
Page 6
若◎ 元素的数目m 等于矩阵的阶数n（即：m＝n），那么这指
所有0元素的最少直线数 l 。
注：l 应等于m，若不相等，说明试指派过程有误，回到第2步，另行试 指派；若 l＝m < n，表示还不能确定最优指派方案，须再变换当前的系 数矩阵，以找到n个独立的0元素，为此转第4步。
分配问题与匈牙利法
Page 7
4) 变换矩阵(bij)以增加0元素
在没有被直线通过的所有元素中找出最小值，没有被直线通过 的所有元素减去这个最小元素；直线交点处的元素加上这个最小 值。新系数矩阵的最优解和原问题仍相同。转回第2步。
1
◎0
Ø0
独立0元素的个数为4 , 指派问题的最优指 派方案即为甲负责D工作，乙负责B工作， 丙负责A工作，丁负责C工作。这样安排 能使总的工作时间最少，为4＋4＋9＋11 ＝28。
分配问题与匈牙利法
派问题的最优解已得到。若m < n, 则转入下一步。
3) 用最少的直线通过所有0元素。其方法：
① 对没有◎的行打“√”； ② 对已打“√” 的行中所有含Ø元素的列打“√” ； ③ 再对打有“√”的列中含◎ 元素的行打“√” ； ④ 重复①、②直到得不出新的打√号的行、列为止； ⑤ 对没有打√号的行画横线，有打√号的列画纵线，这就得到覆盖
即完成4个任务的总时间最少 为：2＋4＋1+8=15
分配问题与匈牙利法
Page 12
例4.7 已知四人分别完成四项工作所需时间如下表，求最优 分配方案。
任务
A
B
C
D
人员
甲
2
15
13
4
乙
10
4
14
15
丙
9
14
16
13
丁
7
8
11
9
分配问题与匈牙利法
Page 13
解：1）变换系数矩阵，增加0元素。
2 15 13 4 2
Page 9
解：1）变换系数矩阵，增加0元素。
6 7 11 2 2
(cij
)
4 3
5 1
9 10
8 4 4 1
5 9 8 2 2
2）试指派（找独立0元素）
4 5 9 0 0 1 5 4 2 0 9 3 3 7 6 0
－5
4 5 4 0
0 1 0 4
2 0 4 3
3 7 1 0
4 5 4 ◎
◎ 1 Ø 4
,
j
1.2.
.n)
Page 2
分配问题与匈牙利法
Page 3
克尼格定理 :
如果从分配问题效率矩阵[aij]的每一行元素中分别减去 (或加上)一个常数ui，从每一列中分别减去(或加上)一个常数 vj，得到一个新的效率矩阵[bij]，则以[bij]为效率矩阵的分配 问题与以[aij]为效率矩阵的分配问题具有相同的最优解。
分配问题与匈牙利法
Page 8
例4.6 有一份中文说明书，需译成英、日、德、俄四种文字， 分别记作A、B、C、D。现有甲、乙、丙、丁四人，他们将 中文说明书译成不同语种的说明书所需时间如下表所示，问 如何分派任务，可使总时间最少？
任务
A
B
C
D
人员
甲
6
7
11
2
乙
4
5
9
8
丙
3
1
10
4
丁
5
9
8
2
分配问题与匈牙利法
线交点处的元素加上这个最小值。得到新的矩阵，重复2）
步进行试指派
分配问题与匈牙利法
Page 11
3 4 3 0
0 1 0 5
2 0 4 4
2
6
0
0
试指派
3 4 3 ◎
◎ 1 Ø 5
2 ◎ 4 4
2
6
◎
Ø
得到4个独立零元素， 所以最优解矩阵为：
0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0
分配问题与匈牙利法
Page 4
指派问题的求解步骤：
1) 变换指派问题的系数矩阵(cij)为(bij)，使在(bij)的各行各列 中都出现0元素，即
从(cij)的每行元素都减去该行的最小元素； 再从所得新系数矩阵的每列元素中减去该列的最小元素。
2) 进行试指派，以寻求最优解。
在(bij)中找尽可能多的独立0元素，若能找出n个独立0元 素，就以这n个独立0元素对应解矩阵(xij)中的元素为1，其余 为0，这就得到最优解。
2 ◎ 4 3
3
7
1
Ø
找到 3 个独立零元素
但m=3<n=4
分配问题与匈牙利法
Page 10
3）作最少的直线覆盖所有0元素
4 5 4 ◎ √
◎ 1 Ø 4
2 ◎ 4 3
3
7
1
Ø
√
独立零元素的个数m等于最少 直线数l，即l＝m=3<n=4；
√
4）没有被直线通过的元素中选择最小值为1，变换系数矩
阵，将没有被直线通过的所有元素减去这个最小元素；直
1 指派第i个人做第j件事 xij 0 不指派第i个人做第j件事 (i, j 1,2,...,n)
分配问题与匈牙利法
指派问题的数学模型为：
nn
minZ
c x ij ij
i 1 j1
n
xij 1
(i 1.2. .n)
j1
n
xij 1
( j 1.2. .n)i1xi Nhomakorabeaj
取0或1(i
分配问题与匈牙利法
Page 5
找独立0元素，常用的步骤为：
从只有一个0元素的行开始，给该行中的0元素加圈，记作◎ 。 然后划去◎ 所在列的其它0元素，记作Ø ；这表示该列所代表的 任务已指派完，不必再考虑别人了。依次进行到最后一行。
从只有一个0元素的列开始（画Ø的不计在内），给该列中的0 元素加圈，记作◎；然后划去◎ 所在行的0元素，记作Ø ，表示 此人已有任务，不再为其指派其他任务了。依次进行到最后一列。