运筹学指派问题的匈牙利法实验报告

合集下载

最大化指派问题匈牙利算法

最大化指派问题匈牙利算法

最大化指派问题匈牙利算法匈牙利算法,也称为Kuhn-Munkres算法,是用于解决最大化指派问题(Maximum Bipartite Matching Problem)的经典算法。

最大化指派问题是在一个二分图中,找到一个匹配(即边的集合),使得匹配的边权重之和最大。

下面我将从多个角度全面地介绍匈牙利算法。

1. 算法原理:匈牙利算法基于增广路径的思想,通过不断寻找增广路径来逐步扩展匹配集合,直到无法找到增广路径为止。

算法的基本步骤如下:初始化,将所有顶点的标记值设为0,将匹配集合初始化为空。

寻找增广路径,从未匹配的顶点开始,依次尝试匹配与其相邻的未匹配顶点。

如果找到增广路径,则更新匹配集合;如果无法找到增广路径,则进行下一步。

修改标记值,如果无法找到增广路径,则通过修改标记值的方式,使得下次寻找增广路径时能够扩大匹配集合。

重复步骤2和步骤3,直到无法找到增广路径为止。

2. 算法优势:匈牙利算法具有以下优势:时间复杂度较低,匈牙利算法的时间复杂度为O(V^3),其中V是顶点的数量。

相比于其他解决最大化指派问题的算法,如线性规划算法,匈牙利算法具有更低的时间复杂度。

可以处理大规模问题,由于时间复杂度较低,匈牙利算法可以处理大规模的最大化指派问题,而不会因为问题规模的增加而导致计算时间大幅增加。

3. 算法应用:匈牙利算法在实际中有广泛的应用,例如:任务分配,在人力资源管理中,可以使用匈牙利算法将任务分配给员工,使得任务与员工之间的匹配最优。

项目分配,在项目管理中,可以使用匈牙利算法将项目分配给团队成员,以最大程度地提高团队成员与项目之间的匹配度。

资源调度,在物流调度中,可以使用匈牙利算法将货物分配给合适的运输车辆,使得货物与运输车辆之间的匹配最优。

4. 算法扩展:匈牙利算法也可以扩展到解决带权的最大化指派问题,即在二分图的边上赋予权重。

在这种情况下,匈牙利算法会寻找一个最优的匹配,使得匹配边的权重之和最大。

匈牙利法求解指派问题

匈牙利法求解指派问题

然后划去所在的列的其他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

求解指派问题的匈牙利算法.doc

求解指派问题的匈牙利算法.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 6 2 1 -1 Cij= 0 5 3 1 -1 0 0 0 0 1 1 1 3 2 0 2 +1 5 1 0 0 4 2 0 0 1 2 3 2 2 4 3 1 0 2 1 0 0 2
最优解:x13=1,x21=1,x32=1,x44=1
若◎元素的数目m=n,则该指派问题的最优 解已经得到,否则转入Step 3;
13
指派问题的匈牙利解法——步骤(续)
Step 3. 设有 m<n 个◎, 找最少覆盖所有0的直线
1) 对没有◎的行打√
2) 对已打√行中含所在列打√ 3) 对已打√列中含◎所在行打√ 4) 重复2)~3), 直至没有要打√的行和列为止 5) 对没有打√的行划横线, 对打√的列划竖线 得到最少覆盖所有0的直线数l。
i 1 j1 ik n n j1 n j1
n
n
n
cijx ij c kjx kj (s)
i 1 j1 ik j1
z (s)
指派问题的匈牙利解法
• 根据此定理,可以对 做如下改变,目的是 找出C 中的 n个不同行不同列的0元素: • 将 C的每一行减去该行中的最小元素,得 到C’矩阵 ,则C’ 的每行中均至少出现一个 0元素,且所有cij0 。同样,对C 的列亦进 行如此计算,由此,我们完全可以从原效 率矩阵 出发,得到一个新的效率矩阵 ,使 C的每行每列中均至少存在一个0元素,而 不改变问题的最优解。
Z=15
独立练习 • P161第6.4题
6.5.4 非标准形式的指派问题 • 非标准型指派问题求解的总原则是化非标准 形式为标准形式,然后用匈牙利解法求解。 (1) 最大化指派问题 设效率矩阵为 C (cij )nn ,其中最大元素

指派问题的匈牙利法

指派问题的匈牙利法

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

匈牙利法实验报告

匈牙利法实验报告

一、实验背景指派问题是一种典型的组合优化问题,广泛应用于生产管理、资源分配、任务调度等领域。

匈牙利法是解决指派问题的有效算法之一,它通过优化分配方案,使得总成本最小或总收益最大。

本实验旨在通过编程实现匈牙利法,解决一个具体的指派问题,并验证算法的正确性和效率。

二、实验目的1. 理解匈牙利法的基本原理和步骤;2. 掌握匈牙利法在指派问题中的应用;3. 评估匈牙利法的计算效率和稳定性;4. 比较匈牙利法与其他指派问题的求解方法。

三、实验原理匈牙利法是一种基于矩阵运算的指派问题求解算法,其核心思想是通过行减法和列减法,逐步缩小问题的规模,最终找到最优解。

具体步骤如下:1. 构建指派问题的系数矩阵;2. 进行行减法和列减法,使每行和每列至少有一个零元素;3. 标记所有零元素所在的行和列;4. 构建一个零元素覆盖矩阵,判断是否覆盖所有行;5. 若覆盖所有行,则得到最优解;否则,继续进行行减法和列减法。

四、实验过程1. 设计指派问题实例:假设有5个任务和5个资源,任务与资源的分配矩阵如下:| 任务1 | 任务2 | 任务3 | 任务4 | 任务5 || --- | --- | --- | --- | --- || 资源1 | 20 | 30 | 40 | 50 | 60 || 资源2 | 10 | 20 | 30 | 40 | 50 || 资源3 | 30 | 20 | 10 | 40 | 50 || 资源4 | 40 | 50 | 20 | 10 | 30 || 资源5 | 50 | 30 | 40 | 20 | 10 |2. 编写程序实现匈牙利法:使用Python编程语言,实现匈牙利法的基本步骤,并求解上述指派问题。

