《管理运筹学》分配问题与匈牙利算法
运筹学匈牙利法
运筹学匈牙利法运筹学匈牙利法（Hungarian Algorithm），也叫匈牙利算法，是解决二部图最大（小）权完美匹配（也称作二分图最大权匹配、二分图最小点覆盖）问题的经典算法，是由匈牙利数学家Kuhn和Harold W. Kuhn发明的，属于贪心算法的一种。
问题描述在一个二分图中，每个节点分别属于两个特定集合。
找到一种匹配，使得所有内部的节点对都有连边，并且找到一种匹配方案，使得该方案的边权和最大。
应用场景匈牙利算法的应用场景较为广泛，比如在生产调度、货车调度、学生对导师的指定、电影的推荐等领域内，都有广泛的应用。
算法流程匈牙利算法的伪代码描述如下：进行循环ɑ、选择一点未匹配的点a作为起点，它在二分图的左边β、找出a所有未匹配的点作为下一层节点ɣ、对下一层的每个节点，如果它在右边未匹配，直接匹配ɛ、如果遇到一个已经匹配的节点，进入下一圈，考虑和它匹配的情况δ、对已经匹配的点，将它已经匹配的点拿出来，作为下一层节点，标记这个点作为已被搜索过ε、将这个点作为当前层的虚拟点，没人配它，看能否为它找到和它匹配的点ζ、如果能匹配到它的伴侣，令它们成对被匹配最后输出最大权匹配。
算法优缺点优点：相比于暴力求解二分图最大权匹配来说，匈牙利算法具有优秀的解决效率和高效的时间复杂度，可以在多项式时间（O(n^3)）内解决二分图最大权匹配问题。
缺点：当二分图较大时，匈牙利算法还是有很大的计算复杂度，复杂度不佳，算法有效性差。
此时就需要改进算法或者使用其他算法。
总结匈牙利算法是一个常见的解决二分图最大权匹配问题的算法，由于其简洁、易用、效率优秀等特性，广泛应用于学术和实际问题中。
匈牙利算法虽然在处理较大规模问题时效率不佳，但仍然是一种值得掌握的经典算法。
《管理运筹学》分配问题与匈牙利算法
2019/9/10
第 12页
第4章 整数规划与分配问题
4 5 4 ◎ √
◎ 1 Ø 4
2 ◎ 4 3
3
7
1
Ø
√
√
3 4 3 ◎
◎ 1 Ø 5
2 ◎ 4 4
2
6
0
Ø
3 4
◎ 1 2 ◎ 2 6
3 ◎
Ø 5
4 4
◎
Ø
得到4个独立零元素， 所以 最优解矩阵为：
7
8
11
9
-7
运筹学
0 13 11 2
6 0 10 11
0 5 7 4
0 1
4
2
2019/9/10
第 6页
第4章 整数规划与分配问题
运筹学
0 13 11 2
6 0 10 11
0 5 7 4
0
1
4
2
-0 -0 -4 -2
0 13 7 0 6 0 6 9 0 5 3 2 0 1 0 0
2019/9/10
第 11页
第4章 整数规划与分配问题
运筹学
第三步，作最少的直线覆盖所有0元素：
4 5 4 ◎ √
◎ 1 Ø 4
2 ◎ 4 3
3
7
1
Ø
√
√
独立零元素的个数m等于最少直线数l，即l＝m=3<n=4；
第四步，变换矩阵(bij)以增加0元素：没有被直线覆盖的所有元素中的最小元素为1，然后 打√各行都减去1；打√各列都加上1，得如下矩阵，并转第二步进行试指派：
第4章 整数规划与分配问题
【算法题】任务分配问题---匈牙利算法
【算法题】任务分配问题---匈⽛利算法⼀、问题描述问题描述：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矩阵。
运筹学指派问题的匈牙利法
运筹学课程设计指派问题的匈牙利法专业：姓名：学号：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件工作。
运筹学中匈牙利算法解题步骤
运筹学中匈牙利算法解题步骤解题步骤：指派问题是0-1 规划的特例，也是运输问题的特例，当然可用整数规划，0-1 规划或运输问题的解法去求解，这就如同用单纯型法求解运输问题一样是不合算的。
利用指派问题的特点可有更简便的解法，这就是匈牙利法，即系数矩阵中独立 0 元素的最多个数等于能覆盖所有 0 元素的最少直线数。
第一步：变换指派问题的系数矩阵（c ij）为(b ij)，使在(b ij)的各行各列中都出现0元素，即(1) 从（c ij）的每行元素都减去该行的最小元素；(2) 再从所得新系数矩阵的每列元素中减去该列的最小元素。
第二步：进行试指派，以寻求最优解。
在(b ij)中找尽可能多的独立0元素，若能找出n个独立0元素，就以这n个独立0元素对应解矩阵(x ij)中的元素为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, 则转入下一步。
第三步：作最少的直线覆盖所有0元素。
(1)对没有◎的行打√号；(2)对已打√号的行中所有含Ø元素的列打√号；(3)再对打有√号的列中含◎元素的行打√号；(4)重复(2)，(3)直到得不出新的打√号的行、列为止；(5)对没有打√号的行画横线，有打√号的列画纵线，这就得到覆盖所有0元素的最少直线数 l 。
分配问题与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元素。
2023年运筹学指派问题的匈牙利法实验报告
2023年运筹学指派问题的匈牙利法实验报告一、前言运筹学是一门涉及多学科交叉的学科，其主要研究通过数学模型和计算机技术来提高生产和管理效率的方法和技术。
其中，指派问题是运筹学中的重要研究方向之一。
针对指派问题，传统的解决方法是匈牙利法。
本文将基于匈牙利法，通过实验的方法来探讨2023年指派问题的发展。
二、指派问题1.定义指派问题是指在一个矩阵中指定每一行和每一列只选一个数，使得多个行和列没有相同的数，而且总和最小。
2.传统算法匈牙利算法是一种经典的用于解决指派问题的算法。
该算法基于图论的思想，用于寻找最大匹配问题中的最大流。
匈牙利算法的时间复杂度为 $O(n^3)$，但是，该算法仍然被广泛应用于实际问题求解。
三、实验设计1.实验目的本实验旨在探究匈牙利算法在指派问题中的应用以及其发展趋势，同时，通过对比算法运行速度来评估其效率和实用性。
2.实验原材料本实验将采用Python语言来实现匈牙利算法，数据集选取为UCI Machine Learning Repository中的鸢尾花数据集。
3.实验步骤步骤1：导入数据集，并进行数据预处理。
步骤2：计算每个样本在所有类别中的得分，并选取得分最高的类别作为预测结果。
步骤3：使用匈牙利算法对预测结果进行优化，以求得更优的分类方案。
步骤4：对比优化前后的分类结果，评估算法的实用性和效率。
四、实验结果本实验的最终结果表明，匈牙利算法在指派问题中的应用具有很好的效果。
实验数据表明，经过匈牙利算法优化后，分类器的准确率有了显著提高，分类结果更加精确。
同时，通过对比算法运行时间，也发现该算法具有较高的运行速度和效率。
五、实验结论本实验通过大量数据实验表明，匈牙利算法在指派问题中的应用具有很高的效率和精度。
将算法运用到实际生产和管理中，可有效地提高生产效率和管理水平。
但是，由于算法的时间复杂度比较高，因此在实际运用过程中需要合理选择算法，并对算法进行优化，以确保其效率达到最大化。
分配问题与匈牙利法
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期
摘 要： 现代企业的发展，必须依托科学高效的
运筹学-12分配问题
具体求解过程(6)
• 4.没有找到m个独立的 “0”:
• (1)找最小直线覆盖所有 “0”
• 对没有打的行画横线; • 所有打的列画上垂线. • 找到了覆盖矩阵所有零
元素的最小直线数.
(0) 8 2 5 11 (0) 5 4 2 3 (0) 0 0 11 4 5
O3 26 17 16 19 0
增加一个虚拟工作T5
O4 19 21 23 17 0 O5 17 18 19 17 0
每一个工人干 这项工作需 要的时间比其他工作所需时 间要多的多，为什么？
O2下岗，
O1T1, T5 , O3T3 , O4T4 , O5T2 ,93-27=66
人员少，工作岗位多的情况P.125/4.5
• 如该列没有零元素或有 两个以上零元素(划去的不 计在内),则专下一列,直到 最后一列为止.
0 8 2 5 11 0 5 4 2 3 0 0 0 11 4 5
(0) 8 2 5 11 (0) 5 4 2 3 0 0 0 11 4 5 .
具体求解过程(4)
乙
总时间：101
丙
•加一个虚拟人员戊，
39 34
38 27
26 28
20 40
33 32
其效率为55（最大） 丁 24 42 36 23 45
甲B;乙D;丙C;丁A;戊E 戊 0 0
0
0
0
总时间：165-55=101
人员少，工作岗位多的情况P.125/4.5
25 29 31 42 37 25 0 4 6 17 12 0 4 5 17 7
• 即做2.找到m个独立
“0”
分配问题与匈牙利法
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 24
1. 最大化指派问题
处理方法：设m为最大化指派问题系数矩阵C中最大元素。
令矩阵B＝（m-cij）nn则以B为系数矩阵的最小化指派问题和
原问题有相同的最优解。
例4.9 某人事部门拟招聘4人任职4项工作，对他们综合考评的 得分如下表（满分100分），如何安排工作使总分最多。
分配问题与匈牙利法
Page 7
例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
分配问题与匈牙利法
Page 8
解：1）变换系数矩阵，增加0元素。
6 7 11 2 2
4 5 9 0
(cij
)
4 3
5 1
9 10
8 4 4 1
5 9 8 2 2
0 1 5 4 2 0 9 3 3 7 6 0
运筹学-12分配问题
+2 (0) 8 2 5 -2 11 (0) 5 4 2 3 (0) 0 0 11 4 5 . -2
0 6 0 3 13 0 5 4 4 300 0 9 2 3 .
具体求解过程(8)
• 4.没有找到m个独立的
“0”:
• (3)找独立的“0”元素
• 设工程有A1,A2,A3,A4四项任务，恰有B1,B2,B3,B4个工人去
完成各项的任务,由于任务性质和每个工人的技术水平不 相同，他们完成各项任务所需的时间也不一样.见表:
• 问应当如何分配，即哪个人去完成哪项任务，才能使总 共花去的时间最少？
所需时间 任务 工人
A1
A2
A3
A4
B1
2 15 13 4
补充内容 分配问题
分配问题与匈牙利解法
分配问题
• 有n项任务，恰有n个人可以分别去完成
其中每项，但是由于任务的性质和每个 人的技术专长各不相同，因此每个人去 完成不同的各项任务的效率也不一样。 • 问应当如何分配，即哪个人去完成哪项 任务，才能使总效率最高？ • 如：400混合游泳接力赛。
分配问题（例）
• 证明: 将从(b i j)中得到的数据代入目标函数式
• 有f ’= b i j x i j = (a i j u i v j ) x i j
•
= aijxij uixij vj xij
• = a i j x i j u i v j (因为 u i v j为常数) • 所以min f = a i j x i j与 f’ = b i j x i j等价
乙
总时间：101
丙
•加一个虚拟人员戊，
§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
分配问题(指派问题)与匈牙利法(课堂PPT)
1
0
0
0
0
整体解题思路总结
34
整体解题思路总结
例题：
单位：小时
人1 人2 人3 人4 人5
工作1 4
8
7 15 12
工作2 7
9 17 14 10
工作3 6
9 12 8
7
工作4 6
7 14 6 10
工作5 6
9 12 10 6
35
例题：
整体解题思路总结
4 8 7 15 12
7 9 17 14 10
0
2
3
4
0
0 0 1 0 0
0 1 0 0 0
1
0
0
0
0
0 0 0 1 0
0
0
0
0
1
27
分配方案A=7+9+6+6+6=34
⑩再次寻找独立零元素
逐列检验
4 8 7 15 12
7 9 17 14 10
6
9
12
8
7
6 7 14 6 10
6
9
12
10
6
0 3 0 11 8
（1）逐行检验
对只有一个未标记的零元素的行，用记号O将该零元素圈起，然后 将被圈起的零元素所在列的其他未标记的零元素用记号/划去。
重复行检验，直到每一行都没有未被标记的零元素或至少有两个未 被标记的零元素为止。
表示此事已不能由 其他人来做
（此人已不能做其他事）
0 13 7 0
6
0
6
9
表示此人只能做该事
0
4
1
4
3
4.2-分配问题和匈牙利法
0 0 0 1 0
0 0 1 0 0
0 0 0 0 1
0 1 0 0 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
此问题有多个最优解
匈牙利法
第三种情况
矩阵中所有零元素或被划去,或打上( )号,但打( )号的 零元素个数仍小于n.
整数规划
整数规划的数学模型 设置逻辑变量建立整数规划模型 分配问题与匈牙利法 分支定界法、割平面法 应用举例
§3 分配问题与匈牙利法
分配问题的标准形式及其数学模型
分配问题也称指派问题(assignment problem),在我们现实 生活中,常有各种性质的分配问题.例如：应如何分配若干 项工作给若干个人(或部门)来完成,以达到总体的最佳效果 等等.由于分配问题的多样性,我们有必要定义分配问题的 标准形式.
可用表上作 解:这是一个标准的分配问题.若设0－1变量 业法求解
1 表示学生i翻译语种j xij (i, j 1, 2,3, 4) 0 表示学生i不翻译语种j 则问题的数学模型为
min z 14 x11 9 x12 4 x13 15 x14 11x21 7 x22 9 x23 10 x24 13 x31 6 x32 10 x33 5 x34 17 x41 9 x42 15 x43 13 x44 4 xij 1 i 1, 2,3, 4 j 1 4 s.t. xij 1 j 1, 2,3, 4 i 1 xij 0或1 i, j 1, 2,3, 4
匈牙利法
0 8 11 0 上述例子完成一、二、三步之后如右： 2 3 转向第四步： 0 11
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
运筹学
分配问题与匈牙利法
2016/2/18
第 1页
第4章 整数规划与分配问题
运筹学
1. 分配问题
在实际中经常会遇到这样的问题，有n 项不同的任务，需要n 个人分别完成其中的一项，但
由于任务的性质和各人的专长不同，因此各人去完成不同的任务的效率（或花费的时间或费 用）也就不同。于是产生了一个问题，应指派哪个人去完成哪项任务，使完成 n 项任务的总 效率最高（或所需时间最少），这类问题称为分配问题或指派问题。
-0
2016/2/18
0 13 7 0 6 0 6 9 0 5 3 2 0 1 0 0
-0
-4
-2
第 7页
第4章 整数规划与分配问题
运筹学
第二步，试分配：
Ø 13 7 ◎ 0 0 6 0 ◎ 6 9 ◎ 0 5 3 2 ◎ Ø Ø 1 0 0 0
2016/2/18
第 12页
第4章 整数规划与分配问题
运筹学
4 ◎ 2 3
5 4 ◎ √ Ø 1 4 ◎ 4 3 7 1 Ø√ √
3 ◎ 2 2
4 3 ◎ 1 Ø 5 ◎ 4 4 6 0 Ø
3 4 3 0 0 1 0 5 2 0 4 4 2 6 0 0
乙 丙
丁 戊
9 8
7 4
12 5
3 6
7 4
6 7
11 6
9 5
9
9 6 11
第4章 整数规划与分配问题
运筹学
7 9 8 7 4
2016/2/18
5 9 8 11 5 12 7 11 9 7 5 4 6 94 3 6 9 63 6 7 5 11 4
Ø 0 1 3 2 ◎ 0
◎
0 6 2 Ø 0
3 Ø 0 3 ◎ 0 Ø 6 4 4 0 3 ◎ 0 0 Ø 2 0 Ø 2 0 ◎ 3
总时间为28
此问题有多个最优解
2016/2/18
第 23页
第4章 整数规划与分配问题
运筹学
◎ 0 1 3 2 Ø 0
1 2 4 3 ◎ 0
◎
0 6 2 Ø 0
3 √ Ø 0 √ 3 √ √ ◎ 0 3 3 Ø 0 5 3 ◎ 0 Ø 0 2 1 3 1 4
√ √
√
第 20页
第4章 整数规划与分配问题
运筹学
1 2 4 3 0 ◎
◎
0 6 2 0 Ø
1 0 0 0
此分配问题的最优时间：4+4+9+11=28
第4章 整数规划与分配问题
运筹学
例 2 有一份中文说明书，需译成英、日、德、俄四种文字。现有甲、乙、丙、丁四人，他们 将中文说明书译成不同语种的说明书所需时间如下表所示，问如何分配任务，使总时间最少？
任务 人员 甲 乙 丙 丁 英语 日语 德语 俄语
Ø 0
6 2 ◎ 0 4
4
3 ◎ 0 3 Ø 0 6
总时间为28
第 25页
3 0 Ø 3 0 ◎ 3 3 Ø 0 5 3 0 ◎ 0 Ø 2 1 3 1 4
√
l =m=4 < n=5
√ √ √ √
√
√
2016/2/18
第 21页
第4章 整数规划与分配问题
运筹学
1 2 4 3 ◎ 0
◎
0 6 2 Ø 0
3 Ø 0 3 ◎ 0 3 3 Ø 0 5 3 ◎ 0 Ø 0 2 1 3 1 4
0 6 2 0
3 0 3 0 3 3 0 5 3 0 0 2 1 3 1 4
第 19页
第4章 整数规划与分配问题
运筹学
1 2 4 3 0
2016/2/18
0 6 2 0
3 0 3 0 3 3 0 5 3 0 0 2 1 3 1 4
2016/2/18
第 4页
第4章 整数规划与分配问题
运筹学
例1
任务 人员 甲 乙 丙 丁
A 2 10 9 7
B 15 4 14 8
C 13 14 16 11
D 4 15 13 9
第4章 整数规划与分配问题
运筹学
求解过程如下： 第一步，变换系数矩阵：
2 10 9 7
15 4 14 8
5 1 0 7
9 5 9 6
0 4 3 0
4 0 2 3
5 1 0 7
4 0 4 1
0 4 3 0
－5
第二步，试指派：
4 ◎ 2 3
2016/2/18
5 4 ◎ 1 Ø 4 ◎ 4 3 7 1 Ø
找到 3 个独立零元素 但m=3<n=4
第4章 整数规划与分配问题
运筹学
例1
任务 人员 甲 乙 丙 丁
A 2 10 9 7
B 15 4 14 8
C 13 14 16 11
D 4 15 13 9
第4章 整数规划与分配问题
运筹学
2. 匈牙利法
第一步：变换指派问题的系数矩阵（cij）为(bij)，使在(bij)的各行各列中都出现0元素
第二步：进行试分配，以寻求最优解。如果得到最优解，运算结束，否则转到第三步。 第三步：作最少的直线覆盖所有0元素。 第四步：变换矩阵(bij)以增加0元素，转到第二步。
第 11页
第4章 整数规划与分配问题
运筹学
第三步，作最少的直线覆盖所有0元素：
4 ◎ 2 3
5 4 ◎ √ 1 Ø 4 ◎ 4 3 √ Ø 7 1 √
独立零元素的个数m等于最少直线数l，即l＝m=3<n=4； 第四步，变换矩阵(bij)以增加0元素：没有被直线覆盖的所有元素中的最小元素为1，然后 打√各行都减去1；打√各列都加上1，得如下矩阵，并转第二步进行试指派：
l =m=4 < n=5
√
√
√
2016/2/18
第 18页
第4章 整数规划与分配问题
运筹学
2 2 4 4 ◎ 0
2016/2/18
◎
0 5 1 Ø 0
4 ◎ 0 3 1 Ø 5 2 3 0 4 Ø 0 ◎ 0 3 2 3 1 5
1 2 4 3 0
2 2 4 4 ◎ 0
◎
0 5 1 Ø 0
4 ◎ 0 3 1 Ø 5 2 3 0 4 Ø 0 ◎ 0 3 2 3 1 5
第 17页
第4章 整数规划与分配问题
运筹学
2 2 4 4 ◎ 0
◎
0 5 1 Ø 0
4 ◎ 0 3 1 Ø 5 2 3 0 4 Ø 0 ◎ 0 3 2 3 1 5
Ø 0
3
Ø 0 ◎ 0 2
Ø 0
6 2 ◎ 0 4
2 0 Ø 3
◎ 0
4
3 ◎ 0 3 Ø 0 6
总时间为28
第 24页
2016/2/18
第4章 整数规划与分配问题
运筹学
0 Ø 1 3 2 ◎ 0
2016/2/18
Ø 0
3
Ø 0 ◎ 0 2
◎
0 2 0 Ø 3
6 4 3 5
7 5 1 9
11 9 10 8
2 8 4 2
第4章 整数规划与分配问题
运筹学
求解过程如下： 第一步，变换系数矩阵：
6 4 (cij ) 3 5
7 11 2 2 5 9 8 4 1 10 4 1 9 8 2 2
4 0 2 3
√ √
√ √ √ √
0 1 3 2 0
3 0 3 0 4 4 0 6 0 6 2 0 3 0 0 2 0 2 0 3
√
2016/2/18
第 22页
第4章 整数规划与分配问题
运筹学
0 1 3 2 0
3 0 3 0 4 4 0 6 0 6 2 0 3 0 0 2 0 2 0 3
2 2 4 4 0
0 5 1 0
6 2 5 3 2 3 1 7 4 0 0 3 3 4 2 6
-1 -2
第 16页
第4章 整数规划与分配问题
运筹学
2 2 4 4 0
2016/2/18
0 5 1 0
Байду номын сангаас
4 0 3 1 2 3 0 5 4 0 0 3 2 3 1 5
0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0
第 13页
3 ◎ 2 2
2016/2/18
4 3 1 Ø ◎ 4 6 ◎
◎
5 4 Ø
得到4个独立零元素， 所以 最优解矩阵为：
第4章 整数规划与分配问题
运筹学
任务
人员 甲 乙 丙 丁
英语
6 4 3 5
日语
7 5 1 9
德语
11 9 10 8
俄语
2 8 4 2
0 1 0 0
0 0 1 0
0 0 0 1
1 0 0 0
此分配问题的最优时间：2+4+1+8=15
2016/2/18
第 14页
第4章 整数规划与分配问题
运筹学
例3 费 用 人员 甲 工作 A 7 B 5 C 9 D 8 E 11
0 0 1 0
0 1 0 0
0 0 0 1
1 0 0 0
2016/2/18
第 8页
第4章 整数规划与分配问题