自动化仓库存储毕业设计

1.绪论 ................................................................... 0 1.1 自动化立体仓库的进展 ................................................ 3 1.2 自动化立体仓库的概念 ................................................ 3 1.2 自动化立体仓库的特点 ................................................ 2 2.货位规划 ............................................................... 4 2.1设计条件 ............................................................ 4 2.2运算系数矩阵 ........................................................ 4 2.2.1符号假设 ........................................................ 4 2.2.2条件 ............................................................ 5 2.2.3运算系数矩阵 .................................................... 5 2.3运用匈牙利算法求解 .................................................. 7 2.4最终的货位规划图 ................................................... 14 2.5运行结果 ........................................................... 14 2.6设计总结 ........................................................... 15 3.堆垛机径路规划 ........................................................ 17 3.1设计条件 ........................................................... 17 3.2运算节点相对距离 ................................................... 17 3.2.1符号假设 ....................................................... 18 3.2.2条件 ........................................................... 18 3.2.3运算节点相对距离 ............................................... 18 3.3规划堆垛机合理线路 ................................................. 20 3.3.1最近邻点法 ..................................................... 20 3.3.2最近插入法 ..................................................... 22 3.3.3两种方法的程序运行结果 ......................................... 27

3.4分析结果 ........................................................... 27 3.5设计总结 ........................................................... 28 参考文献 ................................................................ 30 附录 .................................................................... 31

1.绪论

1.1 自动化立体仓库的进展

1.1.1 国外自动立体仓库的进展

自动化立体仓库的产生和进展是第二次世界大战之后生产和技术进展的结果。50年代初，美国显现了采纳桥式堆垛起重机的立体仓库；50年代末60年代初显现了司机操作的巷道式堆垛起重机立体仓库；1963年美国领先在高架仓库中采纳运算机操纵技术，建立了第一座运算机操纵的立体仓库。此后，自动化立体仓库在美国和欧洲得到迅速进展，并形成了专门的学科。60年代中期，日本开始兴建立体仓库，同时进展速度越来越快，成为当今世界上拥有自动化立体仓库最多的国家之一。

1.1.1 我国自动化立体仓库的进展概况

我国自动化仓库的进展与欧美、日本等发达国家相比起步较晚，国内第一座自动化仓库是郑州纺织机械厂冷作二车间的模具库，建成于1974年2月，与此同时，国内一些科研机构也开始了自动化仓库的研究工作。起步最早的是原一机部系统的起重研究所、自动化研究所和第九设计院等单位。1974年北京汽车制造厂与自动化研究所合作，动工兴建了该厂的自动化仓库。稍后，北京商业储运公司与河南粮食科研所和中科院自动化研究所合作，兴建了该公司的针织品自动化仓库。至1980年，我国差不多建成和正在施工建设中的自动化仓库达到21座。

我国的自动化仓库大部分是简易的中低层小型分离式仓库。货架只有单元货架和重力货架两种。作业方式几乎差不多上巷道堆垛机配以小车、叉车或输送机等周边设备。这些仓库要紧分布在机械制造业，其次是商业、电气行业。仓库的操纵以手动操纵为主，能够单机自动远距离操纵的目前只有北京汽车制造厂零件库、长沙火车站库和天津储运公司库。

在差不多建成的自动化仓库中，有一些还处于调试中，有一些那么因故障率太高，难以正常使用。

1.2 自动化立体仓库的概念

所谓自动化立体仓库是指在高层货架用货箱或托盘储存物资，用电子运算机治理和操纵巷道式堆垛机及其他机械，不需要人工搬运作业而实现收发作业的仓库。

1.2.1 自动化立体仓库的种类

自动化立体仓库能够按照物品的特性、自动化立体仓库的建筑物形式及设备形式等进行分类，下面逐一进行介绍。 1．按照储存物品的特性进行分类

⑴ 常温自动化立体仓库系统：常温仓库系统温湿度一样在5℃～40℃一下，相对湿度在90﹪以下。

⑵ 低温自动化立体仓库系统：该系统包括恒温空调仓储系统、冷藏仓储系统、冷冻仓储系统等。

① 恒温空调仓储系统相关于温湿度的要求是低温、低湿度，依照其存放物品关于温湿度的要求而设计。

② 冷藏仓储系统的温度必须在低温0℃～5℃之间，要紧用作蔬菜和水果的储存。 ③ 冷冻仓库系统，一样而言有-2℃到-35℃极速冷冻。但由于刚才在-20℃以下会有脆化现象，机械性只会急剧变化，因此冷冻自动仓库的钢架必须考虑使用低温材料以及低温焊材。

⑶ 防爆型自动仓储系统：要紧以存放具有挥发性或易于燃爆的物品为主，因此其系统中使用的电器电控照明等设备，必须考虑其功能，按照不同的防爆等级来设计，因此会有不同的造价。

2.按照自动化立体仓库建筑形式进行分类

按照建筑物形式划分能够将自动化立体仓库分为自立式钢架仓储系统、一体式钢架仓储系统。

3.按照自动化立体仓库设备形式进行分类

按照自动化立体仓库设备形式来划分，自动仓储系统能够分为单位负载式自动化立体式仓库、开放式钢架、封闭式钢架、推回式钢架、重力式钢架、水平式钢架子母车系统等等。

1.3 自动化立体仓库的特点

1.3.1 自动化立体仓库的优点

自动化立体仓库的要紧优点有以下几个方面： ⑴ 提高劳动生产率，降低劳动强度。 ⑵ 提高仓库空间利用率。 ⑶减少商品的破旧率。 ⑷提高仓库的治理水平。

1.3.2 自动化立体仓库的缺点

自动化立体仓库的缺点要紧在以下六个方面;

⑴结构复杂，配套设备多，建筑和设备投资较高。

⑵货架安装精度要求高，施工比较困难，而且施工的周期长。

⑶储存物资的品种受到一定，不适于储存超长和重量较大的物资。 ⑷作业弹性小，难以应对储存高峰需要。 ⑸设备的保养和爱护依靠于供应商。

⑹系统发挥优势，需与其他治理咨询系统〔采购、配送、销售〕相结合。 因此，在选择建设自动化立体仓库时，必须综合考虑自动化立体仓库在整个企业中的运营策略地位和设置自动化立体仓库的目的，不能为了自动化而自动化，而后再详细斟酌建设自动化立体仓库所带来的正面和负面阻碍。最后，还要考虑相应采取的补救措施。因此，在实际建设中必须进行详细的方案规划，进行综合评测，最终确定建设方案。

2.货位规划 2.1设计条件

某自动化立体仓库采纳2行3列的单元货格式货架存放物资，一共有6个货格，每个货格存放一个托盘物资。货格以按列编码的形式进行编号，如图2.1所示。其它参数假定如下：假设堆垛机在水平方向的行驶速度Vx=3.0m/s，在垂直方向的行驶速度Vy=2m/s；货格大小为L〔长〕×W〔宽〕×H〔高〕=1m×1m×0.8m；堆垛机初始状态在

xy原点0处；货格j的横坐标j和纵坐标j确实是其所在的列和行，如货格6的坐标为〔3，2〕。现有6个托盘物资需要存放到货架上，物资的出入库频率如表2.1所示。

Vy

2 4 6 1 3 5 0

图2.1原始货格图 表2.1 托盘物资出入库频率表

Vx

物资 A B 频率 6 30 物资 C D 频率 15 9 物资 E F 频率 4 20 依照以上条件，利用匈牙利算法合理安排各托盘物资的存放位置。

2.2运算系数矩阵

2.2.1符号假设

，i=A，B，C，D，E，F； fi为第i种物资的出入库频率〔次数〕

2．xj，yj分别为货格j的横坐标和纵坐标，即货格j所在的列和行〔距离巷道口最近1.

的列记为第1列，最底层记为第1层〕，j=1，2，3，4，5，6； 3．vx为水平方向的行驶速度； 4.vy为垂直方向的行驶速度；

5.L为货格的长； 6.W为货格的宽；

7.H为货格的高；

8.tj为堆垛机运行之货格j所用时刻，该时刻是堆垛机行进过程中水平方向和垂直方向所用时刻的最大值，j=1，2，3，4，5，6；