3. 分析结果:通过程序运行结果,验证匈牙利法是否得到最优解,并计算总成本。

五、实验结果与分析1. 实验结果:通过程序运行,得到最优解为任务1-资源1、任务2-资源2、任务3-资源3、任务4-资源4、任务5-资源5,总成本为160。

匈牙利法的指派问题-33页文档资料

匈牙利法的指派问题-33页文档资料

C
c11 c21
ci1
b
c12 c22
ci2 b
cn1
cn2
c1n c2n
cin b
cnn
minZ Z b
minZ Zb
若X0是minZ的最优, 解则 X0也是 minZ的最优解
指派问题的最优解:
若C中有n 个位于不同行不同列的零元素,
则令这些零元素对应的变量取1,其余变量
例:有一份说明书要分别译成英、 工作
日、德、俄四种文字,现交给甲、人
英日德 俄
乙丙、丁四个人去完成,每人完 甲 2 15 13 4
成一种。由于个人的专长不同,
乙 丙
10 4 14 15 9 14 16 13
翻译成不同文字所需的时间(小 丁 7 8 11 9
时数)如右表,问应派哪个人去
完成哪个任务,可使总花费时间
2
C
10
9 7
15 4 14 8
13 14 16 11
4 -2
15 -4
13 9
-9 -7
0
6 0 0
13 0 5 1
11 10 7 4
2 0 13
11
4 2
6
0 0
0 5 1
7 6 3 0
0
9
2
0
-4 -2
最优解的取法:
从含0元素最少的行或列开始,圈出一个0元 素,用 ○表示,然后划去该○所在的行和列 中的其余0元素,用×表示,依次类推,若能 得到n个○,则得最优解X0
最 优
取x14 1,x22 1, x31 1, x43 1 ,其余 xij 0

总费用 Z c14 x14 c22x22c31x31c43x43 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 1 ◎0 3 1 3 √
2 6 0 3 0 2 6 ◎0 3 Ø0 √
(5)若◎ 元素旳数目m 等于矩阵旳阶数n,那么这指 派问题旳最优解已得到。若m < n, 则转入下一步。
第三步:作至少旳直线覆盖全部0元素。 (1)对没有◎旳行打√号; (2)对已打√号旳行中全部含Ø元素旳列打√号; (3)再对打有√号旳列中含◎ 元素旳行打√号;
(4)反复(2),(3)直到得不出新旳打√号旳行、列为止; (5)对没有打√号旳行画横线,有打√号旳列画纵线, 这就得到覆盖全部0元素旳至少直线数 l 。l 应等于m, 若不相等,阐明试指派过程有误,回到第二步(4),另 行试指派;若 l=m < n,须再变换目前旳系数矩阵, 以找到n个独立旳0元素,为此转第四步。
0
3
8
5
圈零划零
0 8 0 5
11 0 9 4
2 3 4 0
0
38
5
得最优解
将圈起旳零改为1,其他元素改为0,即得 最优解如下
0 0 1 0
(xij
)
0 0
1 0
0 0
0 1
1 0 0 0
最小总时间为22。
再看一例
祈求解如下矩阵体现旳指派问题
12 7 9 7 9
8
9
6
6
6
7 17 12 14 9
将时间矩阵C旳每一行都减去相应行旳最小元素 和每一列都减去相应列旳最小元素,使每一行 和每一列都具有零;

运筹学指派问题的匈牙利法

运筹学指派问题的匈牙利法

运筹学课程设计指派问题的匈牙利法专业:姓名:学号: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,其次要求所需总时间最少,并且给出了该类问题的求解方法。

关键词:运筹学指派问题匈牙利算法系数矩阵解矩阵引言:在日常的生产生活中常遇到这样的问题:有n项任务,有n个人员可以去承担这n 项任务,但由于每位人员的特点与专长不同,各对象完成各项任务所用的时间费用或效益不同;有因任务性质要求和管理上需要等原因,每项任务只能由一个人员承担来完成,这就涉及到应该指派哪个人员去完成哪项任务,才能使完成n项任务花费总时间最短,总费用最少,产生的总效益最佳。

我们把这类最优匹配问题称为指派问题或分配问题。

1.指派问题的解法——匈牙利法早在1955年库恩(,该方法是以匈牙利数学家康尼格(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)的最优解,同时与其对应的原系数矩阵的最优解。

1.2匈牙利法的具体步骤第一步:使指派问题的系数矩阵经过变换在各行各列中都出现○元素。

指派问题与匈牙利解法

指派问题与匈牙利解法

指派问题与匈⽛利解法指派问题概述:实际中,会遇到这样的问题,有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

匈牙利法解决人数与任务数不等的指派问题于凯重庆科技学院经济管理学院物流专业重庆沙坪坝区摘要:本文将讨论运筹学中的指派问题,而且属于非标准指派问题,即人数与任务数不相等的指派问题,应当视为一个多目标决策问题,首先要求指派给个人任务数目两两之间相差不能超过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)的最优解,同时与其对应的原系数矩阵的最优解。

【信息系统项目管理】运筹学匈牙利算法示例

【信息系统项目管理】运筹学匈牙利算法示例
立0元素,就以这n个独立0元素对应解矩阵(xij)中的元 素为1,其余为0,这就得到最优解。找独立0元素,常 用的步骤为:
(1)从只有一个0元素的行(列)开始,给这个0元素加 圈,记作◎ 。然后划去◎ 所在列(行)的其它0元素,记作 Ø ;这表示这列所代表的任务已指派完,不必再考虑 别人了。
(2)给只有一个0元素的列(行)中的0元素加圈,记作 ◎;然后划去◎ 所在行的0元素,记作Ø .
0Ø 13 7 ◎0 6 0◎ 6 9 0◎ 5 3 2 0Ø 1 0◎ Ø0
0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0
例二、 有一份中文说明书,需译成英、日、德、俄四种 文字,分别记作A、B、C、D。现有甲、乙、丙、丁四 人,他们将中文说明书译成不同语种的说明书所需时 间如下表所示,问如何分派任务,可使总时间最少?
第四步:变换矩阵(bij)以增加0元素。 在没有被直线覆盖的所有元素中找出最小元素,然后 打√各行都减去这最小元素;打√各列都加上这最小元 素(以保证系数矩阵中不出现负元素)。新系数矩阵 的最优解和原问题仍相同。转回第二步。
例一:
任务 人员
A
B
C
D

