送货路线设计(经典版)

数学建模作业六
论文成员：
09计本（2）班刘琳岚
09数本（1）班汪灵枝
09数本（1）班钟建忠
2011-8-7
内容摘要；首先标出50个地点。

然后用MATLAB软件计算出所有连通线路的距离。

结果（取整）如下所示。

（程序及结果见附录）
针对问题一：首先根据题中所给数据求出30件货物质量之和49.5kg、体积之和0.9m3，得出结果不超过送货员的载重。

所以这里不用考虑质量、体积的约束。

本文使用最小生成树法的改进模型，（当两点之间没有直线连接时，应改进为使其两点的距离最短；遇到两点之间不直接连接，如果由这两点组成的最短路径与后面有重复，必须把后面的路径中重复的部分删除。

），采用单一目标规划问题，对路程进行优化。

得到最优化路线；O-18-13-19-24-31-27-39-27-31-34-40-45-42-49-42-43-38-36-38-35-32-23-16-14-17-21-26-O.
其路程为D= 54618.59 米时间为t=3.32578小时。

针对问题二；题中增加了“时间”这一约束条件，而没有要求返回出发点。

所以我们必须在满足各点的时间要求前提下，寻找一条最优的路径。

对于此种情况的解决方法，我们将22个节点按时间限制划分为四个阶段，分别为：9:00、9:30、10：15、12:00 ，然后按照“时间要求越早，先送到”的原则。

分析各时间段所需到达的节点，在各区域得出最短路径。

依
据各分区域“路径均较短，则总路径较短”的原则（注：引自高教版《运筹学》动态规划最优化原理），最短距离用最小生成树法计算。

最后经过改进得出总距离最短的具体路径为O-18-13-19-24-31-27-39-27-31-34-40-45-42-49-42-43-38-36-38-35-32-23-16-14-17-21-26
其路程为 53226.59m 时间为3.27h 针对问题三；用最小生成树法对50个地点进行分析。

并用最小生成树法分三区并分组求出最佳送货路线，得出的结论可以很好的符合此问题的要求。

一·问题重述
现今社会网络越来越普及，网购已成为一种常见的消费方式，随之物流行业也渐渐兴盛，每个送货员需要以最快的速度及时将货物送达，而且他们往往一人送多个地方，请设计方案使其耗时最少。

现有一快递公司，库房在图1中的O 点，一送货员需将货物送至城市内多处，请设计送货方案，使所用时间最少。

该地形图的示意图见图1，各点连通信息见表3，假定送货员只能沿这些连通线路行走，而不能走其它任何路线。

各件货物的相关信息见表1，50个位置点的坐标见表2。

假定送货员最大载重50公斤，所带货物最大体积1立方米。

送货员的平均速度为24公里/小时。

假定每件货物交接花费3分钟，为简化起见，同一地点有多件货物也简单按照每件3分钟交接计算。

现在送货员要将100件货物送到50个地点。

请完成以下问题。

1. 若将1~30号货物送到指定地点并返回。

设计最快完成路线与方式。

给出结果。

要求标出送货线路。

2. 假定该送货员从早上8点上班开始送货，要将1~30号货物的送达时间不能超过指定时间，请设计最快完成路线与方式。

要求标出送货线路。

3. 若不需要考虑所有货物送达时间限制(包括前30件货物)，现在要将100件货物全部送到指定地点并返回。

设计最快完成路线与方式。

要求标出送货线路，给出送完所有快件的时间。

由于受重量和体积限制，送货员可中途返回取货。

可不考虑中午休息时间。

二·问题分析 在路线中，每个目的地看作图中的一个节点，各目的地之间的路看作图中连通节点的边，各条路的长度或行驶时间看作对应边上的权所给的线路网就转化为加权网络图，而所求问题就转化为在给定的加权网络图中寻找从给定点O 出发行遍所有顶点至少一次再回到O 点，使得总权即时间最短。

对于第一道题前三十个货到达的目的地的节点看作点集V,连接任意两点的路线所需时间作为权值赋给对应边，形成边集E 得到加权图G(V,E)（因为32和38两地点通过35的路线比其他路都短所以可以两点直接连起而权值为323835→→的权值和）。

我们可以采用最小生成树法算出0点到 任意一点的最短距离，然后根据最短路线逐次加边加权得到从0点出发回到0点的最短路线。