9. cij为堆垛机将物资i向货格j存取时所花费的时刻。

2.2.2条件

fA=6，fB=30，fC=15，fD=9，fE=4，fF=20； vx=3.0m/s, vy=2.0m/s；L×W×H=1m×1m×0.8m；

货格1的坐标为〔x1，y1〕=(1,1)；货格2的货格为〔x2，y2〕=〔1，2〕；货格3的坐标为〔x3，y3〕=〔2，1〕；货格4的坐标为〔x4，y4〕=〔2，2〕；货格5的坐标为〔x5，y5〕=〔3，1〕；货格6的坐标为〔x6，y6〕=〔3，2〕。

2.2.3运算系数矩阵

xjLyj1H1.运算tj：公式为tj=max, 〔2.1〕

vyvxx1Ly11H11110.8,,=max=max=1/3 t123vyvx

x2Ly21H11210.8,,=max=max=2/5 t223vyvx

x3Ly31H21110.8,,=max=max=2/3 t323vyvxx4Ly41H21210.8,,=max=max=2/3 t423vyvx

x5Ly51H31110.8,=max=max,=1 t523vyvxx6Ly61H31110.8,,=1 =maxt6=max23vyvx2.运算系数矩阵中的系数：cij=fitj 〔2.2〕

cA1=fAt1=6×1/3=2, cB1=fBt1=30×1/3=10,

cC1=fCt1=15×1/3=5,cD1=fDt1=9×1/3=3,

cE1=fEt1=4×1/3=4/3，cF1=fFt1=20×1/3=20/3； cA2=fAt2=6×2/5=12/5，cB2=fBt2=30×2/5=12， cC2=fCt2=15×2/5=6，cD2=fDt2=9×2/5=18/5， cE2=fEt2=4×2/5=8/5，cF2=fFt2=20×2/5=8； cA3=fAt3=6×2/3=4，cB3=fBt3=30×2/3=20， cC3=fCt3=15×2/3=10，cD3=fDt3=9×2/3=6， cE3=fEt3=4×2/3=8/3，cF3=fFt3=20×2/3=40/3； cA4=fAt4=6×2/3=4，cB4=fBt4=30×2/3=20， cC4=fCt4=15×2/3=10，cD4=fDt4=9×2/3=6， cE4=fEt4=4×2/3=8/3，cF4=fFt4=20×2/3=40/3； cA5=fBt5=6×1=6，cB5=fBt5=30×1=30， cC5=fCt5=15×1=15，cD5=fDt5=9×1=9， cE5=fEt5=4×1=4，cF5=fFt5=20×1=20； cA6=fAt6=6×1=6，cB6=fBt6=30×1=30， cC6=fCt6=15×1=15，cD6=fDt6=9×1=9， cE6=fEt6=4×1=4，cF6=fFt6=20×1=20；

得到系数矩阵表：

表2.2系数矩阵表 1 2 3 4 5 6 A 2 12/5 4 4 6 6 B 10 12 20 20 30 30 C 5 6 10 10 15 15 D 3 18/5 6 6 9 9 E 4/3 8/5 8/3 8/3 4 4 F 20/3 8 40/3 40/3 20 20 2.3运用匈牙利算法求解

1. 匈牙利算法的步骤

第一步：建等效矩阵。

（1） 从系数矩阵的每行元素中减去该行的最小元素。 （2） 再从所得系数矩阵的每列元素中减去该列的最小元素。 第二步：找0元素，进行试指派。

〔1〕从只有一个0元素的行〔或列〕开始，给那个0元素加括号〔0〕，表示这行所代表的货格已有一种物资分配。然后划去〔0〕所在列〔或行〕的其它0元素，记作〝〞，表示这列所代表的物资已指派。

〔2〕对只有一个0元素的列〔或行〕的0元素加括号〔0〕，然后划去〔0〕所在行〔或列〕的0元素，记作〝〞。

假如在〔1〕，〔2〕两步中，遇到每一行和每一列都有两个或两个以上的0元素，可任选一个加括号，同时把其所在行和列的0元素都划去。 〔3〕重复〔1〕，〔2〕两步，直到所有0元素都被加括号或打叉。

〔4〕加括号的0元素即为0元素，假设其个数m等于矩阵的阶数n，那么已得到问题的最优解。假设m〔2〕对以打〝√〞的行中所含0元素的列打〝√〞。

〔3〕再对〔2〕，〔3〕，直到得不到新的打〝√〞的行、列为止。

〔4〕将没有打〝√〞的行和以打〝√〞的列用直线覆盖，且直线的数目一定等于0元素的个数。转第四步。 第四步：增加0元素。

从没有被直线覆盖的元素中找出最小元素。未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，转第二步，重新确定0元素。 2．应用过程

(1)给系数矩阵表乘以15， 从系数矩阵的每行元素中减去该行的最小元素, 再从所得系数矩阵的每列元素中减去该列的最小元素，得到等效矩阵。

303660609090

15075180903001503001504502254502254520100025424120904020010 904020010201356030013560300200261300115505002501305525026011050026011050001680 80160160〔2〕①从只有一个0元素的第2行开始，给那个0元素加括号〔0〕，表示这行所代表的货格已有一种物资分配。然后划去〔0〕所在列的其它0元素，记作〝〞，表示这列所代表的物资已指派。②对只有一个0元素的第1列的0元素加括号〔0〕，然后划去〔0〕所在行的0元素，记作〝〞。

(0)21010202026130130260260115555110110525255050(0)1680 801601600元素的个数m=2<矩阵的阶数n=6，转入下一步。 〔3〕用最少的直线覆盖所有0元素。

①对第3、4、5、6行打〝√〞。 ②对第5列打〝√〞。

③得不到新的打〝√〞的行、列，停止。

④将没有打〝√〞的行和已打〝√〞的列用直线覆盖，且直线的数目一定等 于0元素的个数。

(0)210102020

〔4〕增加0元素。

26130130260260115555110110525255050(0)√ 16√ 80 √ 80√ 160√ 160√ 从没有被直线覆盖的元素中找出最小元素2。未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，

然后重新确定0元素。矩阵中0元素的个数m=3＜n=6，用最少的直线覆盖所有0元素。

00881818000249312853231285323258108482581084820(0)0148078 重新确定 0780元素 8180158015818(0)2(0)249381285323(0)8128532318258108481825810848√ 3232348258108481478 √ 78√ 158√ 158√ (0)24912853128532581082(0)1478 78158158m〔5〕连续增加0元素，即从未被直线覆盖的元素中找出一个最小元素，未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=3＜n=6，用最少的直线覆盖所有0元素。

001000024938 0120451500120451501025010040010250100400(0)10(0)2493814(0)m01470 重新确定 700元素 150150(0)10249381204515120451525010040(0)25010040

14√ 70 √ 70√ 150√ 150√ √ √ 〔6〕连续增加0元素，即从未被直线覆盖的元素中找出一个最小元素，未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此

得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=4＜n=6，用最少的直线覆盖所有0元素。

300010100001303(0)2162160811(0)117421174212067 重新确定 11742120670元素 117421024797247973701472479737014710247973(0)13216(0)811(0)117421267 √ √ 117421267102479737(0)147√ 102479737147√ (0)12123737138(0)1167 m030210117011710247102470242979701300811重新确定 12067 0元素 120673701473701473(0)1010

(0)211171172472472429797(0)12123737138(0)311m少的直线覆盖所有0元素。

15120010100211051052352350025015(0)12216(0)60811(0)10530300055 重新确定 3000550元素 10530102358525852501358525013510235852515(0)2512216(0)811√ (0)1053055 √ 1053055√ 102358525(0)135√ 102358525135√ √ √ √ 258(0)1155 m〔9〕连续增加0元素，即从未被直线覆盖的元素中找出一个最小元素，未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=5＜n=6，用最少的直线覆盖所有0元素。

2112(0)1010

(0)159999229229(0)2424797921006310121500205099240049 0992400491022979250129102297925012963121(0)1215205m素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=5＜n=6，用最少的直线覆盖所有0元素。

2101215099099021902190600240240691541021123051049 重新确定 10490元素 (0)01196915011921(0)11215(0)309924(0)10992410(0)21969152196915(0)√ 6(0)24(0)2469152196915549 √ 49√ 119√ 119√ (0)159999219413051049 m√ √ 〔11〕连续增加0元素，即从未被直线覆盖的元素中找出一个最小元素，未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=5＜n=6，用最少的直线覆盖所有0元素。