2
15 13
4
乙 10
4
14 15

9
14 16 13
-1 -2
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
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
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

浅析指派问题的匈牙利解法成稿讲解

浅析指派问题的匈牙利解法成稿讲解

浅析指派问题的匈牙利解法胡小芹数学科学学院数学与应用数学学号:040414057指导教师:苏孟龙摘要:对于指派问题,可以利用许多理论进行建模并加以解决,但匈牙利解法是解决指派问题的一种非常简单有效的方法,并且可以解决多种形式的指派问题,但匈牙利算法本身存在着一些问题,本文主要介绍了匈牙利算法的基本思想,基本步骤,以及它的改进方法.在匈牙利算法的基础上,本文还介绍了两种更简便实用的寻找独立零元素的方法——最小零元素消耗法和对角线法.关键词:指派问题;匈牙利解法;最小零元素消耗法;对角线法0 引言在现实生活中经常会遇到把几个任务分派给几个不同的对象去完成,由于每个对象的条件不同,完成任务的效率和效益亦不同.指派问题的目标就是如何分派使所消耗的总资源最少(或总效益最优),如给工人分派工作,给车辆分配道路,给工人分配机床等等,同时许多网络问题(如旅行问题,任务分配问题,运输问题等),都可以演化成指派问题来解决.在现实生活中,指派问题是十分常见的问题,而匈牙利解法是解决指派问题的一种非常简单有效的方法.本文主要介绍匈牙利解法的基本原理及思想,解题步骤,不足与改进,以使匈牙利法更能有效地解决指派问题.1 指派问题及其数学模型指派问题是指由m项任务,需要n个人来承担,每人只能承担一项任务,且每项任务只能有一人来承担,由于各人的专长不同,各人完成的任务不同,导致其效率也各不相同.因此,就产生怎样科学地指派任务,才能使完成各项任务所消耗的总资源最少(或总成本最低等),由于n m ,不同,指派问题可分为以下三种情况:第一、当n m =时,即为每人指派一项任务.第二、当n m >时,即任务数〉人数,这时可虚设)(n m -个人构成m m ⨯的 效率矩阵,并且这)(n m -个人在执行这m 项任务时的效率应该是效率最高. 第三、当n m <时,即配置人数〉任务数,这时应虚设)(m n -项任务,并且这n 个人在执行这)(m n -项任务时的成本最低.通过虚设任务或人,指派问题的效率矩阵都可以转化成方阵.匈牙利解法要求指派问题最小化,其数学模型为设用0ij c >(,1,2,,)i j n =表示指派第i 个人去完成第j 项任务时所用的时间,定义决策变量 10ij i j x i j ⎧=⎨⎩表示第个人完成第项任务, 表示不指派第个人完成第项任务.则问题可转化为0-1线性规划问题:∑∑===n j ij n i c Z 11mint s ⋅ 111,1,2,,,1,1,2,,,01,i,j 1,2,,n nij i nij j ijx j n x i n x ==⎧==⎪⎪⎪==⎨⎪⎪==⎪⎩∑∑或.如果指派问题要求的是最大化问题如F max ,则可以转化为最小化问题,一般方法是:取max (,1,2),ij M c i j n ==令(,1,2,)ij ij b M c i j n =-=,则11min ,n n ij i j f b ===∑∑,max F nM f F =-有从而求. 2 指派问题的解法——匈牙利解法“匈牙利解法”最早是由匈牙利数学家 D.Konig 用来求矩阵中0元素的一种方法,由此他证明了“矩阵中独立0元素的最大个数等于能覆盖所有0元素的最少直线数”.1955年由W.W.Knhu 在求解著名的指派问题时引用了这一结论,并对具体解法做了改进,仍称为匈牙利解法.2.1 匈牙利解法的基本原理和解题思想从根本上讲,求指派问题的最优解就是要在n 阶方阵中找到n 个这样的元素,它们分布在不同行不同列上,并且这些元素之和为最小,而要使这些元素之和为最小,就要使其中的每一个元素尽可能的小——最好这些元素都是其所在行所在列上的最小元素.而指派问题的最优解又具有这样的性质(定理1):若从系数矩阵)(ij c 的每行(列)各元素中分别减去该行(列)的最小元素,得到的新矩阵()ij b ,那么以()ij b 为系数矩阵求得的最优解与用()ij c 求得最优解相同.由于新矩阵()ij b 中每行每列都有最小元“0”,因此,求原指派问题的最优解转化为在()ij b 中指出n 个分布在不同行不同列上的“0”元素(简称为独立0元素),而根据考尼格(Konig )证明的定理(定理2):矩阵中独立元素的0最多个数等于能覆盖所有零元素的最少直线数,利用这一定理,就可以通过寻找“能覆盖所有零元素的最少直线数”来确定()ij b 中独立元0素的具体数量.若()ij b 中独立0元素的个数少于矩阵的阶数n ,就要继续对矩阵()ij b 进行化简,直到找到n 个独立0元素为止,这就是匈牙利解法的基本原理和解题思想.2.2 匈牙利解法的解题步骤第一步:变换效益矩阵,使新矩阵中的每行每列至少有一个0.(1)行变换:找出每行最小元素,再从该行各元素中减去这个最小元素.(2)列变换:从所得新矩阵中找出每列中的最小元素,再从该列各元素中减去这个最小元素.第二步:进行试指派,以寻找最优解.(1)逐行检查从第一行开始,如果该行只有一个零元素,就对这个零元素打上括号,划去与打括号零元素同在一列的其他零元素,如果该行没有零元素,或有两个或多个零元素(已划去的不计在内),则转下行.打括号的意义可理解为该项任务已分配给某人.如果该行只有一个0,说明只能有唯一分配.划掉同列括号零元素可理解为该任务已分配,此后不再考虑分配给他人.当该行有两个或更多的零元素时,不计括号内的,其理由是至少有两个分配方案,为使以后分配时具有一定的灵活性,故暂不分配.(2)逐列检查在行检查的基础上,由第一列开始检查,如果该列只有一个零元素,就对这个零元素打括号,再划去与打括号零元素同行的其它零元素.若该列没有零元素或有两个以上零元素,则转下一列.(3)重复(1)、(2)两步后,可能出现以下三种情况:①每行都有一个零元素标出括号,显然打括号的零元素必然位于不同行不同列,因此得到最优解.②每行每列都有两个或两个以上的零,这表示对这个人可以分配不同任务中的任意一个.这时可以从所剩零元素最少的行开始,比较这行各零元素所在列中元素的个数,选择零元素少的那列这个零元素打括号,划掉同行同列的其他它零元素,然后重复前面的步骤,直到所有0都作了标记.③矩阵中所有零都作了标记,但标有(0)的元素个数少于m个,则转下步.第三步:做最少的直线覆盖所有零元素,以确定该系数矩阵中能找到最多的独立0元素.·对没有()的行打√;·对打√的行上所有含0元素的列打√;·再对打√的列上有()的行打√;·重复上两步,直到过程结束;·对没有打√的行划横线,对所有打√的列划垂线.这就得到了能覆盖矩阵中所有0元素的最少直线数.第四步:非最优阵的变换——零元素的移动.(1)在没有被直线覆盖的所有元素中,找出最小元素;(2)所有未被直线覆盖的元素都减去这个最小元素;(3)覆盖线十字交叉处的元素都加上这个最小元素;(4)只有一条直线覆盖的元素的值保持不变.第五步:回到第二步,反复进行,直到矩阵中每行每列都有一个打()的0元素为止,即找到最优解.2.3 匈牙利算法的一点注记(1)匈牙利算法第一步变换效益矩阵使每行每列都出现零元素,一般方法是先行变换,再列变换,但先列变换再行变换最优解不变.(2)有些时候先行后列变换后不能得到最优解,但先列后行变换时却能直接找到最优解,从而减少了计算步骤,使计算简明.如下所示:先行变换,再列变换得2109715414813141611415139B ⎡⎤⎢⎥⎢⎥=→⎢⎥⎢⎥⎣⎦(0)82511(0)5423(0)001145B ⎡⎤⎢⎥⎢⎥=⎢⎥⎢⎥⎣⎦只找到三个独立0元素,不是最优解.那么先列变换,后行变换得2109715414813141611415139B ⎡⎤⎢⎥⎢⎥=→⎢⎥⎢⎥⎣⎦06(0)013(0)51763(0)(0)920B ⎡⎤⎢⎥⎢⎥=⎢⎥⎢⎥⎣⎦ 每行每列都有“(0)”,得到最优解.3 匈牙利法的不足与改进3.1 不足和改进(一)以上是匈牙利法的常规解题方法,虽然能有效地解决指派问题,但是其解题过程中还存在以下两点不足:第一、在匈牙利算法的第二步中用“试指派”的方法寻找独立0元素,道理简单,也能很快找到独立0元素,但对于一个n 阶方阵,这些独立0元素在矩阵中可能有n 种排列方式,这样在矩阵中标出来的独立0元素排列很乱,没有规律.另外,对于某些矩阵0元素排列的比较有规律,本可以用别的更简单的方法寻找独立0元素,而用这种“一般性”的方法比较麻烦.第二、在匈牙利算法的第三步“做最少的直线覆盖所有0元素”过程中,一会儿针行,一会儿针对列,一会儿对没有()的打√,一会儿又对有()的打√,一会对没有打√号的(行)划线,一会又对打√号的(列)划线,这样变来变去令人晕头转向,稍不注意就会出错,特别是对于这种画法每一步的意图以及内在原理,大多数人难以理解,具体步骤很难记住,难以掌握,这就影响了这一理论在实际工作中的应用.算法的改进:第一、寻找独立0元素的一种新方法——对角线法.对角线法的原理:根据要在指派问题化简后的系数矩阵(ijb)中找出n个独立0元素,而这些独立0元素又分布在方阵的不同行不同列上,利用这一特点,我们可以对矩阵(ijb)的行(或列)进行某种调换,就一定可以使这些独立0元素按矩阵的对角线排列,这样凡是出现在对角线上的零元素一定是独立0元素,而非对角线上的零元素也一定是非独立0元素,这样我们既能很快找到所有独立0元素,又能直观地发现矩阵中独立0元素的个数.方法:从0元素数量最少的行开始,选择该列第一个0元素,根据该0元素所在行的位置确定该列元素在新矩阵中列的位置(若该0元素所在行是第i行,那么就将该0元素所在列放在新矩阵的第i列),并在原矩阵中划去这一列,并划掉同行其它0元素,再在剩下的矩阵中重新比较各列0元素的数量,并按前面方法进行,直至完成.这样就可以将所有独立0元素集中放在新矩阵的对角线上,当对角线上全为0时,就得到了指派问题的最优解,如果对角线上某一处不为0,说明该矩阵中独立0元素数量不足,这时需要对矩阵作进一步化简.应用示例: 寻找矩阵B中的独立0元素B=5050200304400401⎡⎤⎢⎥⎢⎥⎢⎥⎢⎥⎣⎦→B=5050200304400401⎡⎤⎢⎥⎢⎥⎢⎥⎢⎥⎣⎦→10505003244004010B⎡⎤⎢⎥⎢⎥=⎢⎥⎢⎥⎣⎦(第一列与第四列交换)或25050 2300 0044 0104B⎡⎤⎢⎥⎢⎥=⎢⎥⎢⎥⎣⎦(第二列与第四列交换)第二、最少直线的一种简单画法.画法原理:根据定理“矩阵中独立0元素的最多个数恰好等于能覆盖所有0元素的最少直线数”,也就是说矩阵中有多少个独立0元素,就需要多少条直线将所有0元素覆盖,而从匈牙利法解题步骤看矩阵中独立0元素的数量m 及位置,在划线前是已知,所以覆盖0元素的最少直线数m 也是已知的.由于任意两个独立0元素“(0)”都不同行且不同列,而盖0线也只能按矩阵的行或列来划,因此,一条盖0线只能覆盖一个“(0)”,要覆盖m 个“(0)”就需要m 个直线.基于“盖0线”与独立0元素“(0)”之间数量的一对一关系,只要我们始终围绕着独立0元素“(0)”来画线,首先就能用最少的直线覆盖所有的独立0元素.另外,由于矩阵中的非独立0元素总是和某个独立0元素在同一行或同一列,因此画盖“(0)”线时,只要我们能使每条盖0线都尽可能多的附带非独立0元素,那我们就能实现用最少的直线覆盖所有0元线.具体画法:(1)标记——对“(0)”所在行和列上的0元素数量在行列旁予以标注,对没有“(0)”的行与列的打×号予以标记.(2)画线——从有“(0)”的行与列中找出0元素最多的行(或列)画一横(或纵)线覆盖这些0元素.(3)修正——从“(0)”所在行与列上的0元素数量减去已被覆盖的0元素数.(4)重复上述过程,直至覆盖所有0元素.上述方法的关键是紧紧抓住独立0元素其所在行与列上的0元素的多少决定盖0线的画法(即画线的先后和方向,横向还是纵向),使每条线都能覆盖尽可能多的0元素.另外,因某些非独立0元素处在可被两条盖0线同时覆盖的交叉点上,为减少重复性覆盖,每画一条线后都要对各行各列0元素数予以修正(从中减去已被覆盖的0元素数).示例: 试用最少的直线覆盖下列矩阵中的所有0元素5(0)202230(0)0(0)1057298(0)0406365B ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⎣⎦→ 5(0)2022230(0)03(0)10572198(0)04206365B ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⨯⎣⎦2 1 23 ×5(0)2022230(0)00(0)10572198(0)04206365B ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⨯⎣⎦→ 5(0)2020230(0)00(0)10572198(0)04206365B ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⨯⎣⎦→ 2 1 1 × × 2 × 1 × ×5(0)2020230(0)00(0)10572198(0)04006365B ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⨯⎣⎦ 2 × × × ×注意:当矩阵中的行和列旁标的0元素的数量相等时,我们从中任意选择一个画线,但是当此行(或列)中的0元素所对列(或行)中无“(0)”时,只能先划去此行(或列).比如上面的矩阵B 中,第二行和第四列中0元素相等,都是最多(3个),若先划去第四列,则第二行中第五列中的0元素用这种方法无法划去,若要划去这个0元素,则直线增多.3.2 不足和改进(二)用于解决指派问题的匈牙利解法,在运算过程中存在着两个问题:第一、算法不完善.从未标零元素最少的行取定0元素,不能保证0元素所在的列未标零元素最少.因此,系数矩阵已存在最大匹配,但无法取得最大匹配,而算法中途停止.第二、计算步骤烦琐.当0元素不够又没有未标零元素时,作直线覆盖,移动零元素,然后再取定0元素,反复进行.一 改进算法1 完善匈牙利算法选取零元素时,若被划行未标零元素多于一个,则要保证所标的零元素所在的列未标零元素最少.利用此方法可以解决问题一.2 改进算法步骤(1)利用匈牙利算法,由系数矩阵()ij c 得到各行各列都有零元素的等效矩阵()ij b .(2)若有未划零元素,则选有未划零元素最多的行或列作直线覆盖,直到没有未划零元素为止.(3)若直线数目小于n ,则在未划元素中选取最小元素,未划的各元素减去最小元素,直线交叉处的元素均加最小元素,转2.否则转4.(4)选取有未标零元素最少的行(或列)取未标零元素,记(0),同行同列的未标零元素记 φ;若该行(或列)未标零元素多于一个,则选列(或行)中未标零元素最少的本行未标零元素为(0),直到(0)元素个数等于n 为止.(5)结束算法,得到最大匹配.令对应于(0)的1ij x =,其余的0ij x =,并计算目标函数值.二 定义及定理定义1 作直线覆盖时,被直线覆盖的元素,称为已划元素.未被直线覆盖的元素,称为未划元素.定义2 求最大匹配时,已作记号(0)和φ的零元素称为已标元素,未作记号的零元素称为未标零元素.定理 矩阵()ij b 中已存在最大匹配的充要条件是直线覆盖其中全部零元素的最少数目为n .证明 必要性 若()ij b 中有最大匹配,则()ij b 中存在n 个不同行不同列的零元素,故至少n 条直线才能覆盖全部元素.充分性 若覆盖全部零元素的最少直线数目为n ,则()ij b 中有n 个不同行不同列的零元素.否则可以用少于n 条的直线能覆盖全部元素.此算法的优点是,先求具有最大匹配的等效矩阵,再求最大匹配.求解过程中可以减少迭代次数,降低计算量,并且对某些用匈牙利算法无法得到最大匹配的矩阵利用此改进的算法可以得到最大匹配,例如效益矩阵010()002003ij b ⎡⎤⎢⎥=⎢⎥⎢⎥⎣⎦. 3.3 不足和改进(三)3.3.1 匈牙利法存在的问题我们用“匈牙利法”处理了许多与分配问题相关的运输、调度问题,大多数情况下算法是收敛的,得到了最优解,而处理一些特殊数据时算法不收敛,无法找出最优解,矩阵阶数越大的分配问题,不收敛的情况越多.试验中,发现了一个较小阶不收敛的系数矩阵,下面用“匈牙利法”对该矩阵进行分析2 2 4 1 4 4 4 4 12 2 1 1 23 3 3 12 3 1 4 4 2 4 3 42 1 1 4 13 1 1 23 1 1 1 2 2 1 3 11 3 1 42 23 1 33 4 2 1 1 1 3 3 13 24 1 3 1 4 1 21 4 12 1 43 1 4经过算法第一步,得到修正的系数矩阵1 1 3 0 3 3 3 3 01 1 0 0 12 2 2 01 2 0 3 3 1 3 2 31 0 0 3 02 0 0 12 0 0 0 1 1 0 2 00 2 0 3 1 1 2 0 22 3 1 0 0 0 2 2 02 13 0 2 0 3 0 10 3 0 1 0 3 2 0 3进行算法第二步,做分配方案,最终第2行无(0)标记,使得第2行第2列没有分配1 1 3 (0) 3 3 3 3 ×1 1 ×× 12 2 2 ×1 2 (0) 3 3 1 3 2 31 ×× 3 (0)2 ×× 12 ××× 1 1 (0) 2 ×(0) 2 × 3 1 1 2 × 22 3 1 ××× 2 2 (0)2 13 × 2 × 3 × 1× 3 × 1 × 3 2 (0) 3进行算法第三步,最终所有的行和所有的列都有∨标记,所有的行末画一条横线,所有的列都画上了竖线,各行列作标记的顺序如下∨∨∨∨∨∨∨∨∨⒄⑿⑵⑶⑻⑼⒀⒁⑷1 1 3 (0) 3 3 3 3 ×⑹∨1 1 ×× 12 2 2 ×⑴∨1 2 (0) 3 3 1 3 2 3 ⑸∨1 ×× 3 (0)2 ×× 1 ⑽∨2 ××× 1 1 (0) 2 ×⒂∨(0) 2 × 3 1 1 2 × 2 ⒅∨2 3 1 ××× 2 2 (0) ⑺∨2 13 × 2 (0) 3 × 1 ⑾∨× 3 × 1 × 3 2 (0) 3 ⒃∨进行算法第四步,没有找到未被直线覆盖的元素,所以也就无法找到最小的元素,也就不能产生新的效能矩阵,算法进入死循环.这就否定了“匈牙利法”主要过程的算法基础.若算法第二步未完成一个完全分配时,则一定能生成一个新的效能矩阵,出现新的零元素,再重新进行完全分配,最终一定能得到一个完全的最优解.3.3.2 匈牙利算法的改进为了使“匈牙利法”对任意数据都能有效的找到最优解,我们在原算法的基础上增加第六步,以及在第三步后面增加判断功能:若生成n条直线,无法生成新的效能矩阵,则退出“匈牙利法”,进行第六步.第六步:产生新的小系数矩阵,使原矩阵分解.(1)从第二步算法中,记下有(0)标记的行号和列号,作为部分解进行保存.(2)从系数矩阵中抽取行列都没有(0)标记的数据,组成一个新的小系数矩 阵:[]ij E ,1,2,,,1,2,,,i m j m m n ==<.(3)将小系数矩阵再代入“匈牙利法”, 继续计算, 得到小系数矩阵的分配解, 把它添加到部分解的结果中去,组合得到一个新的解,如果新的解仍然不是完全解,则转(1)继续处理.(4)对已分配的元素,两两一对组成任意一个矩形的斜对角顶点, 相加后生成一个基础量, 再将矩形的另一对斜对角顶点的元素相加,生成一个改变量,有n 个已分配的元素将产生12321n n ++++-+-对基础量和改变量.(5)对于每对基础量和改变量,如果存在基础量大于改变量的情况,则找出基础量与改变量差值最大的一对,由改变量取代基础量,转(4)继续处理.(6)得到整个分配的最优解,输出分配结果.在上例中,新的小系数矩阵仅为第2行和第2列,m 为1.另外,也没有找到改变量小于基础量的两对值,所以无须进行优化,直接将该元素添加到部分解中去,通常新的小系数矩阵的阶数都很小.文献[]5中给出了一个2222*的系数矩阵,存在上述问题,利用改进的匈牙利算法最终得到最优解.3.4 匈牙利算法的推广匈牙利算法的关键是在变换后的系数矩阵中找出n 个分布在不同行不同列的独立0元素,而匈牙利算法计算过程比较麻烦,文献[]8,文献[]9在匈牙利算法的基础上提出了两种比较简单的寻找独立0元素的方法:最小零元素消耗法及对角线法.3.4.1 最小零元素消耗法基本思想:对于一个给定的矩阵,其中0元素的数目是一定的,这一定的0元素最多能分配出多少个0元素来?当分配出一个0元素时,该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元素,以(0)标记.此0元素所在行所在列以不起作用,再计算余下的个各个0元素的消耗数,重复上述步骤,直至每行每列的0元素都标记完,最终得到最大匹配,若标记(0)的个数等于矩阵阶数,得到最优解.在应用此方法的时候,当遇到0消耗相同的0元素不止一个,此时应先分配哪个0元素呢?有以下三种情况:(1)0消耗数相同,但0元素在同一行或同一列上,如下所示:120(,)0(,)i j ij120(,)0(,)i j ij现就0元素在同一行的情况说,如果分配其任何一个,另一个则被消耗掉,他们的0消耗数实际上是相同的,只能表示一个分配,要么分配10(,)i j ,要么分配20(,)i j ,但第i 行则可以确定下来,等其它0元素分配完以后,如12,j j 列中有一列确定,则第i 行可以具体确定出0元素,若12,j j 列仍未确定,则说明最大分配小于n ,或者有多种最优分配方案.对于同一列的情况,可以确定第j 列,具体分配哪一个,视其它0元素的分配而定.(2)0消耗数相同且互相影响,但0元素不同行不同列,此时0元素的消耗数必共同消耗一个或两个0元素,如下所示:11220(,)00(,)i j ij 11220(,)000(,)i j ij110(,)i j 、220(,)i j 的0消耗相同,设为q ,他们的0消耗因共有0元素而相互影响,若先分配110(,)i j ,则在余下的0元素中220(,)i j 的0消耗数为1q -或2q -,必为最小,应予与分配.反之也是,因此这种情况两者应同时分配.(3)0消耗数相同但互不影响,此时必为下图所示:11220(,)0(,)i j ij此时若先分配110(,)i j ,则在余下的0元素中,220(,)i j 的0消耗必为最少,应予与分配,反之也是.这种情况可将它们同时分配.综合上述三种情况,当遇到0消耗数相同的0元素时,如果它们不在同一行同一列,可以将其同时分配;如果在同一行同一列上,可将该行或该列分配,分配数加1,具体分配视其它0元素分配结果而定.3.4.2 对角线法匈牙利算法的实质就是寻找n 个分布在不同行不同列的零元素,而匈牙利算法本身计算过程较复杂,下面给出一种使系数矩阵对角线为零的算法——对角线法.基本步骤:第一步:变换系数矩阵使每行每列都出现零元素,同匈牙利算法第一步.第二步:进行行排序,即(1)在变换后的系数矩阵()ij b 的第j 列元素中(1,2,,)j n =,从第,1,,j j n +行中选取最小元素,记为0b i j .(2)将0i 行元素与j 行进行交换.通过步骤二可使每列中的零元素或最小元素尽量出现在对角线上.若这样选取的最小元素有两个以上时,则取这些最小元素所在行中第n 个元素大者所对应的元素为最小元素;若第n 个元素也相同,则取第1n -个元素中大者对应的元素为最小元素,以此类推;若这些最小元素后各行对应元素都相同,则取这些最小元素所在行中第1j -个元素小者对应元素为最小元素;若第1j -个元素相同,则取再前一个元素中小者对应元素为最小元素,以此类推.若这些最小元素所在行的对应元素均相同,则可任选一最小元素所在行与第j 行元素交换.第三步:检验——若0ii b =(1,2,,)i n =,则以得最优解,过程结束.否则进行第四步.第四步:进行行排序,排序过程类似于第二步,只须将第二步中的“列”改为“行”.而“行”改为“列”,“后”改为“下”,“前”改为“上”即可.第五步:若0ii b =(1,2,,)i n =,则已得到最优解,迭代过程停止,否则进行第六步.第六步:,1,2,,ij ij ii b b b j n =-=. 第七步:若0,1,2,,ij b j n ≥=,则返回第五步.否则,若0ik b <,则令,1,2,,jk jk ik b b b j n =-=,返回第一步.从上述过程来看,整个过程包括两个基本部分,第一部分是通过一系列矩阵的行列变换,把零元素排列在对角线上;第二部分是最解的检验,即所有0ii b =时,已得到最优解.对于此算法的收敛性分析,文献[]9中给出了几个定理,并进行了证明,可以看出此改进算法的收敛性极好,可以有效地解决指派问题.4 对最大化指派问题的匈牙利解法的一点改进对最大化的指派问题的解法,一般方法是找出系数矩阵()ij c 中的最大元素,即1nij i M max c ==∑),,2,1(n j =,做矩阵B ,其元素为),,2,1;,,2,1(n j n i b ij ==且ij ij c M b -=,然后利用匈牙利解法最小化求B 的最优解.下面我们在此基础上对其提出一点改进,直接在原系数矩阵上进行修改.修改的原则是:在最小化问题中,系数矩阵不能出现负数,在最大化问题中,修改后的不能出现正元素,可出现零.基本步骤:第一步:修改系数矩阵.。

2023年运筹学指派问题的匈牙利法实验报告

2023年运筹学指派问题的匈牙利法实验报告

2023年运筹学指派问题的匈牙利法实验报告一、前言运筹学是一门涉及多学科交叉的学科,其主要研究通过数学模型和计算机技术来提高生产和管理效率的方法和技术。

其中,指派问题是运筹学中的重要研究方向之一。

针对指派问题,传统的解决方法是匈牙利法。

本文将基于匈牙利法,通过实验的方法来探讨2023年指派问题的发展。

二、指派问题1.定义指派问题是指在一个矩阵中指定每一行和每一列只选一个数,使得多个行和列没有相同的数,而且总和最小。

2.传统算法匈牙利算法是一种经典的用于解决指派问题的算法。

该算法基于图论的思想,用于寻找最大匹配问题中的最大流。

匈牙利算法的时间复杂度为 $O(n^3)$,但是,该算法仍然被广泛应用于实际问题求解。

三、实验设计1.实验目的本实验旨在探究匈牙利算法在指派问题中的应用以及其发展趋势,同时,通过对比算法运行速度来评估其效率和实用性。

2.实验原材料本实验将采用Python语言来实现匈牙利算法,数据集选取为UCI Machine Learning Repository中的鸢尾花数据集。

3.实验步骤步骤1:导入数据集,并进行数据预处理。

步骤2:计算每个样本在所有类别中的得分,并选取得分最高的类别作为预测结果。

步骤3:使用匈牙利算法对预测结果进行优化,以求得更优的分类方案。

步骤4:对比优化前后的分类结果,评估算法的实用性和效率。

四、实验结果本实验的最终结果表明,匈牙利算法在指派问题中的应用具有很好的效果。

实验数据表明,经过匈牙利算法优化后,分类器的准确率有了显著提高,分类结果更加精确。

同时,通过对比算法运行时间,也发现该算法具有较高的运行速度和效率。

五、实验结论本实验通过大量数据实验表明,匈牙利算法在指派问题中的应用具有很高的效率和精度。

将算法运用到实际生产和管理中,可有效地提高生产效率和管理水平。

但是,由于算法的时间复杂度比较高,因此在实际运用过程中需要合理选择算法,并对算法进行优化,以确保其效率达到最大化。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

运筹学课程设计报告专业:班级:学号:姓名:2012年6月20日目录一、题目。

二、算法思想。

三、算法步骤。

四、算法源程序。

五、算例和结果。

六、结论与总结。

一、题目:匈牙利法求解指派问题。

二、算法思想。

匈牙利解法的指派问题最优解的以下性质:设指派问题的系数矩阵为C=()c ij n n⨯,若将C的一行(或列)各元素分别减去一个常数k(如该行或列的最小元素),则得到一个新的矩阵C’=()'c ij n n⨯。

那么,以C’位系数矩阵的指派问题和以C位系数矩阵的原指派问题有相同最优解。

由于系数矩阵的这种变化不影响约束方程组,只是使目标函数值减少了常数k,所以,最优解并不改变。

必须指出,虽然不比要求指派问题系数矩阵中无负元素,但在匈牙利法求解指派问题时,为了从以变换后的系数矩阵中判别能否得到最优指派方案,要求此时的系数矩阵中无负元素。

因为只有这样,才能从总费用为零这一特征判定此时的指派方案为最优指派方案。

三、算法步骤。

(1)变换系数矩阵,使各行和各列皆出现零元素。

各行及各列分别减去本行及本列最小元素,这样可保证每行及每列中都有零元素,同时,也避免了出现负元素。

(2)做能覆盖所有零元素的最少数目的直线集合。

因此,若直线数等于n,则以可得出最优解。

否则,转第(3)步。

对于系数矩阵非负的指派问题来说,总费用为零的指派方案一定是最优指派方案。

在第(1)步的基础上,若能找到n个不同行、不同列的零元素,则对应的指派方案总费用为零,从而是最优的。

当同一行(或列)上有几个零元素时,如选择其一,则其与的零元素就不能再被选择,从而成为多余的。

因此,重要的是零元素能恰当地分布在不同行和不同列上,而并在与它们的多少。

但第(1)步并不能保证这一要求。

若覆盖所有零元素的最少数目的直线集合中的直线数目是n,则表明能做到这一点。

此时,可以从零元素的最少的行或列开始圈“0”,每圈一个“0”,同时把位于同行合同列的其他零元素划去(标记为),如此逐步进行,最终可得n个位于不同行、不同列的零元素,他们就对应了最优解;若覆盖所有零元素的最少数目的直线集合中的元素个数少于n,则表明无法实现这一点。

需要对零元素的分布做适当调整,这就是第(3)步。

(3)变换系数矩阵,是未被直线覆盖的元素中出现零元素。

回到第(2)步。

在未被直线覆盖的元素中总有一个最小元素。

对未被直线覆盖的元素所在的行(或列)中各元素都减去这一最小元素,这样,在未被直线覆盖的元素中势必会出现零元素,但同时却又是以被直线覆盖的元素中出现负元素。

为了消除负元素,只要对它们所在的列(或行)中个元素都加上这一最小元素(可以看作减去这一最小元素的相反数)即可。

四、算法源程序。

#include<iostream.h>#include<stdlib.h>#define m 5int input(int M[m][m]){int i,j;for(i=0;i<m;i++){ cout<<"请输入系数矩阵第"<<i+1<<"行元素:"<<endl;for(j=0;j<m;j++)cin>>M[i][j];}cout<<"系数矩阵为:"<<endl;for(i=0;i<m;i++){ for(j=0;j<m;j++)cout<<M[i][j]<<"\t";cout<<endl;}return M[m][m];}int convert(int M[m][m]){ int x[m],y[m];int i,j;for(i=0;i<m;i++){ x[i]=M[i][0];for(j=1;j<m;j++){ if(M[i][j]<x[i])x[i]=M[i][j];}}for(i=0;i<m;i++)for(j=0;j<m;j++)M[i][j]-=x[i];for(j=0;j<m;j++){ y[j]=M[0][j];for(i=0;i<m;i++){ if(M[i][j]<y[j])y[j]=M[i][j];}}for(i=0;i<m;i++)for(j=0;j<m;j++)M[i][j]-=y[j];cout<<"对系数矩阵各行各列进行变换得:"<<endl;for(i=0;i<m;i++){ for(j=0;j<m;j++)cout<<M[i][j]<<"\t";cout<<endl;}return M[m][m];}int exchange(int M[m][m]){ int i,j,n;cout<<"进行行变换输入0,进行列变换输入其他任意键:"<<endl;cin>>n;if(n==0)cout<<"分别输入要变换的行及该行未覆盖元素中最小元素:"<<endl;elsecout<<"分别输入要变换的列及该列的最小元素:"<<endl;int a,b;cin>>a>>b;for(j=0;j<m;j++)if(n==0)M[a-1][j]-=b;elseM[j][a-1]-=b;cout<<"变换后的矩阵:"<<endl;for(i=0;i<m;i++){ for(j=0;j<m;j++)cout<<M[i][j]<<"\t";cout<<endl;}return M[m][m];}void main(){ int M[m][m];cout<<"<<<<<<<<<<<<<<<<<<<匈牙利法解指派问题>>>>>>>>>>>>>>>>>>>> "<<endl;while(true){cout<<""<<endl;cout<<">>>>>>>>>>>>>>>> 菜单<<<<<<<<<<<<<<<<"<<endl<<endl;cout<<" 1.系数矩阵输入"<<endl;cout<<" 2.初始变换"<<endl;cout<<" 3.行列变换"<<endl;cout<<" 4.退出"<<endl;cout<<"************************************"<<endl<<endl;int n;cout<<"请选择功能键";cin>>n;switch(n){case 1:input(M);break;case 2:convert(M);break;case 3:exchange(M);break;case 4:cout<<"谢谢使用!"<<endl;exit(0);break;default:cout<<"输入有误!请重新输入!"<<endl;}}}五、 算例和结果。

例4—12 今有甲、乙、丙、丁4个人去完成5项任务。

每人完成各项任务所需的时间如表4—11所示。

由于任务数多于人数,故规定其中有一人可兼完成两项任务,其余三人各完成一项任务。

是确定总花费时间为最小的指派方案。

(课本P113)假设第5个人是戊,他完成各项任务的时间取甲、乙、丙、丁中的最小者,构造表4—12。

由表4—12可得到系数矩阵C⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=32202627244523364224324028273433202638393741312925C1、将系数矩阵C输入程序。

2、对系数矩阵各行各列减去最小元素,即程序中的初始变换。

3、进行行变换4、进行列变换6、再次进行行变换7、再次进行列变换此时,已经不能用少于五根直线覆盖零元素,故此时为最优指派方案。

⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=32202627244523364224324028273433202638393741312925C [][][][][]⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡→20023120714001800113001318317100最优指派方案是:甲做B ,乙做C ,丙做E ,丁做A ,戊做D ,由于戊(虚拟的人)完成D 的时间与乙相同,实际上最优指派方案是:乙完成C 和D ,甲、丙、丁分别完成B ,E ,A ,总计时间为131。

六、结论和总结。

匈牙利法解指派问题,其步骤简单易懂,操作起来也不难,可是由于计算量实在太大很容易出错,故利用程序来完成对系数矩阵的化简变换是再好不过的。

只要确定输入,以及找出的覆盖集合无误,则计算结果就不会出错。

由于时间仓促,我编的程序还有许多不足之处,比如说:在输入系数矩阵之前,需要事先定义二维数组的行及列。

针对这个问题我尝试了好几次,也没有解决。

查了一些资料,好像可以通过动态分配二维数组的空间大小来实现二维数组行和列的输入。

本来我想实现程序对系数矩阵零元素的直线覆盖功能的,可操作起来实在太难,故改为手动操作。

通过这次课程设计,我不仅对运筹学的知识进行了巩固,也发觉到了编程对数学的强大辅助功能。

利用它可以解决好多数学问题,大大节省了时间及精力。

学好数学和计算机是今后就业的重要筹码。

相关文档
最新文档