问题二我们将22个节点按时间限制划分为四个阶段，分别为：9:00、9:30、10：15、12:00 ，然后按照“时间要求越早，先送到”的原则。

分析各时间段所需到达的节点，在各区域得出最短路径。

依据各分区域“路径均较短，则总路径较短”的原则（注：引自高教版《运筹学》动态规划最优化原理），最短距离用最小生成树法计算。

最后得出总距离最短的具体路径
问题三;我们将50个节点按路程近似三等分将区域分为3个区域，在对每个区域运用最小生成树法进行求解。

三·问题假设
第一问；1.假设重复的送货地点仍按一件货物的停留时间算，所以不用考虑主要与次要因素问题。

2.经过某一点停留时，才可以加权，否则不能加权。

3. 假设送货员非常熟悉地理位置，送货中途不间断，不考虑中午休息时间。

同时也不考虑装货时间。

4.假设用平均速度代表他的行驶速度。

5。

针对第二问；定义；两点间最短距离。

就是在连通的所有路上选最短的路程。

如0-13两地的最短距离即为0-18-13的距离和
6.针对第三问；（1）以上可大胆假设送货员中途返回两次，即三次送完。

(2)又因为每次送货都不超过50公斤，且货物总重148公斤，总体积为2.98立方米，所以三次送货每次携带的货物总重和总体积必须尽量均衡。

（3）可假设有三个送货员同时送货，结果只需把这三个的总时间加起来即可。

四·模型的符号说明
m表示货物的重量
v表示货物的体积
t表示到达两个地点的时间
T表示总的时间
五·模型的建立与求解
问题一若将1—30号货物送到指定地点并返回设计最短时间路线方式
经计算得前30号货物的重量是M=49.5公斤< 50公斤
V0.9立方米< 1立方米
体积为
所以送货员可以一次送完，而不用考虑是否返回取货。

本题是图上点的行遍性问题。

只取30个点得到路线图如下所示
图（1）（前30号货物的目的地除35号地点外）
本题可用最小生成树法求的最小生成树，然后再用模型的改进方案进行初选路线图，最小生成树图如下所示（程序见附录）：
图（1.2）最小生成树图
但由于有些连通路线未考虑在内从而走了很多重复路线，所以很可能有比这更短的路径，现在对其改进如下：
（1）最小生成树法的改进模型
对图1的区域采用最小生成树法求出最佳送货路线，但由于其不是完全图所以不一定是最佳解，所以对该算法得到的解需要进一步修正。

在原来算法的基础上改进如下：
当两点之间没有直线连接时，应改进为使其两点的距离最短（两点之间可以经过若干个点）.
遇到两点之间不直接连接，如果由这两点组成的最短路径与后面有重复，必须把后面的路径中重复的部分删除。

通过上述修正，可以运用改进的最小生成树算法得到一个不是完全图的最优解H
设送货路线为总长为i D ，则我们要达到目标可以表示为min
i i i
x d
⨯∑=30
1
，i x 为0或者1，即符合0~1规划模型。