4536(0)(0)15(0)75751954519545

3024(0)151545003065361502454075001007500100195451500195451506545365451025 m〔12〕连续增加0元素，即从未被直线覆盖的元素中找出一个最小元素，未被覆盖的元素都减去该最小元素，而被两条线覆盖的元素都加上该最小元素，其它元素不变。如此得到新系数矩阵，然后重新确定0元素。矩阵中0元素的个数m=n=6，因此问题已得最优解，将矩阵中的非0元素变为0，将0元素变为1。

5000361000700070001904501904575050(0)361054070(0)1020 重新确定 10200元素 70(0)190450901509019045010000000001001000 000100100000000010352400153524(0)15(0)20 209015(0)9075541010m=n

由解可得最优分配方案：A物资放5货格，B物资放1货格，C物资放3货格，D物资放4货格，E物资放6货格，F物资放2货格。

2.4最终的货位规划图

2〔物资F〕 Vy 1〔物资B〕

4〔物资D〕 3〔物资C〕 6〔物资E〕 5〔物资A〕 图2.2最终的规划货位图

Vx 通过以上手工运算过程，我们得知运算繁琐且困难，运算结果误差较大，为了简化运算过程，减少作业量，提高完成作业的效率，同时使得运算结果精确而又可靠，也使得阅读者能清晰而又准确地明白得我们的运算过程，因此我们利用运算机编程语言，通过对程序的运行，得出2.5示结果图。

2.5运行结果

运算机编程运行过程与手算结果一致，编程语言见附录。

为了能更好更快地把握与编程有关的知识，在以后的学习工作中我们应该多多地运用此方法解决类似的设计问题，以提高作业效率。

2.6设计总结

在此次的课程设计中不仅检验了我们所学习的知识，也培养了我们如何去把握

一件情况，如何去做一件情况，又如何完成一件情况。在设计过程中，与同学分工设计，和同学们相互探讨，相互学习，相互监督。学会了合作，学会了运筹帷幄，学会了宽容，学会了明白得，也学会了做人与处世。

课程设计是我们专业课程知识综合应用的实践训练，也是我们迈向社会，从事职业工作前一个必许多的过程．〞千里之行始于足下〞，通过这次课程设计，我深深体会到这句千古名言的真正含义．我今天认真细致的进行课程设计，学会脚踏实地迈开这一步，确实是为改日能稳健地在社会大潮中奔驰打下坚实的基础．

通过这次货位优化设计，我们在多方面都有所提高。通过这次优化设计，综合运用本专业所学课程的理论和生产实际知识进行一次物资位置优化设计工作的实际训练从

而培养和提高学生工作能力，巩固与扩充了自动化立体仓库设计等课程所学的内容，把握自动化立体仓库设计的方法和步骤，把握货位优化设计的差不多思想，明白得了如何样分析货位能力，如何样确定设计方案，了解了货位的差不多结构，提高了运算能力，绘图能力，熟悉了规范和标准，同时各科相关的课程都有了全面的复习，摸索的能力也有了提高。

通过此次课程设计，我们了解了自动化立体仓库货位规划问题，并把握了解决那个问题的方法：匈牙利算法。利用匈牙利算法对货位进行规划，合理安排各托板物资的存放位置。将学到的运算方法灵活运用到现实问题中，能够量化的解决问题，增加了我的知识储备。在此过程中，培养了我们的细心运算和认真检查能力。更重要的是，我们学会了这种学习的方法，而这是日后最有用的，确实是受益匪浅，也感受到了收成的欢乐。

在此感谢我们的赵小柠老师.，老师严谨细致、一丝不苟的作风一直是我们工作、学习中的榜样；老师循循善诱的教诲和不拘一格的思路给予我们无尽的启发；这次自动化立体仓库货位优化设计的每个实验细节和每个数据，都离不开老师您的细心指导。而您爽朗的个性和宽容的态度，关心我们专门顺利的完成了这次课程设计。没有你的指导和讲解，我们全然无法顺利完成此次课程设计，设计过程中有专门多需要注意的事项和细节，你都反复跟我们强调，让我们尽量幸免显现不必要的错误。你细致而又耐心的解答我们每一个人的疑难问题，使得我们的设计过程变得顺理，设计结果更加准确。是你让我们明白得了好多不曾明白得知识，在设计过程中，我们不仅巩固了往常学过的相关知识，同时也通过此次设计了解并把握了相关的新知识，使得我们的各方面知识有更进一步的扩展。

同时感谢互帮互助的同学们，感谢大伙儿相互之间的关心和支持，让我们感受到同学之间的友谊之情。单靠一个人的力量是无法顺利完成课程设计，只有互相协助，互相合作，发挥各自优势，才能更好更有效地完成一项作业，所谓〝团结确实是力量〞。

由于我们的设计能力有限，在设计过程中难免显现错误，但我们也差不多专门努力的做了，有不足之处的恳请老师多多指教,及时住处我们存在的问题，并指导我们如何更好地完成课程设计，以便我们吸取教训，在以后的课程设计中不再显现类似的错误和不足，能专门快专门准确的完成课程设计，同时也慢慢完善我们自己的设计能力，为以后在工作中的相关设计奠定坚实的基础。我们将会十分诚恳地同意你的批判与指正，争取最大努力在以后的课程设计中做的越来越完美。

3.堆垛机径路规划

3.1设计条件

随机从图3.1中的25个货格中抽出7个货格的物资，分别用节点v1,v2,v3,v4,v5, v6,v7表示。节点间的距离用直角距离公式求解。分别用最近邻点法和最近插入法找出堆垛机存取7个托盘物资的合理路线。 Vy 5 (O) 4 (G) 3 (D) 2 (B) 1 (A) 10 (U) 9 (K) 8 (J) 7 (F) 6 (C) 15 (W) 14 (T) 13 (H) 12 (I) 11 (M) 20 (X) 19 (N) 18 (E) 17 (V) 16 (P) 25 (Y) 24 (Q) 23 (S) 22 (R) 21 (L) o 图3.1 最终的货位规划图 Vx 3.2运算节点相对距离

从图3.1中随机抽出7个货格的物资B、J、I、T、P、X、S，分别用节点 v1,v2,v3,v4,v5,v6，v7表示。货格和节点的相对位置如图3.2、图3.3所示。

Vy 5 (O) 4 (G) 3 (D) 2 (B) 1 (A) 10 (U) 9 (K) 8 (J) 7 (F) 6 (C) 15 (W) 14 (T) 13 (H) 12 (I) 11 (M) 20 (X) 19 (N) 18 (E) 17 (V) 16 (P) 25 (Y) 24 (Q) 23 (S) 22 (R) 21 (L) o

图3.2货格相对位置图 Vx

v6

v4 v2 v3 v1 v5

图3.3节点相对位置图

v7 3.2.1符号假设

vi表示节点i，i=1，2，3，4，5，6，7； 2.dvv为节点vi与vj之间的直角距离；

1.

ij3.

xi为节点i的横坐标； yi为节点j的纵坐标；

4. L为货格的长； 5.W为货格的宽； 6.H为货格的高；

3.2.2条件

节点v1的坐标为〔x1，y1〕=〔1,2〕，节点v2的坐标为〔x2，y2〕=〔2,3〕， 节点v3的坐标为〔x3，y3〕=〔3,2〕， 节点v4的坐标为〔x4，y4〕=〔3,4〕， 节点v5的坐标为〔x5，y5〕=〔4,1〕， 节点v6的坐标为〔x6，y6〕=〔4,5〕， 节点v7的坐标为〔x7，y7〕=〔5,3〕；L×W×H=1m×1m×0.8m；两货格相对距离相等。

3.2.3运算节点相对距离

运算出所有节点之间的相对距离，直角距离公式为：

dijxjxiLyjyiH 〔3.1〕

dvvx2x1Ly2y1H=|2-1|×1+|3-2|×0.8=1.8

12dvvx3x1Ly3y1H=|3-1|×1+|2-2|×0.8=2

13dvvx4x1Ly4y1H=|3-1|×1+|4-2|×0.8=3.6