这是一个目标规划模型，下面考虑求解模型的方法：
∑==28
1
i i i d D （28为所走的28条路线的路程）
∑==28
1
i i t t （28为所走的28条路线的时间）
)321(1t T +⨯=/60
计算结果如下表所示:
路线所需时间（h）路线长度（km）
O-18-13-19-24-31-27-39-27-31-
3.326 5
4.619
34-40-45-42-49-42-43-38-36-38
-35-32-23-16-14-17-21-26-O.
路线图（1.3）
针对问题二。

我们将22个节点按时间限制划分为四个阶段，分别为：9:00、9:30、10：
15、12:00 ，然后按照“时间要求越早，先送到”的原则。

分析各时间段所需到达的节点，
在各区域得出最短路径。

依据各分区域“路径均较短，则总路径较短”的原则。

各个阶段用
最小生成树法求出最短路径。

第一阶段（9:00以前必须完成）的目的地有
（13,18,39,27,24）五个，从O点出发。

一共六个点.算出每两点之间的最短距离.(如0-13两
地的最短距离即为0-18-13的距离和.)
由最小生成树得到的路线o-18-13-18-31-24-31-27-39;
实际上通过计算有13-18-31-24的路程6997m大于13-19-24的路程5715m。

经过改进得到最优路线为；O-18-13-19-24-27-39
最短路程为15558 m
花费的时间为(38.895+15)=53.895<60分钟。

故第一阶段能按时完成。

同理第二阶段（9:30以前必须完成）的目的地有（31,45,34,40）四个。

最优路线为；39-31-34-40-45
最短路程为10049 m
花费的时间为(25.1225+12)=37.1225
到达地点45的时间为9:29.按时到达。

第三阶段（10:15以前必须完成）的目的地有（43,42,49,38）四个。

最优路线为；45-42-49-42-43-38
最短路程为8056m 花费的时间为32.14min
到达最后目的地的时间是10；03<10;15
第四阶段（12:00以前必须完成）的目的地有（32,23,16,36,26,21,14,17）八个。

最优路线为；38-36-38-35-32-23-16-14-17-21-26
最短路程为19220(m )
花费的时间为(48.05+24)=72.05(min)
到达的时间为11；16
、故行走路线为；
O-18-13-19-24-27-39-31-34-40-45-42-49-42-43-38-36-38-35-32-23-16-14-17-21-26
其路程为53226.59m 花费时间为3.27h
针对第三问；用最小生成树法可得如下图所示的结果
物体的总重量为148kg <150kg 总体积为 2.98 m3 < 3m3
所以我们假设三次送完。

将其分为三部分。

再对其分组：按实际工作的经验以及以上生成树图有以下准则：
准则一：尽量使同一干支及其分支上的点分在同一组；
准则二：应将相邻的干支上的点分成一组；
准则三：尽量将长的干枝与短的干支分在同一组。

由以上分组原则，我们找到两组分组形式
分组一：（1,2）（3,4）（5,6）
分组二：（6,1）（2,3）（4,5）
显然第二种分组不可能为最优解，首先从路线上将其排除，从而得到一种近似最优解，路线如图3.3
分组路线货物
总重kg
/
货物
总体积
3
/m
路线
总长度
km
/
总长
度km
/
总时
间h/
1, 2
0-26-31-34-40-47
-40-37-41-44-48-46-33
-28-30-22-
20-22-29-25-19-2
4-31-26-0
49.5
2
0.8360 44.557
122.40
7
行走
时间
5.1
+
交货
时间
2.5 =
7.6
3，4
0-26-31-27-39-27
-31-18-13-11-12-15-5-
2-4-3-8-1-6-1-7-10-9-1
4-21-0
48.7
8
0.9890 44.385
5, 6
0-2-17-23-16-23-
32-35-38-43-42-49-50-
45-36-21-0 49.7
0.9750 33.465
对于上述结果，分三个路线三次送货把整个图划分为三个区域比较均横非常符合模型
假设；
且由每个路线货物的总重与货物总体积与所给总货物和总体积的限制范围的相对误差
为：
006.050/)70.4950(0244.050/)78.4850(0096
.050/)52.4950(321=-==-==-=εεε
025
.01/)9750.01(011.01/)9890.01(1640
.01/)8360.01(321=-==-==-=ξξξ
因为总货物的总重量与所限制的总重量的相对误差很小，总体积与所限制的总体积的相对误差也很小，所以三中路线比较均横，检验可通过。

所以上述方案可为最优解，我们假设顺利通。

七 模型的评价与推广
模型的优点;(1) 运用上述最小生成树法可得到一个图表，可以一目了然的的确定大概路线。

而在实际生活中，即需要这样的粗略路径来达到实际的目的。

(2) 使用了准确的算法和适当的假设，使模型的准确性和实用性到达统一. (3)对最小生成树法进行了改进.使模型更接近最优化.
模型的缺点;(1)由于数据较多，没法使用工具进行模型的验证，只能一步一步的精化模型.
(2)本题采用最小生成树法，得出基本的路线图，得出具体情况 确实费了一番功夫，运算量相对也较大。

(3)所求的最佳送货路线是近似最优解，而类似的近似最优解可以不止一个，未能在理论上证明本问题最优解得情况
模型的推广；可充分使用到最短路的一系列问题的求解中。

对运输公司实现最优化和节约能源具有现实的意义。

同时也可运用到旅游方面。

八 参考文献 （1）《运筹学》 刘桂真等 高等教育出版社 （2）《数学模型》 姜启源 谢金星 高等教育出版社 附录；
MATLAB 求距离的程序 ShapeX = [9185 1445 7270 3735 2620 10080 10025 7160 13845 11935 7850 6585 7630
13405
2125
15365 14165
8825
5855
780
12770
2200
14765
7790
4435
10860 10385
565
2580
1565
9395
14835
1250
7280
15305 12390
6410
13915
9510
8345
4930
13265 14180
3030
10915
2330
7735
885
11575
8010
];
ShapeY = [500 560
570
670
995
1435
2525 2680 3050 3545 4185 5200 5325 5975 7045 7385 8075 8165 8355 8560 8835 9055 9330 9525 9635 10500 9765 9865 9955 10100 10365 10900 11065 11375 11415 11510 11610 12050 12300 13650 14145 14215 15060 14235 14500 14550 14880 15160 15325
N=length(ShapeX);
for i=1:N
for j=1:N
Distance(i,j)=sqrt((ShapeX(i)-ShapeX(j))^2+(ShapeY(i)-ShapeY(j))^2); end
end
Distance
A=zeros(N);
Max_Value=zeros(N);
for k=1:N
[max_line,column]=max(Distance(k,:));
A(k,column)=max_line;
end
Max_Value(k,column)=max(max(A))
[I,J]=find(Max_Value)
point_start=[ShapeX(I) ShapeY(I)]
point_end=[ShapeX(J) ShapeY(J)]
问题1最小生成树法
#include <stdio.h>
#include "graph.h"
#define INF 32767 //INF表示∞
#define MAXE 100 //最多边数
typedef struct
{ int u; //边的起始顶点
int v; //边的终止顶点
int w; //边的权值
} Edge;
void DispMat(MGraph g)
//输出邻接矩阵g
{
int i,j;
for (i=0;i<g.vexnum;i++)
{
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]==INF)
printf("%3s","∞");
else
printf("%3d",g.edges[i][j]);
printf("\n");
}
}
void SortEdge(MGraph g,Edge E[]) //从邻接矩阵产生权值递增的边集
{
int i,j,k=0;
Edge temp;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]<INF)
{
E[k].u=i;
E[k].v=j;
E[k].w=g.edges[i][j];
k++;
}
for (i=1;i<k;i++) //按权值递增有序进行直接插入排序
{
temp=E[i];
j=i-1; //从右向左在有序区E[0..i-1]中找E[i]的插入位置
while (j>=0 && temp.w<E[j].w)
{
E[j+1]=E[j]; //将权值大于E[i].w的记录后移
j--;
}
E[j+1]=temp; //在j+1处插入E[i]
}
}
void Kruskal(Edge E[],int n,int e)
{
int i,j,m1,m2,sn1,sn2,k;
int vset[MAXE];
for (i=0;i<n;i++) vset[i]=i; //初始化辅助数组
k=1; //k表示当前构造最小生成树的第几条边,初值为1
j=0; //E中边的下标,初值为0
while (k<n) //生成的边数小于n时循环
{
m1=E[j].u;m2=E[j].v; //取一条边的头尾顶点
sn1=vset[m1];sn2=vset[m2]; //分别得到两个顶点所属的集合编号
if (sn1!=sn2) //两顶点属于不同的集合,该边是最小生成树的一条边
{
printf(" (%d,%d):%d\n",m1,m2,E[j].w);
k++; //生成边数增1
for (i=0;i<n;i++) //两个集合统一编号
if (vset[i]==sn2) //集合编号为sn2的改为sn1
vset[i]=sn1;
}
j++; //扫描下一条边}
}
void main()
{
int i,j,u=3;
MGraph g;
Edge E[MAXE];
int A[MAXV][50];
g.vexnum=22;g.arcnum=25;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
A[i][j]=INF;
A[0][1]=1296;A[0][2]=2182;A[0][3]=1392;
A[1][6]=1823;
A[2][10]=2103;A[2][4]=3113;A[2][5]=5342;
A[3][10]=1537;
A[5][6]=2195;A[5][7]=2607;
A[6][8]=1771;
A[7][8]=2097;
A[8][9]=1311;
A[10][11]=1780;A[10][12]=1067;A[10][20]=2324;
A[12][13]=2203;A[12][18]=1779;
A[13][14]=1537; A[13][17]=3182;
A[14][15]=2618;
A[15][16]=917;
A[16][17]=2351;A[16][21]=1971;
A[17][19]=3217;
A[19][20]=1630;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
A[j][i]=A[i][j];
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
g.edges[i][j]=A[i][j];
SortEdge(g,E);
printf("\n");
printf("图G的邻接矩阵:\n");
DispMat(g);
printf("\n");
printf("克鲁斯卡尔算法求解结果:\n");
Kruskal(E,g.vexnum,g.arcnum);
printf("\n");
}
#include <stdio.h>
#include "graph.h"
#define INF 32767 //INF表示∞
#define MAXE 100 //最多边数
typedef struct
{ int u; //边的起始顶点
int v; //边的终止顶点
int w; //边的权值
} Edge;
void DispMat(MGraph g)
//输出邻接矩阵g
{
int i,j;
for (i=0;i<g.vexnum;i++)
{
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]==INF)
printf("%3s","∞");
else
printf("%3d",g.edges[i][j]);
printf("\n");
}
}
void SortEdge(MGraph g,Edge E[]) //从邻接矩阵产生权值递增的边集{
int i,j,k=0;
Edge temp;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]<INF)
{
E[k].u=i;
E[k].v=j;
E[k].w=g.edges[i][j];
k++;
}
for (i=1;i<k;i++) //按权值递增有序进行直接插入排序
{
temp=E[i];
j=i-1; //从右向左在有序区E[0..i-1]中找E[i]的插入位置
while (j>=0 && temp.w<E[j].w)
{
E[j+1]=E[j]; //将权值大于E[i].w的记录后移
j--;
}
E[j+1]=temp; //在j+1处插入E[i]
}
}
void Kruskal(Edge E[],int n,int e)
{
int i,j,m1,m2,sn1,sn2,k;
int vset[MAXE];
for (i=0;i<n;i++) vset[i]=i; //初始化辅助数组
k=1; //k表示当前构造最小生成树的第几条边,初值为1
j=0; //E中边的下标,初值为0
while (k<n) //生成的边数小于n时循环
{
m1=E[j].u;m2=E[j].v; //取一条边的头尾顶点
sn1=vset[m1];sn2=vset[m2]; //分别得到两个顶点所属的集合编号
if (sn1!=sn2) //两顶点属于不同的集合,该边是最小生成树的一条边
{
printf(" (%d,%d):%d\n",m1,m2,E[j].w);
k++; //生成边数增1
for (i=0;i<n;i++) //两个集合统一编号
if (vset[i]==sn2) //集合编号为sn2的改为sn1
vset[i]=sn1;
}
j++; //扫描下一条边
}
}
克鲁斯卡尔算法求解结果:
(15,16):917
(10,12):1067
(0,1):1296
(8,9):1311
(0,3):1392
(3,10):1537
(13,14):1537
(19,20):1630
(6,8):1771
(12,18):1779
(10,11):1780
(1,6):1823
(16,21):1971
(7,8):2097
(2,10):2103
(5,6):2195
(12,13):2203
(10,20):2324
(16,17):2351
(14,15):2618
(2,4):3113
问题二的程序及答案
克鲁斯卡尔算法求解结果:
(4,5):1780
(0,2):2102
(3,4):2848
(1,2):3113
(2,3):3984
Press any key to continue
问题三的程序及答案
//文件名:exp8-7.cpp
#include <stdio.h>
#include "graph.h"
#define INF 32767 //INF表示∞
#define MAXE 100 //最多边数typedef struct
{ int u; //边的起始顶点int v; //边的终止顶点
int w; //边的权值
} Edge;
void DispMat(MGraph g)
//输出邻接矩阵g
{
int i,j;
for (i=0;i<g.vexnum;i++)
{
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]==INF)
printf("%3s","∞");
else
printf("%3d",g.edges[i][j]);
printf("\n");
}
}
void SortEdge(MGraph g,Edge E[]) //从邻接矩阵产生权值递增的边集
{
int i,j,k=0;
Edge temp;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
if (g.edges[i][j]<INF)
{
E[k].u=i;
E[k].v=j;
E[k].w=g.edges[i][j];
k++;
}
for (i=1;i<k;i++) //按权值递增有序进行直接插入排序
{
temp=E[i];
j=i-1; //从右向左在有序区E[0..i-1]中找E[i]的插入位置
while (j>=0 && temp.w<E[j].w)
{
E[j+1]=E[j]; //将权值大于E[i].w的记录后移
j--;
}
E[j+1]=temp; //在j+1处插入E[i]
}
}
void Kruskal(Edge E[],int n,int e)
{
int i,j,m1,m2,sn1,sn2,k;
int vset[MAXE];
for (i=0;i<n;i++) vset[i]=i; //初始化辅助数组
k=1; //k表示当前构造最小生成树的第几条边,初值为1
j=0; //E中边的下标,初值为0
while (k<n) //生成的边数小于n时循环
{
m1=E[j].u;m2=E[j].v; //取一条边的头尾顶点
sn1=vset[m1];sn2=vset[m2]; //分别得到两个顶点所属的集合编号
if (sn1!=sn2) //两顶点属于不同的集合,该边是最小生成树的一条边
{
printf(" (%d,%d):%d\n",m1,m2,E[j].w);
k++; //生成边数增1
for (i=0;i<n;i++) //两个集合统一编号
if (vset[i]==sn2) //集合编号为sn2的改为sn1
vset[i]=sn1;
}
j++; //扫描下一条边}
}
void main()
{
int i,j,u=3;
MGraph g;
Edge E[MAXE];
int A[MAXV][51];
g.vexnum=51;g.arcnum=51;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
A[i][j]=INF;
A[0][21]=1797;A[0][26]=1392;A[0][18]=2102;
A[1][6]=1294;A[1][7]=1968;A[1][8]=2864;A[1][3]=1916;
A[2][4]=2293;A[2][5]=1253;A[2][20]=7823;
A[3][4]=3536;A[3][8]=1958;
A[5][15]=5005;
A[7][10]=2059;A[7][18]=5918;
A[8][12]=1757;
A[9][10]=1946;A[9][14]=2681;
A[10][18]=5910;
A[11][12]=1418;A[11][13]=1670;
A[12][13]=1457;A[12][15]=4806;A[12][25]=5757;
A[13][18]=3113;A[13][19]=3456;
A[14][18]=5342;A[13][16]=2608;A[13][17]=2196;A[13][21]=3297;
A[15][22]=2861;A[15][25]=4235;
A[16][23]=2098;
A[17][21]=1824;A[17][23]=1775;
A[18][31]=2104;
A[19][24]=2259;A[19][25]=1966;
A[20][22]=1499;
A[21][26]=2192;A[21][36]=2880;
A[22][29]=1098;A[22][30]=1287;
A[23][32]=1312;
A[24][31]=1780;
A[25][29]=1886;A[25][41]=4155;
A[26][31]=1537;
A[27][31]=1068;A[27][39]=1780;A[27][36]=2204;
A[28][30]=1018;A[28][33]=1326;
A[30][41]=4998;
A[31][34]=2325;
A[32][35]=1114;
A[33][46]=3759;
A[34][40]=1631;
A[35][38]=1410;
A[36][38]=1537;A[36][45]=3182;
A[37][40]=2090;A[37][41]=2602;
A[38][43]=2618;
A[40][45]=3217;A[40][47]=2331;A[40][50]=3043;
A[41][44]=2366;A[41][46]=2736;
A[42][43]=918;A[42][45]=2352;A[42][49]=1971;
A[44][48]=2153;A[44][50]=4987;
A[45][50]=3103;
A[46][48]=1494;
A[49][50]=3569;
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
A[j][i]=A[i][j];
for (i=0;i<g.vexnum;i++)
for (j=0;j<g.vexnum;j++)
g.edges[i][j]=A[i][j];
SortEdge(g,E);
printf("\n");
printf("图G的邻接矩阵:\n");
DispMat(g);
printf("\n");
printf("克鲁斯卡尔算法求解结果:\n");
Kruskal(E,g.vexnum,g.arcnum);
printf("\n");
}
克鲁斯卡尔算法求解结果:
(42,43):918
(28,30):1018
(27,31):1068
(22,29):1098
(32,35):1114
(2,5):1253
(22,30):1287
(1,6):1294
(23,32):1312
(26,33):1326
(28,33):1326
(0,26):1392
(35,38):1410
(11,12):1418
(12,13):1457
(46,48):1494
(20,22):1499《26,31》(36,38):1537
(34,40):1631
(8,12):1757
(17,23):1775
(24,31):1780
(27,39):1780
(0,21):1797
(17,21):1824
(25,29):1886
(1,3):1916
(9,10):1946
(3,8):1958
(19,25):1966
(1,7):1968
(42,49):1971
(7,10):2059
(37,40):2090
(16,23):2098
(0,18):2102
(18,31):2104
(44,48):2153
(13,17):2196《19,24》(2,4):2293
(31,34):2325
(40,47):2331
(42,45):2352
(41,44):2366
(37,41):2602
(38,43):2618
(9,14):2681
(15,22):2861
(40,50):3043
(3,4):3536
Press any key to continue。