14dvvx5x1Ly5y1H=|4-1|×1+|1-2|×0.8=3.8

15dvvx6x1Ly6y1H=|4-1|×1+|5-2|×0.8=5.4

16dvvx7x1Ly7y1H=|5-1|×1+|3-2|×0.8=4.8

17dvvx3x2Ly3y2H=|3-2|×1+|2-3|×0.8=1.8

23dvvx4x2Ly4y2H=|3-2|×1+|4-3|×0.8=1.8

24dvvx5x2Ly5y2H=|4-2|×1+|1-3|×0.8=3.6

25dvvx6x2Ly6y2H=|4-2|×1+|5-3|×0.8=3.6

26dvvx7x2Ly7y2H=|5-2|×1+|3-3|×0.8=3

27dvvx4x3Ly4y3H=|3-3|×1+|4-2|×0.8=1.6

34dvvx5x3Ly5y3H=|4-3|×1+|1-2|×0.8=1.8

35dvvx6x3Ly6y3H=|4-3|×1+|5-2|×0.8=3.4

36dvvx7x3Ly7y3H=|5-3|×1+|3-2|×0.8=2.8

37dvvx5x4Ly5y4H=|4-3|×1+|1-4|×0.8=3.4

45dvvx6x4Ly6y4H=|4-3|×1+|5-4|×0.8=1.8

46dvvx7x4Ly7y4H=|5-3|×1+|3-4|×0.8=2.8

47dvvx6x5Ly6y5H=|4-4|×1+|5-1|×0.8=3.2

56dvvx7x5Ly7y5H=|5-4|×1+|3-1|×0.8=2.6

57dvvx7x6Ly7y6H=|5-4|×1+|3-5|×0.8=2.6

67得到节点相对距离表：

表3.1节点相对距离表 元素 v1 v2 v3 v4 v1 — 1.8 2 3.6 v2 — 1.8 1.8 v3 — 1.6 v4 — v5 v6 v7 v5 3.8 3.6 1.8 3.4 — v6 5.4 3.6 3.4 1.8 3.2 — v7 4.8 3 2.8 2.8 2.6 2.6 — 3.3规划堆垛机合理线路

3.3.1最近邻点法

1．最近邻点法的思路

〔1〕从零点开始，作为整个回路的起点。

〔2〕找到离刚刚加入到回路中的顶点最近的一个顶点，并将其加入到回路中。 〔3〕重复步骤〔2〕，直到所有顶点都加入到回路中。 〔4〕最后，将最后一个加入的顶点和起点连接起来。 2.应用过程

〔1〕先将节点v1加入回路中，T={v1}。

〔2〕从节点v1动身，比较其到节点v2，v3，v4，v5，v6，v7的距离，选择其最小值，加入到回路中。

Min{dvv|i∈N,1≤i≤7，且i≠1}=dvv=1.8

1i12因此将v2加入到回路中，T={v1,v2}，其结果如图3.4。

v6 v4 v2 v3 v1 v5 图3.4步骤2图

v7 〔3〕从节点v2动身，在节点v3，v4，v5，v6，v7中，找出离v2最近的节点。 Min{dvv|i∈N,1≤i≤7，且i≠1，2}=dvv=1.8

2i23如此v3确实是最近的点，将v3加入回路中，T={v1，v2，v3}，其结果如图3.5。

v4 v2 v6 v7 v3 v1

v5 图3.5步骤3图 〔4〕从节点v3动身，在v4，v5，v6，v7中，找出离v3最近的节点。 Min{dvv|i∈N,1≤i≤7，且i≠1，2，3}=dvv=1.6

3i24如此v4确实是最近的点，将v4加入回路中，T={ 3.6所示。

v1，v2，v3，v4}，其结果如图

v4 v2 v6 v7 v3 v5

图3.6步骤4图

v1

〔5〕从节点v4动身，观看离v4最近的节点。

Min{dvv|i∈N,1≤i≤7，且i≠1，2，3，4}=dvv=1.8

4i46如此v6确实是最近的点，将v6加入到回路中，T={ 结果如图3.7所示。

v1

v1，v2，v3，v4，v6}，其

v4 v2 v3 图3.7步骤5图 v6 v7 v5

〔6〕从节点v6动身，观看离v6最近的节点。

Min{dvv|i∈N,1≤i≤7，且i≠1，2，3，4，6}=dvv=2.6

6i67如此v7确实是最近的点，将v7加入到回路中，T={ 其结果如图3.8所示。

v1，v2，v3，v4，v6，v7}，

v4 v2 v6 v7 v3 图3.8步骤6图

v1 v5 〔7〕从节点v7动身，v5是最后一个点，直截了当加入就能够加入了。然后，将v5和

v1相连，得到最后的解为{ v1，v2，v3，v4，v6，v7，v5}，其结果如图3.9。

因此堆垛机运行线路为：2→8→12→14→20→23→16 即取送物资次序为：B→J→I→T→X→S→P

堆垛机总行驶距离为： f=1.8+1.8+1.6+1.8+2.6+2.6+3.8=16

v4 v2 v6 v7 v3 v5 v1

图3.9步骤7图

3.3.2最近插入法

1.最近插入法的思路

〔1〕先将节点v1加入到回路中，找到dvv最小的节点vk，形成一个子回路，T={v1，vk，

k1v1}。

〔2〕在剩下的节点中，查找一个离子回路中某一节点最近的节点vk。

〔3〕在子回路中找到一条弧〔vi，vj〕，使得里程增量dvv+dvv－dvv最小。假

ikkjij如有多条满足条件，任选一条，然后将节点vk插入到vi和vj之间，用两条新的弧〔vi，，并将节点vk加入到子回路中。 vk〕和〔vk，vj〕代替原先的弧〔vi，vj〕

〔4〕重复步骤〔2〕和〔3〕，直到所有的节点都加入到子回路中。 2.应用过程

〔1〕比较货格相对距离表中从v1动身的所有路径的大小 Min{dvv|i∈N,1≤i≤7，且i≠1}=dvv=1.8

1i12如此就由节点v1和v2构成的子回路，T={v1，v2，v1}如图3.10所示。

v4 v2 v6 v7 v3 v1 v5

图3.10步骤1图

〔2〕然后考虑剩下的节点v3，v4，v5，v6，v7到v1和v2中某一个节点的最小距离：

Min{dvv，dvv|i∈N,1≤i≤7，且i≠1，2}=dvv=1.8

1i2i23〔3〕由于对称性，不管将v3插入到v1和v2之间往返路径中，结果差不多上一样的，如此，构成一个新的子回路T={v1，v2，v3，v1}，其结果如图3.11所示。

v6 v4 v2 v7 v3 v5 图3.11步骤2图

v1 〔4〕接着考虑剩下的节点v4，v5，v6，v7到v1，v2，v3中某一个节点的最小距离：

Min{dvv，dvv，dvv|i∈N,1≤i≤7，且i≠1，2，3}=dvv=1.6

1i2i3i34〔5〕由图3.11可知，节点v4有3个位置〔条弧线〕能够插入。现在分析将v4加入到哪里合适：

①插入到〔v1，v2〕间，⊿ =dvv+dvv－dvv=3.6+1.8－1.8=3.6

144212 ②插入到〔v2，v3〕间，⊿ =dvv+dvv－dvv=1.8+1.6－1.8=1.6

244323③插入到〔v3，v1〕间，⊿ =dvv+dvv－dvv=1.6+3.6－1.8=2.4

344131比较上面3中情形增量，插入〔v2，v3〕之间的增量最小，因此将v4节点加入到〔v2，v3〕，因此结果为：T={ 所示。

图3.12步骤3图 v1，v2，v4，v3，v1}，其子回路那么变为如图3.12

v6 v4 v2 v7 v3 v5 v1 〔6〕接着考虑剩下的节点v5，v6，v7到v1，v2，v3，v4中某一个节点的最小距离：

Min{dvv，dvv，dvv，dvv|i∈N,1≤i≤7，且i≠1，2，3，4}=dvv=1.8

1i2i3i4i46由图3.12可知，节点v6有4个位置〔条弧线〕能够插入。现在分析将v6加入到哪里合适：

①插入到〔v1，v2〕间，⊿ =dvv+dvv－dvv=5.4+3.6－1.8=7.2

166212 ②插入到〔v2，v4〕间，⊿ =dvv+dvv－dvv=3.6+1.8－1.8=3.6

2624③插入到〔v4，v3〕间，⊿ =dvv+dvv－dvv=1.8+3.4－1.6=3.6

466343④插入到〔v3，v1〕间，⊿ =dvv+dvv－dvv=3.4+5.4－2=6.8

366131比较上面4中情形增量，可将v6插入到〔v2，v4〕〔v4，v3〕的增量最小，现选其一，那个地点将v6节点加入到〔v4，v3〕间，结果为：T={

v1，v2，v4，v6，v3，

v1}，其子回路那么变为如图3.13所示。

v6 v4 v2 v7 v3 v5 图3.13步骤4图

v1 〔7〕接着考虑剩下的节点v5，v7到v1，v2，v3，v4，v6中某一个节点的最小距离： Min{dvv，且i≠1，2，3，4，6}=dvv=1.8 dv2vi，dv3vi，dv4vi，dv6vi|i∈N,1≤i≤7，1i35由图3.13可知，节点v5有5个位置〔条弧线〕能够插入。现在分析将v5加入到哪里合适：

①插入到〔v1，v2〕间，⊿ =dvv+dvv－dvv=3.8+3.6－1.8=5.6

155212 ②插入到〔v2，v4〕间，⊿ =dvv+dvv－dvv=3.6+3.4－1.8=5.2

255424③插入到〔v4，v6〕间，⊿ =dvv+dvv－dvv=3.4+3.6－1.8=5.2

4556④插入到〔v6，v3〕间，⊿ =dvv+dvv－dvv=3.2+1.8－3.4=1.6

655363⑤插入到〔v3，v1〕间，⊿ =dvv+dvv－dvv=1.8+3.8－2=3.6

355131比较上面5中情形增量，插入〔v6，v3〕之间的增量最小，因此将v5节点加入到〔v6，v3〕间，结果为：T={ 为如图3.14所示。

v1

v1，v2，v4，v6，v5，v3，v1}，其子回路那么变

v6 v4 v2 v3 v7 v5 图3.14步骤5图

〔8〕在最后考虑剩下的节点v7到v1，v2，v3，v4，v5，v6中某一节点的最小距离： Min{dvv，dvv，dvv，dvv，dvv，dvv|i∈N,1≤i≤7，且i≠1，2，3，4，5，

1i2i3i4i5i6i6}=dvv=dvv=2.6

5767v7有6个位置〔条弧线〕能够插入。现在分析将v7加入到哪里合适： ①插入到〔v1，v2〕间，⊿ =dvv+dvv－dvv=4.8+3－1.8=6 ②插入到〔v2，v4〕间，⊿ =dvv+dvv－dvv=3+2.8－1.8=4 ③插入到〔v4，v6〕间，⊿ =dvv+dvv－dvv=2.8+2.6－1.8=3.6 ④插入到〔v6，v5〕间，⊿ =dvv+dvv－dvv=2.6+2.6－3.2=2 ⑤插入到〔v5，v3〕间，⊿ =dvv+dvv－dvv=2.6+2.8－1.8=3.6 ⑥插入到〔v3，v1〕间，⊿ =dvv+dvv－dvv=2.8+4.8－2=5.6

1772122774244776677565577353377131 比较上面6种情形增量，v7插入到〔v6，v5〕间的增量最小，因此将v7节点加入到〔v6，v5〕间，结果为：T={ 那么变为如图3.15所示。

v2 v1

v1，v2，v4，v6，v7，v5，v3，v1}，其子回路

v6 v4 v7 v3 图3.15步骤6图 v5

利用最近插入法所得的解为：T={ v1，v2，v4，v6，v7，v5，v3，v1} 因此堆垛机运行路线为：2→8→14→20→23→16→12 即取送物资次序为：B→J→T→X→S→P→I 总距离为：f=1.8+1.8+1.8+2.6+2.6+1.8+2=14.4

节约路程为：16-14.4=1.6

通过对以上两种方法的最终运算结果进行比较，由此可得知，在堆垛机径路规划中最近插入法所得的运算结果要优于最近临点法所得的运算结果。堆垛机出入库调度优化问题是提高自动化立体仓库工作效率的关键因素之一，因此路径优化在自动化立体仓库的治理中显得尤为重，不仅需要有一个能得出最优路径的重要方法，而且还必须要有一个能用最优的最省事省力的方法得出那个最优的规划方案。因此，在上述的两种方法的基础上我们采取了运算机编程的方法，通过运行编程能够看出编程方法简单而又快速有效，其结果能让阅读者清晰明了的明白其原理，不像手工运算那么繁琐而又复杂，专门难让读者看清晰，而且其结果有相对的误差存在。另外，路径优化在自动化立体仓库中本来确实是一道专门关键的程序，假如不采取相对简单而又有效的方法确定其结果，将在专门大程度上阻碍整个作业的全部过程，从而增大作业成本，以及各种关键工序的时刻，以至于整个作业量加大，耗资又耗力，因此为了提高整个工作效率，我们选择运用运算机编程语言来实现径路选择，通过运行运算机编程得到3.3.3所示运行结果。

3.3.3两种方法的程序运行结果

程序运行结果与手算结果一致。C++程序见附录。

我通过这次实践发觉运用C++等编程工具得出的结论准确，且比人工手算快捷方便。在以后的学习实践中应多加运用和提高。

3.4分析结果

从3.3的结果可知，最近插入法求得的运行路线比最近邻点法求得的运行路线更优。最近邻点法的算法十分简单，然而得到的方案并不十分理想，有专门大的改善余地，故此法可作为进一步优化的初始方案。与之相比，最近插入法比较复杂，然而能够得到相对中意的方案。

两种方法都有各自的优势，假如遇到简单的问题，比如只有三五个节点，用最近邻点法就能得出最优方案。假如遇到复杂的问题，就要采纳最近插入法才能得出最优方案。

3.5设计总结

通过那个设计，第一，我了解到了自动化立体仓库在现代物流中的重要性以及堆垛机的径路选择在自动化立体仓库中的重要性。再次，我学会了利用数学的方法对堆垛机路径的规划做出最优的选择，也相信这次学习的两种方法-最近临点与最近插入法将在以后的学习与工作中得到专门好地运用，在用这两种方法的时候我深刻地体会到什么叫一失足成千古恨，它不承诺一丁点的失误。而正是这种运算特点使我在把握这两种方法的同时学会了更加用心的去对待问题。同时也明白了思维缜密，思路严谨在不管是工作依旧日常事务中是多么的重要。有时候甚至会决定一个人的成功与否。最后，我要说，过程尽管专门困难，结果却专门难得。收成更是不可轻视的。因此，这与专业老师的认真指导是分不开的。

以下我将论述一下这次学到的关于专业的相关的知识。

第一，自动化立体仓库的组成：立体货架、有轨巷道、堆垛机、出入库托盘输入系统、尺寸检验条码阅读系统、通讯系统、自动操纵系统、运算机监控系统、运算机治理系统以及其他如电线电缆桥架配电柜、托盘、调剂平台、钢结构平台等辅助设备。它运用一流的集成化理念，采纳先进的操纵、总线、通讯和信息技术，通过以上设备的和谐运作按照用户的需求完成物资的自动有序、快速准确、高速有效的出库入库作业。

第二，自动化立体仓库是现代物流系统中物流进展的一个重要组成部分，具有节约用地，减轻劳动强度，排除擦错、提高自动化水平及其治理水平。提高感力人员和操作人员素养，降低贮运损耗。有效的减少劳动资金积压、提高物流效率等诸多优点。 同时，使用电子运算机不仅能够实现仓库治理的自动操纵，而且能够进行信息处理。

第三，自动化围绕自动仓储系统开发了多种自动化硬件设备及软件设备产品。如：不同类型的库存治理软件、系统仿真软件、图形监控及调度软件、堆垛机输送机操纵软件、条形码识别跟踪系统、搬运机器人、码垛机器手、自动运行小车、物资分选系统、堆垛机认证监测系统、堆垛机操纵系统、货位探测器、高度检测器、输送系统、码垛系统、自动输送小车等产品。采纳现场操纵总线直截了当操纵的方式，真正做到运算机只控不检，所有的决策，调度方式及现场信息等均有堆垛机、出入库输送机等现场设备通过相互间的通讯来完成。堆垛机有自动找回原点的功能，即不管任何情形，只要货叉剧中级水平运行正常，可按照下达的名利自动返回原点，

这意味着操作人员和爱护人员能够尽量不进入巷道。

堆垛机是整个自动化立体仓库的核心设备，通过手动操作，半自动操作自动操作与全自动操作实现把物资从一出搬运到另一处，它由机架，水平行走机构，提升机构，载货台、货叉及电动操纵系统构成。

1，堆垛机形式的确定，对多机型是多种多样，包括单轨巷道堆垛机，巷道式堆垛机 ，转巷道式堆垛机，单立柱性堆垛机，双立柱性堆垛机等等。

2，堆垛机速度的确定，依照仓库流量要求，运算出堆垛机水平速度，提升速度以及货叉速度。

参考文献

【1】焦永兰.«治理运筹学». 北京：中国铁道出版社.2000年3月 【2】蔡临宁.«物流系统规划——建模及实例分析». 北京：机械工业出版社 【3】李霞.«区域物流规划与治理». 北京：经济科学出版社.2020 【4】钱颂迪.运筹学(第三版).北京:清华大学出版社.2005

【5】郝勇.张丽.黄健伟.«物流系统规划与设计». 北京：清华大学出版社.2020 【6】刘昌祺.董良.«自动化立体仓库设计». 北京：机械工业出版社.2004 【7】贾争现.«物流配送中心规划与设计». 北京：机械工业出版社.2020

【8】何善君.«自动小车存取系统的建模及假设干关键技术研究».[D].厦门大学，2020. 【9】李梅娟.«自动化仓储系统优化方法的研究».[D].大连理工大学，2020.

【10】商允伟、刘长有.«自动化仓库货位分配优化问题研究».[J].运算工程与应用，2004. 【11】魏飞、周燕飞.«自动化立体仓库中复合出入库作业的优化».起重运输机械，2007〔07〕. 【12】周奇才.«自动化仓库系统运行的优化操纵».[J].起重机械，2000〔03〕. 【13】周奇才.«基于现代物流的自动化立体仓库系统治理».[D]西南交通大学,2002. 【14】邹晖华、胡吉全.«自动化立体仓库分配策略优化研究».[J].科技资讯，2006〔17〕.

附录

1.匈牙利算法源程序代码 #include \"stdio.h\" #include \"fstream.h\" #include \"iostream\" #include #define TRUE 1 #define FALSE 0 #define BOOL int using std::ios_base; BOOL OutPut(double **,int);

void MaxSubstract(double **A,int n); double GetMaxItem(double **A,int n); double Min(double **,int,int,int =0); int Adjust(double **,int);

//求某一行或列的最小值

//调整效率矩阵使每一行列都含有零元素

int Record(double **,double **,int ,int *,int *);

int MinCount(double *,int,double *); //找出含有零元素最少的某行(列) int Choose(double **,int,int *,int *,int,int,int,int&,int *,int *); int LocalFirst(double **,int,int,int =1); //找出零的位置

int Change(double **,double **,int ,int *,int *,int *R,int *C);//覆盖 int Allot(double **,double **,int ,int *,int *);

//全局分配

void Print(double **A,double **M,int n,int *Row,int *Col,int *P,int *Q,int *P1=NULL,int *Q1=NULL);//画出分配的步骤

ofstream myfile(\"匈牙利算法演算过程.txt\int main() { int n = 6;

double r1[6] = {30,150,75,45,20,100}; double r2[6] = {36,180,90,54,24,120}; double r3[6] = {60,300,150,90,40,200}; double r4[6] = {60,300,150,90,40,200};

double r5[6] = {90,450,225,135,60,300}; double r6[6] = {90,450,225,135,60,300}; double *k[6] = {r1,r2,r3,r4,r5,r6}; double **A = k; double **M=NULL; if (n>0)

{ M=new double*[n];

for (int i=0;iM[i]=new double[n];}

for (i=0;ifor (int j=0;jint *Row=new int[n]; int *Col=new int[n]; for (int i=0;i//cout<<\"====原矩阵====\"<for (i=0;iRow[i]=Col[i]=0;

{cout<cout<Record(A,M,n,Row,Col); Allot(A,M,n,Row,Col);

}

cout<cout<cout<BOOL OutPut(double **A,int n){

for (int i=0;ifor (int j=0;j//cout<//cout<}

return TRUE; }

double GetMaxItem(double **A,int n)

{ double max = A[0][0];

for (int i=0;i{ if (max < A[i][j])

{ max = A[i][j]; }}}

//cout<<\"猎取最大元素值得:\"<void MaxSubstract(double **A,int n) { int max = GetMaxItem(A,n);

for (int i=0;i{ A[i][j] = max - A[i][j];

}

}}

//cout<<\"最大元素都减去每个元素得矩阵:\"<//找出第n行(列)中最小的值 //flag==1表示行 //flag==0表示列

double Min(double **A,int n,int rc,int flag){

double min; if (flag){

min=A[rc][0];

for (int j=1;jA[rc][j])

{ min=A[rc][j];} }} else{

min=A[0][rc];

for (int i=1;iA[i][rc])

{ min=A[i][rc];} }

//调整效应矩阵使每行列都含有0元素 int Adjust(double **A,int n){

double min;

for (int i=0;imin=Min(A,n,i,1);//求第i行中最小值 if (min!=0){ }

for (int j=0;j}}

return min;

}

//cout<<\"=====每行都减去该行最小元素得矩阵=====\"<myfile<<\"每行都减去该行最小元素得:\"<for (int j=0;j//cout<<\"====每列都减去该列最小元素得矩阵=====\"<myfile<<\"每列都减去该列最小元素得:\"<min=Min(A,n,j,0); if (min!=0){ }

for (i=0;iint Record(double **A,double **M,int n,int *Row,int *Col){ }

int Result(int *Row,int *Col,int n){

int flag=1;

for (int i=0;iif (Row[i]!=1||Col[i]!=1){flag=0; }}

break;

for (int k=0;kfor (int j=0;jif (M[i][j]=(A[i][j]==0)){ Row[i]+=1;//运算每行零的个数

Col[j]+=1;//运算每列零的个数

}}}

return TRUE;

return flag;}

//找出没有被分配且零最少的行或列(不运算不含零元素的列) int MinCount(int *rc,int n,int *P){ int min=10000000; int k=-1;

for (int i=0;irc[i]){ min = rc[i]; k=i;

}

}

return k;//k=-1表示没有零元素

}

//找出某行或某列零元素的位置或多个零元素的第一个零的位置 int LocalFirst(double **M,int n,int rc,int flag){ int i=0;

if (flag){//flag==1表示查找行中的零

for (i=0;i}

return i==n?-1:i;//-1表示没有零元素

}

//选中零并划去同行或同列的零

//flag1: 0 按列分配零 1 按行分配零 //flag2: 0 一行(列)中有一个零 2 一行(列)中有多个零

int Choose(double **M,int n,int *Row,int *Col,int rc,int flag2,int &m,int *P,int *Q){ if (flag1){//行 int col=LocalFirst(M,n,rc,1);//col:零所在列

for (int i=0;iif (M[i][col]==1){//给零所在列的其他行零画×

M[i][col]=-1;//画×

Col[col]-=1;//该列的零的个数减一，那个地点连零都给画掉

}

}

Row[i]-=1;

Col[col]+=1;//多减了一个零，就得加上 Row[rc]+=1;

if (flag2){//假如该行有多个零，需要进行试分配 }

M[rc][col]=1;//给零画◎ m++;//分配一个零个数就加一 P[rc]=col; Q[col]=rc;

for (int j=0;jif (M[rc][j]==1){//把该行其他的零画× }}

M[rc][j]=-1;

Row[rc]-=1;//该行的零划掉一个就减一 Col[j]-=1;

}else{//列

int row=LocalFirst(M,n,rc,0);//row:零所在行 for (int j=0;jif (M[row][j]==1){ }}

M[row][j]=-1;//画× Row[row]-=1; Col[j]-=1;

Row[row]+=1; Col[rc]+=1;

}

}

if (flag2){//该列零的个数不是一个，需进行试分配

for (int i=0;iif (M[i][rc]==1){

M[i][rc]=-1; Col[rc]-=1; Row[i]-=1;

}}}

M[row][rc]=1;//画◎ m++; P[row]=rc; Q[rc]=row;

return TRUE;

//判定能否还能划线

BOOL CanDraw(double **A,double **M,int n,int *P,int *Q){

for (int i=0;iif (P[i]==1){

for (int j=0;jif (Q[j]!=1&&A[i][j]==0)

{ return TRUE;} }

//划线调整矩阵√

int Change(double **A,double **M,int n,int *Row,int *Col,int *R,int *C){

int *P=new int[4];//标记各行是否打√ int *Q=new int[4];//标记各列是否打√ for (int k=0;kif (Row[i]==0){ P[i]=1;//给没有画◎的行划√

}}}

return FALSE;

} }

}

while (CanDraw(A,M,n,P,Q)){

for (int i=0;ifor (int j=0;jif (P[i]==1){for (int j=0;jmyfile<myfile<<\"最少的直线覆盖所有的0元素,打钩钩得:\"; Print(A,M,n,Row,Col,R,C,P,Q); myfile<for (i=0;iif (P[i]==1){

for (int j=0;jif (Q[j]!=1){

if (min>A[i][j]){

min=A[i][j];//找出最小元素

}}}}}

for (i=0;iif (P[i]==1){

for (int j=0;jif (Q[j]!=1){

A[i][j]-=min;

}}}}

Record(A,M,n,Row,Col);//从新进行试分配的初始化

// delete[] P; // delete[] Q; }

return TRUE;

BOOL ExistOneZero(int *Row,int *Col,int n,int *P,int *Q){ } //分配

int Allot(double **A,double **M,int n,int *Row,int *Col){

int *P1=new int[4];//标记行是否分配过 int *Q1=new int[4];//标记列是否分配过 int m=0;

for (int i=0;iwhile(ExistOneZero(Row,Col,n,P1,Q1)){//画零

row=MinCount(Row,n,P1); rowcount=Row[row];

while (rowcount>=1&&row!=-1){

//row行的零的个数为1，对其进行试分配 myfile<myfile<<\"对第\"<{ Choose(M,n,Row,Col,row,1,1,m,P1,Q1); } else

{ Choose(M,n,Row,Col,row,1,2,m,P1,Q1); } Print(A,M,n,Row,Col,P1,Q1,NULL,NULL); row=MinCount(Row,n,P1); rowcount=Row[row]; }

for (int i=0;iif (Row[i]==1&&P[i]==-1||Col[i]==1&&Q[i]==-1){ }}

return TRUE;

return FALSE;

col=MinCount(Col,n,Q1);

colcount=Col[col];

while (colcount>=1&&col!=-1){

//col列的零的个数为1，对其进行试分配 myfile<myfile<<\"对第\"<{ Choose(M,n,Row,Col,col,0,1,m,P1,Q1);} else

{ Choose(M,n,Row,Col,col,0,1,m,P1,Q1)} Print(A,M,n,Row,Col,P1,Q1,NULL,NULL); col=MinCount(Col,n,Q1); colcount=Col[col]; }

if (mChange(A,M,n,Row,Col,P1,Q1);

for (int i=0;imyfile<<\"增加0元素,重新确定0元素:\"<//cout<<\"差不多找到最优解\"<row=MinCount(Row,n,P1);//row行

if (row!=-1&&rowcount>1){//零的个数不为1

Choose(M,n,Row,Col,row,1,0,m,P1,Q1); Print(A,M,n,Row,Col,P1,Q1); }}

if (Result(Row,Col,n)){

//cout<<\"差不多找到答案\"<//cout<<\"===========转化为01阵得=========\"<{ if (M[i][j] == 1)

{ cout<myfile<else

{ cout<myfile<}}

cout<return TRUE;}

void Print(double **A,double **M,int n,int *Row,int *Col,int *P,int *Q,int *P1,int *Q1){

//cout<for (int i=0;ifor (int j=0;jif (P[i]==j&&Q[j]==i){

//cout<}else if (M[i][j]==-1){

//cout<}else{ //cout<//cout<if (P1!=NULL){

if (P1[i]==1){

//cout<}else{//cout<myfile<}}

//cout<for (int k=0;k// // // } } } }

cout<}

if (Q1!=NULL){

for (i=0;iif (Q1[i]==1){

//cout<}else{ //cout<myfile<//cout<2、最近邻点法与最近插入法源程序代码

#include #include using namespace std;

#define L 1 //货格长 #define H 0.8 //货格高 int main() {

int i,j=1,k,h=2,m=1;

double x[8],y[8]; //货格的坐标

double distance[8][8]; //vm到vk的距离 double path[8][8]; for(i=1;i<8;i++) {

cout<<\"请输入货格v\"<>x[i]>>y[i]; }

for( m=1;m<8;m++) //运算vm到vk的距离 {

for(int k=1;k<8;k++) {

if(x[m]y[k])

distance[m][k]=(x[k]-x[m])*L+(y[m]-y[k])*H; if(x[m]distance[m][k]=(x[k]-x[m])*L+(y[k]-y[m])*H; if(x[m]>x[k]&&y[m]>y[k])

distance[m][k]=(x[m]-x[k])*L+(y[m]-y[k])*H; if(x[m]>x[k]&&y[m]distance[m][k]=(x[m]-x[k])*L+(y[k]-y[m])*H; if(x[m]==x[k]&&y[m]distance[m][k]=(y[k]-y[m])*H; if(x[m]==x[k]&&y[m]>y[k])

distance[m][k]=(y[m]-y[k])*H; if(x[m]distance[m][k]=(x[k]-x[m])*L; if(x[m]>x[k]&&y[m]==y[k])

distance[m][k]=(x[m]-x[k])*L; if(x[m]==x[k]&&y[m]==y[k]) distance[m][k]=0;

//cout<} }

cout<<\"输出运算最短距离\\n\";

cout<<\"******************最近邻点法************************\\n\"; //运算节点的最短距离 ///////***最近邻点法****/////// double temp; int a[7];

temp=distance[1][2];

for(j=2;j<8;j++) //************1 {

if(temp>distance[1][j]) {

temp=distance[1][j]; h=j; } }

path[1][h]=temp;

cout<<\"那么v[\"<<1<<\"]到其它节点v[\"<temp=100;

for(j=2;j<8;j++) //************2 {

if((j!=a[1])&&(j!=a[2])) {

if(temp>distance[m][j]) {

temp=distance[m][j]; h=j; } } }

path[m][h]=temp;

cout<<\"那么v[\"<temp=100;

for(j=2;j<8;j++) //************3 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])) {

if(temp>distance[m][j]) {

temp=distance[m][j]; h=j; } } }

path[m][h]=temp;

cout<<\"那么v[\"<for(j=2;j<8;j++) //************4 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])&&(j!=a[4])) {

if(temp>distance[m][j]) {

temp=distance[m][j]; h=j; } } }

path[m][h]=temp;

cout<<\"那么v[\"<temp=100;

for(j=2;j<8;j++) //************5 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])&&(j!=a[4])&&(j!=a[5])) {

if(temp>distance[m][j]) {

temp=distance[m][j]; h=j; } } }

path[m][h]=temp;

cout<<\"那么v[\"<a[6]=h; m=h;

temp=100;

for(j=2;j<8;j++) //************6 {

if((j!=a[2])&&(j!=a[3])&&(j!=a[4])&&(j!=a[5])&&(j!=a[6])) {

temp=distance[m][j]; h=j; a[7]=h; }

}

path[m][h]=temp;

cout<<\"那么v[\"<cout<<\"最近邻点法求得回路为：\"<<<\"、\"<cout<+distance[a[5]][a[6]]+distance[a[6]][a[7]]+distance[a[7]][a[1]]<for(j=2;j<8;j++) //************1 {

if(temp>distance[1][j]) {

temp=distance[1][j]; h=j; } }

cout<<\"闭合回路1：v[\"<<1<<\"]、v[\"<temp=100;

for(j=2;j<8;j++) //************2 {

if((j!=a[1])&&(j!=a[2])) //查找到节点的最近节点 {

if(temp>=distance[a[1]][j]) {

temp=distance[a[1]][j]; h=j; }

if(temp>=distance[a[2]][j]) {

temp=distance[a[2]][j]; h=j; } } }

a[3]=a[2]; //将第三个点插入到一二点中 a[2]=h;

cout<<\"闭合回路2：v[1]、v[\"<for(j=2;j<8;j++) //************3 {

if((j!=a[2])&&(j!=a[3])) //查找到节点的最近节点 {

if(temp>=distance[a[1]][j]) {

temp=distance[a[1]][j]; h=j; }

if(temp>=distance[a[2]][j]) {

temp=distance[a[2]][j]; h=j; }

if(temp>=distance[a[3]][j]) {

temp=distance[a[3]][j]; h=j; } } }

a[4]=h;

if((distance[a[1]][a[4]]+distance[a[4]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[2]][a[4]]+distance[a[4]][a[3]]-distance[a[2]][a[3]])&&

(distance[a[1]][a[4]]+distance[a[4]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[3]][a[4]]+distance[a[4]][a[1]]-distance[a[3]][a[1]])) //插入条件判定 {

a[4]=a[3]; a[3]=a[2]; a[2]=h; } else

if((distance[a[2]][a[4]]+distance[a[4]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[1]][a[4]]+distance[a[4]][a[2]]-distance[a[1]][a[2]])&&

(distance[a[2]][a[4]]+distance[a[4]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[3]][a[4]]+distance[a[4]][a[1]]-distance[a[3]][a[1]])) {

a[4]=a[3]; a[3]=h; } else

if((distance[a[3]][a[4]]+distance[a[4]][a[1]]-distance[a[3]][a[1]])<=

(distance[a[1]][a[4]]+distance[a[4]][a[2]]-distance[a[1]][a[2]])&&

(distance[a[3]][a[4]]+distance[a[4]][a[1]]-distance[a[3]][a[4]])<=

(distance[a[2]][a[4]]+distance[a[4]][a[3]]-distance[a[2]][a[3]])) {

a[4]=h; }

cout<<\"闭合回路3：v[1]、v[\"<for(j=2;j<8;j++) //************4 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])&&(j!=a[4])) //查找到节点的最近节点 {

if(temp>=distance[a[1]][j]) {

temp=distance[a[1]][j]; h=j;

}

if(temp>=distance[a[2]][j]) {

temp=distance[a[2]][j]; h=j; }

if(temp>=distance[a[3]][j]) {

temp=distance[a[3]][j]; h=j; }

if(temp>=distance[a[4]][j]) {

temp=distance[a[4]][j]; h=j; } } }

a[5]=h;

if(((distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]]))&&

(distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]])) //插入条件判定 {

a[5]=a[4]; a[4]=a[3]; a[3]=a[2]; a[2]=h; } else

if(((distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]]))&&

(distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]])) //插入条件判定 {

a[5]=a[4]; a[4]=a[3]; a[3]=h; } else

if(((distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]]))) //插入条件判定 {

a[5]=a[4]; a[4]=h; } else

if(((distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]])<=

(distance[a[1]][a[5]]+distance[a[5]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]])<=

(distance[a[2]][a[5]]+distance[a[5]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[4]][a[5]]+distance[a[5]][a[1]]-distance[a[4]][a[1]])<=

(distance[a[3]][a[5]]+distance[a[5]][a[4]]-distance[a[3]][a[4]]))) //插入条件判定 {

a[5]=h; }

cout<<\"闭合回路4:v[1]、v[\"<for(j=2;j<8;j++) //************5 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])&&(j!=a[4])&&(j!=a[5])) //查找到节点的最近节点 {

if(temp>=distance[a[1]][j]) {

temp=distance[a[1]][j]; h=j; }

if(temp>=distance[a[2]][j]) {

temp=distance[a[2]][j]; h=j; }

if(temp>=distance[a[3]][j]) {

temp=distance[a[3]][j]; h=j; }

if(temp>=distance[a[4]][j]) {

temp=distance[a[4]][j]; h=j; }

if(temp>=distance[a[5]][j]) {

temp=distance[a[5]][j]; h=j; } } }

a[6]=h;

if(((distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]]))) //插入条件判定 {

a[6]=a[5]; a[5]=a[4]; a[4]=a[3]; a[3]=a[2]; a[2]=h;

//cout<} else

if(((distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]]))) //插入条件判定 {

a[6]=a[5]; a[5]=a[4]; a[4]=a[3]; a[3]=h; } else

if(((distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]]))) //插入条件判定 {

a[6]=a[5]; a[5]=a[4]; a[4]=h;

//cout<if(((distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]]))) //插入条件判定 {

a[6]=a[5]; a[5]=h;

//cout<} else

if(((distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]])<=

(distance[a[1]][a[6]]+distance[a[6]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]])<=

(distance[a[2]][a[6]]+distance[a[6]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]])<=

(distance[a[3]][a[6]]+distance[a[6]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[5]][a[6]]+distance[a[6]][a[1]]-distance[a[5]][a[1]])<=

(distance[a[4]][a[6]]+distance[a[6]][a[5]]-distance[a[4]][a[5]]))) //插入条件判定 {

a[6]=h;

//cout<}

cout<<\"闭合回路5:v[1]、v[\"<for(j=2;j<8;j++) //************6 {

if((j!=a[1])&&(j!=a[2])&&(j!=a[3])&&(j!=a[4])&&(j!=a[5])&&(j!=a[6])) //查找到节点的最近节点 {

if(temp>=distance[a[1]][j]) {

temp=distance[a[1]][j]; h=j; }

if(temp>=distance[a[2]][j]) {

temp=distance[a[2]][j]; h=j; }

if(temp>=distance[a[3]][j]) {

temp=distance[a[3]][j]; h=j; }

if(temp>=distance[a[4]][j]) {

temp=distance[a[4]][j]; h=j; }

if(temp>=distance[a[5]][j]) {

temp=distance[a[5]][j]; h=j; }

if(temp>=distance[a[6]][j]) {

temp=distance[a[6]][j]; h=j; } } }

a[7]=h;

if(((distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]]))&&

((distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]])<=

(distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]]))) //插入条件判定 {

a[7]=a[6]; a[6]=a[5]; a[5]=a[4]; a[4]=a[3]; a[3]=a[2]; a[2]=h; } else

if(((distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]]))&&

((distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]])<=

(distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]]))) //插入条件判定 {

a[7]=a[6]; a[6]=a[5]; a[5]=a[4]; a[4]=a[3]; a[3]=h; } else

if(((distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]]))&&

((distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]])<=

(distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]]))) //插入条件判定 {

a[7]=a[6];

a[6]=a[5]; a[5]=a[4]; a[4]=h; } else

if(((distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]]))&&

((distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]])<=

(distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]]))) //插入条件判定 {

a[7]=a[6]; a[6]=a[5]; a[5]=h; } else

if(((distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]])<=

(distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]])<=

(distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]])<=

(distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]])<=

(distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]])<=

(distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]]))) //插入条件判定 {

a[7]=a[6]; a[6]=h; } else

if(((distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]])<=

(distance[a[1]][a[7]]+distance[a[7]][a[2]]-distance[a[1]][a[2]]))&&

((distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]])<=

(distance[a[2]][a[7]]+distance[a[7]][a[3]]-distance[a[2]][a[3]]))&&

((distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]])<=

(distance[a[3]][a[7]]+distance[a[7]][a[4]]-distance[a[3]][a[4]]))&&

((distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]])<=

(distance[a[4]][a[7]]+distance[a[7]][a[5]]-distance[a[4]][a[5]]))&&

((distance[a[6]][a[7]]+distance[a[7]][a[1]]-distance[a[6]][a[1]])<=

(distance[a[5]][a[7]]+distance[a[7]][a[6]]-distance[a[5]][a[6]]))) //插入条件判定 {

a[7]=h; }

cout<<\"闭合回路6:v[1]、v[\"<<<\"、\"<cout<+distance[a[5]][a[6]]+distance[a[6]][a[7]]+distance[a[7]][a[1]]<