运筹学最短路径实验
运筹学C语言实现Dijkstra算法求解图的最短路径
运筹学课程设计报告姓名：一、算法思想运用Dijkstra算法求解图的最短路径。
Dijkstra算法思想为：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S 表示，初始时S中只有一个源点，以后每求得一条最短路径, 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。
在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。
此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
二、算法流程或步骤Dijkstr算法具体步骤：（1）初始时，S只包含源点，即S＝，v的距离为0。
U包含除v 外的其他顶点，U中顶点u距离为边上的权（若v与u有边）或）（若u不是v的出边邻接点）。
（2）从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。
（3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u（u U）的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。
（4）重复步骤（2）和（3）直到所有顶点都包含在S中。
三、算法源程序#include <iostream.h>int m;int n;float a[100][100];float dist[100];int prev[100];float MAX_V ALUE=10000;void dijkstra(){if(m<0||m>n) //当无顶点的情况return;bool *s=new bool[n+1];for(int i=0;i<n;i++){dist[i]=a[0][i]; //与源点相连的权值s[i]=false;if(dist[i]==MAX_V ALUE) //与源点无连接的顶点prev[i]=0; //设置对应权值为elseprev[i]=m; //与源点相连接的顶点设置为m }dist[m]=0;s[m]=true;for(int i1=0;i1<n;i1++){float temp=MAX_V ALUE;int u=m;for(int j=0;j<n;j++)if((!s[j])&&(dist[j]<temp))//与源点相连的顶点{u=j;temp=dist[j]; //设置temp成为与源点相连的顶点权值}s[u]=true;for(int j1=0;j1<n;j1++)if((!s[j1])&&(a[u][j1]<MAX_V ALUE)){float newdist=dist[u]+a[u][j1]; //算出与源点不直接相连的权值和if(newdist<dist[j1]){dist[j1]=newdist;prev[j1]=u;}}}}void path(){for(int i=0;i<n;i++)if(i!=m&&dist[i]<MAX_V ALUE){cout<<"由源到顶点"<<i<<"的最短路径为：(终点位置) "<<i;int temp=i;do{temp=prev[temp];cout<<" <-- "<<temp;}while(temp!=m);cout<<" (源位置)。
最短路径的实验报告
最短路径的实验报告最短路径的实验报告引言：最短路径问题是图论中一个经典的问题，涉及到在一个带有权重的图中找到两个顶点之间的最短路径。
本实验旨在通过实际操作和算法分析，深入探讨最短路径算法的性能和应用。
实验设计：本次实验使用了Dijkstra算法和Floyd-Warshall算法来解决最短路径问题。
首先，我们使用Python编程语言实现了这两个算法，并对它们进行了性能测试。
然后，我们选择了几个不同规模的图进行实验，以比较这两种算法的时间复杂度和空间复杂度。
最后，我们还在实际应用中使用了最短路径算法，以验证其实用性。
实验过程：1. 实现Dijkstra算法Dijkstra算法是一种贪心算法，用于求解单源最短路径问题。
我们首先实现了该算法，并对其进行了性能测试。
在测试中，我们使用了一个包含1000个顶点和5000条边的图，记录了算法的运行时间。
结果显示，Dijkstra算法的时间复杂度为O(V^2)，其中V表示图中的顶点数。
2. 实现Floyd-Warshall算法Floyd-Warshall算法是一种动态规划算法，用于求解所有顶点对之间的最短路径。
我们在Python中实现了该算法，并对其进行了性能测试。
在测试中，我们使用了一个包含100个顶点和5000条边的图，记录了算法的运行时间。
结果显示，Floyd-Warshall算法的时间复杂度为O(V^3)，其中V表示图中的顶点数。
3. 比较两种算法通过对Dijkstra算法和Floyd-Warshall算法的性能测试，我们可以看到，Dijkstra算法在处理较大规模的图时性能更好，而Floyd-Warshall算法在处理较小规模的图时性能更好。
因此，在实际应用中，我们可以根据图的规模选择合适的算法。
4. 应用实例为了验证最短路径算法的实际应用性，我们选择了一个城市交通网络图进行实验。
我们使用了Dijkstra算法来计算两个城市之间的最短路径，并将结果与实际的驾车时间进行比较。
最短路径实验报告
最短路径实验报告最短路径实验报告引言：最短路径算法是计算机科学中的一个经典问题，它在许多领域中都有广泛的应用，如交通规划、电路设计、网络通信等。
本实验旨在通过实践探索最短路径算法的实际应用，并对其性能进行评估。
一、问题描述：我们将研究一个城市的交通网络，其中包含多个节点和连接这些节点的道路。
每条道路都有一个权重，表示通过该道路所需的时间或距离。
我们的目标是找到两个节点之间的最短路径，即使得路径上各个道路权重之和最小的路径。
二、算法选择：为了解决这个问题，我们选择了Dijkstra算法和Floyd-Warshall算法作为比较对象。
Dijkstra算法是一种单源最短路径算法，它通过不断选择当前最短路径的节点来逐步扩展最短路径树。
Floyd-Warshall算法则是一种多源最短路径算法，它通过动态规划的方式计算任意两个节点之间的最短路径。
三、实验设计：我们首先构建了一个包含10个节点和15条道路的交通网络，每条道路的权重随机生成。
然后，我们分别使用Dijkstra算法和Floyd-Warshall算法计算两个节点之间的最短路径，并记录计算时间。
四、实验结果：经过实验，我们发现Dijkstra算法在计算单源最短路径时表现出色，但是在计算多源最短路径时效率较低。
而Floyd-Warshall算法在计算多源最短路径时表现出色，但是对于大型网络的单源最短路径计算则需要较长的时间。
五、性能评估：为了评估算法的性能，我们对不同规模的交通网络进行了测试，并记录了算法的计算时间。
实验结果显示，随着交通网络规模的增大，Dijkstra算法的计算时间呈指数级增长，而Floyd-Warshall算法的计算时间则呈多项式级增长。
因此，在处理大型网络时，Floyd-Warshall算法具有一定的优势。
六、实际应用：最短路径算法在实际应用中有着广泛的用途。
例如，在交通规划中，最短路径算法可以帮助我们找到最优的行车路线，减少交通拥堵。
运筹学最短路径问题实验报告
实验报告填写说明
（实验项目名称、实验项目类型必须与实验教学大纲保持一致）
1．实验环境：
实验用的硬件、软件环境。
2．实验目的：
根据实验教学大纲，写出实验的要求和目的。
3．实验原理：
简要说明本实验项目所涉及的理论知识。
4．实验步骤：
这是实验报告极其重要的容。
对于验证性验，要写清楚操作方法，需要经过哪几个步骤来实现其操作。
对于设计性和综合性实验，还应写出设计思路和设计方法。
对于创新性实验，还应注明其创新点。
5．实验结论：
根据实验过程中得到的结果，做出结论。
6．实验总结：
本次实验的收获、体会和建议。
7．指导教师评语及成绩：
指导教师依据学生的实际报告内容，给出本次实验报告的评价和成绩。
附录1：源程序。
管理运筹学 第7章 最短路实例
v1
v2
v3
v4
v5
v6
把所有弧的权数计算如下表：
1 1 2 3 4 5 6 2 16 3 22 16 4 30 22 17 5 41 30 23 17 6 59 41 31 23 18
管
理
运
筹
学
2
§2 最短路问题
(继上页) 把权数赋到图中，再用Dijkstra算法求最短路。
59 22 v1 16 v2 30 41 v4 23 41 23 17 v5 31
管 理 运 筹 学
11
§4 最大流问题
二、最大流问题网络图论的解法 对网络上弧的容量的表示作改进。为省去弧的方向，如下图: (a)和 (b)、(c)和(d)的意义相同。 cij cij 0 vi vi vj vj （ a） （ b） cij cij cji v j vi vi vj （cji） （ d） （c） 用以上方法对例6的图的容量标号作改进，得下图
个网络能联通7个学院办公室，并使总的线路长度为最短。
v2 3 1 4 v7 3 v6 5 2 8 v5 v3
7
v4
图11-14
v1 10
3
4
解：此问题实际上是求图11-14的最小生成树，这在例4中已经求得， 也即按照图11-13的(f)设计，可使此网络的总的线路长度为最短，为19 百米。 “管理运筹学软件”有专门的子程序可以解决最小生成树问题。
年份
年初价格
1
11
2
11
3
12
4
12
5
13
设备维修费如下表 使用年数 每年维修 费用 0-1 5 1-2 6 2-3 8 3-4 11 4-5 18
管
最短路问题的实际应用论文
金华双龙洞旅游路线中最短路问题摘要：金华双龙洞景点分布较多，通过对其旅游路线的设置，转化为图论内容中的最短路情景进行讨论，建立模型，并通过搜索资料，利用几种方法解决路线最小的问题。
关键字：数学建模最短路问题 lingo Dijkstra法 flod算法一、研究背景：在旅游过程中，我们常常感觉到自己一天下来走了很多路，回到宾馆脚痛的不行。
但其实我们可以利用运筹学的知识，通过建立数学模型，转化为图论的内容。
从而较为合理的制定出选择的路线（即最短路问题）。
因而这次的小论文，我主要探究一下几个问题：1.从景点进口到出口的最短路程。
（最短路问题）2.从景点到出口的最长路线。
3.建立的模型是否满足能回到起点（古典图论问题）二、研究内容：根据从互联网中搜索的资料，金华双龙洞的主要景点：景区进口双龙洞，冰壶洞，朝真洞，桃源洞，黄大仙祖宫五个，其余为小景点（若要加入，同样可以按照以下问题的研究方法进行讨论）现在忽略。
问题总假设：分别设置双龙洞，冰壶洞，朝真洞，桃源洞，黄大仙祖宫五个景点为A,B,C,D,E五点，根据现实及假设，可以得到如图所示的路线图：再利用用Dijkstra算法求解无负权网络的最短路。
同时也可以利用此法算出最长路程。
问题一的解决：以A为景点出口，E为出口。
故A点标号为P（a）=0 给其余所有的T标号T（i）=+∞考虑与A相邻的两个顶点BC，两个顶点为T标号，故修改这两个点的标号为：T(b)=min[T(b),P(a)+l12]=min[+∞,0+3]=3T(c)=min[T(c),P(a)+l13]=min[+∞,0+2]=2比较所有T标号，T(c)最小，所以令P(c)=2再考察（C,B）(C,D)(C,E)的端点：同理可得T(b)=6 T(d)=6.8 T(e)=10.2(显然已经到终点但还需要看看其余路线长短)故又令P（b）=6.综合分析只有一条线路即A→C→B→D→E 此时总路程为2+4+3+8.4=16.4>10.2所以，最短路程为A→C→E。
最短路径实验报告
云南财经大学信息学院学生综合性与设计性实验报告（2013—2014 学年第 2 学期）一、实验内容与目的1.内容查看“最短路径.swf”，选择熟悉的程序设计语言定义有向图，根据动画演示求取从有向图任一结点到其他结点的最短路径。
2.实验目的了解最短路径的概论，掌握求最短路径的方法。
二、实验原理或技术路线（可使用流程图描述）实验原理：(李燕妮负责设计，周丽琼负责编程)图是由结点的有穷集合V和边的集合E组成，求最短路径用迪杰斯特拉算法：1)适用条件&范围：a) 单源最短路径(从源点s到其它所有顶点v);b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图)c) 所有边权非负(任取(i,j)∈E都有Wij≥0);2)算法描述：a)初始化：dis[v]=maxint(v∈V,v≠s); dis[s]=0; pre[s]=s; S={s};b)For i:=1 to n1.取V-S中的一顶点u使得dis[u]=min{dis[v]|v∈V-S}2.S=S+{u}3.For V-S中每个顶点v do Relax(u,v,Wu,v)c)算法结束：dis[i]为s到i的最短距离；pre[i]为i的前驱节点三、实验环境条件（使用的软件环境）Microsoft Visual C++6.0四、实验方法、步骤（列出程序代码或操作过程）/*本程序的功能是求图中任意两点间的最短路径*/#include<stdio.h>#include<stdlib.h>#include<conio.h>#include<string.h>#define ING 9999typedef struct ArcCell{int adj;/*顶点关系类型，用1表示相邻，0表示不相邻*/}ArcCell,**AdjMatrix;/*邻接矩阵*/typedef struct type{char data[3];/*顶点值*/}VertexType;typedef struct{VertexType *vexs; /*顶点向量*/AdjMatrix arcs; /*邻接矩阵*/int vexnum,arcnum; /*图的顶点数和边数*/}MGraph;/*初始图*/void InitGraph(MGraph *G){int i,nu,mu;printf("\n输入顶点的个数和（边）弧的个数：");scanf("%d %d",&nu,&mu);G->arcs=(ArcCell **)malloc(nu*sizeof(ArcCell *));for(i=0;i<nu;i++)/*分配邻接矩阵空间*/G->arcs[i]=(ArcCell *)malloc(nu*sizeof(ArcCell));G->vexs=(VertexType *)malloc(nu*sizeof(VertexType)); /*分配顶点空间*/ G->vexnum=nu;G->arcnum=mu; /*图的顶点数和边数*/}void InsertGraph(MGraph *G,int i,VertexType e){if(i<0||i>G->vexnum) return;strcpy(G->vexs[i].data,e.data);}/*确定v1在图顶点中的位置*/int Locate(MGraph G,VertexType v1){int i;for(i=0;i<G.vexnum;i++)if(strcmp(v1.data,G.vexs[i].data)==0) return i;return -1;}/*采用数组（邻接矩阵）和邻接表表示无向图*/void CreateUND(MGraph *G){int i,j,k,*p,w;VertexType v1,v2;p=(int *)malloc(G->vexnum*sizeof(int));for(i=0;i<10;i++) p[i]=0;for(i=0;i<G->vexnum;++i) /*初始邻接表*/{for(j=0;j<G->vexnum;++j)G->arcs[i][j].adj=ING;}for(k=0;k<G->arcnum;++k){printf("\n输入第%d 条（边）弧相对的两个顶点值:\n",k+1);scanf("%s %s",v1.data,v2.data);/*输入相邻的两个点值*/printf("输入它们的权值: ");scanf("%d",&w);i=Locate(*G,v1);j=Locate(*G,v2); /*用i 和j来确定它们的位置*/G->arcs[i][j].adj=w;}}/*输出邻接矩阵*/void Pint(MGraph G){int i,j;for(i=0;i<G.vexnum;i++){for(j=0;j<G.vexnum;j++){if(G.arcs[i][j].adj!=ING)printf("\t%d",G.arcs[i][j].adj);else{if(i==j)printf("\t0");else printf("\t∞");}}printf("\n");}}/*对顶点V0到其余顶点v的最短路径p[v]及其带权长度D[v]若p[v][w]为1，则w是从V0到W当前求得最短路径上的顶点, final[v]为1，当且仅当v属于S，即已经求得从v0到v的最短路*/void ShortestPath(MGraph G,int v0,int **p,int *D){int v,u,i,w,min;int *final;final=(int *)malloc(G.vexnum*sizeof(int));/*分配空间*/for(v=0;v<G.vexnum;++v){final[v]=0;D[v]=G.arcs[v0][v].adj;/*初始化*/for(w=0;w<G.vexnum;++w) p[v][w]=0;/*设空路径*/if(D[v]<ING){p[v][v0]=1;p[v][v]=1;}/*v到v0有路径*/}D[v0]=0;final[v0]=1;/*初始化，V0顶点属于S集*/for(i=1;i<G.vexnum;i++){/*其余G.vexnum-1个顶点*/min=ING;for(w=0;w<G.vexnum;++w) /*求出矩阵这一行的最小值*/ if(!final[w]) /*W顶点属于V-S中*/if(D[w]<min){v=w;min=D[w];}final[v]=1;/*离V0顶点最近的V加入S集*/for(w=0;w<G.vexnum;++w) /*更新当前最短路径及距离*/ if(!final[w]&&(min+G.arcs[v][w].adj<D[w])){ /*不是最小的，修改D[w],P[w]*/D[w]=min+G.arcs[v][w].adj;for(u=0;u<G.vexnum;u++)p[w][u]=p[v][u];p[w][w]=1;}}free(final);}void main(){MGraph G;VertexType e;int i,j;int **p;int *D;InitGraph(&G);p=(int **)malloc(G.vexnum*sizeof(int *));for(i=0;i<G.vexnum;i++)p[i]=(int *)malloc(G.vexnum*sizeof(int));D=(int *)malloc(G.vexnum*sizeof(int));printf("顶点值：\n");for(i=0;i<G.vexnum;++i)/*给图顶点向量付值*/{scanf("%s",e.data);InsertGraph(&G,i,e);}CreateUND(&G);/*构造图结构*/printf("邻接矩阵为：\n");Pint(G);for(i=0;i<G.vexnum;i++) /*输出邻接矩阵*/{ShortestPath(G,i,p,D); /*调用最短函数*/for(j=0;j<G.vexnum;j++)if(i!=j) printf(" %s 到%s 的最短路径为%d \n",G.vexs[i].data,G.vexs[j].data,D[j]);printf("\n\n");}getch();}五、实验过程原始记录( 测试数据、图表)请给出各个操作步骤的截图和说明，要求有对时间复杂度和空间复杂度的说明。
最短路径问题的求解PPT精选文档
.
3
最短路径问题的求解
三、等代价搜索法 等代价搜索法也是在宽度优先搜索的基础上进行了部分优化的一种算法，它与
启发式搜索的相似之处都是每次只展开某一个结点（不是展开所有结点），不同之 处在于：它不需要去另找专门的估价函数，而是以该结点到A点的距离作为估价值， 也就是说，等代价搜索法是启发式搜索的一种简化版本。它的大体思路是：
.
2
最短路径问题的求解
二、 启发式搜索 在宽度优先搜索算法的基础上，每次并不是把所有可展开的结点展开，
而是对所有没有展开的结点，利用一个自己确定的估价函数对所有没展开 的结点进行估价，从而找出最应该被展开的结点（也就是说我们要找的答 案最有可能是从该结点展开），而把该结点展开，直到找到目标结点为止。
.
12
最短路径问题的求解
八、Dijkstra算法（从一个顶点到其余各顶点的最短路径，单源最短路径） 例3、如下图，假设C1,C2,C3,C4,C5,C6是六座城市，他们之间的连线表示两 城市间有道路相通，连线旁的数字表示路程。请编写一程序，找出C1到Ci 的最短路径(2≤i≤6)，输出路径序列及最短路径的路程长度。
3、由数轴可见，A与A'点相比，A点离原点近，因而保留A点，删除A'点，相应的，B、B'点保留B点， D、D'保留D'，E、E'保留E'，得到下图：
.
11
最短路径问题的求解
4、此时再以离原点最近的未展开的点B联接的所有点，处理后，再展开离原点最近未展开的D点， 处理后得到如下图的最终结果：
matlab最短路径运筹课程设计
matlab最短路径运筹课程设计一、课程目标知识目标：1. 理解运筹学中图论的基本概念，掌握最短路径问题的定义及其在实际问题中的应用。
2. 掌握MATLAB软件的基本操作，学会使用MATLAB解决最短路径问题。
3. 学习并理解不同最短路径算法（如Dijkstra算法、Floyd算法等）的原理及其适用场景。
技能目标：1. 能够运用MATLAB软件构建图的模型，并实现最短路径算法。
2. 能够分析实际问题的需求，选择合适的算法解决最短路径问题。
3. 培养学生的编程能力，提高解决问题的实践操作技能。
情感态度价值观目标：1. 培养学生对运筹学及MATLAB编程的兴趣，激发学生主动探索和创新的热情。
2. 培养学生团队协作精神，学会与他人共同分析问题、解决问题。
3. 培养学生运用所学知识解决实际问题的成就感，增强自信心。
分析课程性质、学生特点和教学要求，本课程将目标分解为以下具体学习成果：1. 学生能够自主阅读教材，理解和掌握最短路径相关概念。
2. 学生能够在MATLAB环境下编写程序，实现至少两种最短路径算法。
3. 学生能够运用所学知识，解决实际问题，并撰写课程报告。
4. 学生通过课程学习，培养团队协作、创新思维和实际操作能力。
二、教学内容本课程教学内容紧密结合课程目标，确保科学性和系统性。
教学内容主要包括以下几部分：1. 图论基础知识：图的定义、顶点、边、路径、邻接矩阵等基本概念，并介绍最短路径问题的定义及分类。
2. MATLAB软件操作：MATLAB基本命令、数据类型、矩阵运算、函数编写及调试等操作。
3. 最短路径算法：- Dijkstra算法：单源最短路径算法，解决无负权边的图的最短路径问题。
- Floyd算法：多源最短路径算法，解决带有负权边的图的最短路径问题。
4. 教学案例：结合实际案例，运用所学算法解决具体问题。
教学大纲安排如下：第一周：图论基础知识，教材相关章节：第二章 图的基本概念。
第二周：MATLAB软件操作，教材相关章节：第一章 MATLAB基础。
最短路径实验指导书
实验八最短路径实验一、实验目的通过最短路径求解的实验，帮助学生熟练掌握图的顶点和边的概念，以及其存储实现；掌握图的基本运算和利用图解决实际问题的基本方法。
二、实验内容以严蔚敏《数据结构（C语言版）》教科书图7.33交通图为例，求解最短路径。
具体内容包括：1、用文本文件组织图的顶点和图的边。
2、图的存储表示：从文件中输入图的顶点和图的边，并转换为图的存储结构表示。
3、求解交通图的最短路径，并用文件保存图的最短途径数据。
4、求解从一个城市出发到其它所有城市的最短路径。
5、求解从一个城市到另一个城市的最短路径。
三、实验仪器微型计算机实验用编程语言：Turbo C 2.0，Borland C 3.0等以上版本四、实验原理图是顶点的集合和边的集合。
边定义了顶点之间的关系。
1、图的存储表示（1）图的顶点的表示在交通图中，图的一个顶点表示一个城市的名字。
城市的名字用一个字符串表示。
因此，图的顶点集用一个二维字符数组表示，也可以说以字符串为单位的一维数组表示。
用C语言定义为：char city[CityNum][NameLenght];图的顶点在图中的位置用顶点名（城市名）在一维顶点向两种的序号表示。
顶点在图的位置（序号）与顶点的输入顺序有关。
对于同一个图，顶点的输入顺序不同，顶点在图中的位置不同，但不影响计算结果。
（2）图的边的表示在交通图中，边表示城市之间的交通线路，在本例中假设交通线路为铁路。
边上的权值表示铁路的长度（公里数）。
考虑铁路都是双向行使，交通图用无向图来表示。
为了方便求的任给两个城市是否有铁路相连，以及铁路的长度，用邻接矩阵表示交通图中各城市之间的邻接关系。
用C语言定义为：int arc[CityNum][CityNum]（3）图的总体存储表示图的总体存储表示定义如下：#define CityNum 30 //最大城市结点数#define NameLenght 12 //城市名字长度#define Infinity 10000 //若城市间没有路径距离设定为Infinitytypedef char Vextype[NameLenght];typedef int Arctype;typedef struct{ Vextype vexs[CityNum]; // 顶点数组Arctype arcs[CityNum][CityNum]; //边矩阵，权值w ijint vexnum,arcnum; //顶点数,边数} Mgraph2、最短路径的表示最短路径值用矩阵表示，其定义如下：int dist[CityNum][CityNum]其中，dist[i][j]表示第i个城市到第j个城市的最短路径值路径顶点序列用路径矩阵表示，定义如下：int Path[CityNum][CityNum]其中，Path[i][j]表示第i个城市到第j个城市的路径上，第j个城市的前一个城市（序号）。
实验报告6-最短路径问题
HUNAN UNIVERSITY 课程实习报告题目最短路径问题学生姓名学生学号专业年级指导老师完成日期一、需求分析本实验是求最短路径的问题，从文件中读入有向网中顶点的数量和顶点间的票价的矩阵，以用户指定的起点，在文件中输出到其余各顶点的最短路径及花费。
（1）输入：输入的形式：（文件）5-1 10 3 20 -1-1 -1 -1 5 -1-1 2 -1 -1 15-1 -1 -1 -1 11-1 -1 -1 -1 -1（用户）输入起点：0输入值的范围：文件输入中，顶点数和矩阵中顶点间的票价均为整型int，用户输入中，起点数为整型int。
（2）输出的形式：（文件）源点0到顶点1的最小花费为:5路径为：0——>2——>1源点0到顶点2的最小花费为:3路径为：0——>2源点0到顶点3的最小花费为:10路径为：0——>2——>1——>3源点0到顶点4的最小花费为:18路径为：0——>2——>4（3）程序所达到的功能：在文件中给出有向网的顶点个数和顶点间的票价的矩阵，以用户指定的起点，在文件中输出起点到其余各顶点的最短路径及花费。
（4）测试数据：a.输入：（文件）5-1 10 3 20 -1-1 -1 -1 5 -1-1 2 -1 -1 15-1 -1 -1 -1 11-1 -1 -1 -1 -1（用户）输入起点：0输出：（文件）源点0到顶点1的最小花费为:5路径为：0——>2——>1源点0到顶点2的最小花费为:3路径为：0——>2源点0到顶点3的最小花费为:10路径为：0——>2——>1——>3源点0到顶点4的最小花费为:18路径为：0——>2——>4b.输入：（文件）5-1 10 3 20 -1-1 -1 -1 5 -1-1 2 -1 -1 15-1 -1 -1 -1 11-1 -1 -1 -1 -1（用户）输入起点：2输出：（文件）源点2到顶点0：没有连通路径源点2到顶点1的最小花费为:2路径为：2——>1源点2到顶点3的最小花费为:7路径为：2——>1——>3源点2到顶点4的最小花费为:15路径为：2——>4c.输入：（文件）618 10 3 20 -1 915 -1 -1 5 -1 -1-1 20 16 -1 -1 15-1 -1 30 -1 6 32 9 -1 20 -1 -1-1 8 12 -1 -1 5（用户）输入起点：5输出：（文件）源点5到顶点0的最小花费为:21路径为：5——>1——>3——>4——>0源点5到顶点1的最小花费为:8路径为：5——>1源点5到顶点2的最小花费为:12路径为：5——>2源点5到顶点3的最小花费为:13路径为：5——>1——>3源点5到顶点4的最小花费为:19路径为：5——>1——>3——>4d.输入：（文件）618 10 3 20 -1 915 -1 -1 5 -1 -1-1 20 16 -1 -1 15-1 -1 30 -1 6 32 9 -1 20 -1 -1-1 8 12 -1 -1 5（用户）输入起点：3输出：（文件）源点3到顶点0的最小花费为:8路径为：3——>4——>0源点3到顶点1的最小花费为:11路径为：3——>5——>1源点3到顶点2的最小花费为:11路径为：3——>4——>0——>2源点3到顶点4的最小花费为:6路径为：3——>4源点3到顶点5的最小花费为:3路径为：3——>5e.输入：（文件）3-1 -1 -1-1 -1 -1-1 -1 -1（用户）输入起点：1输出：（文件）源点1到顶点0：没有连通路径源点1到顶点2：没有连通路径f.输入：（文件）3-1 -1 -1-1 -1 -1-1 -1 -1（用户）输入起点：3输出：（文件）源点3到顶点0的最小花费为:-572562307路径为：3——>1——>0源点3到顶点1的最小花费为:-572662307路径为：3——>1源点3到顶点2的最小花费为:-572662307路径为：3——>2二、概要设计（1）所有抽象数据类型的定义：const int MaxNum=100000;//利用邻接矩阵存储图：class Graph{private:int *Adj;//保存邻接矩阵的一维数组j和k之间权值存储在Adj[j*Num+k]中int Num;public:Graph();~Graph();void Floyd(int start);};（2）算法的基本思想：采用邻接矩阵为图的存储结构，保存邻接矩阵的一维数组j和k之间权值存储Adj[j*Num+k]中，以用户指定的起点，进行弗洛伊德算法，先初始化最短路径，对角线元素设置为0，其他元素设置为边的权值，没有有向边设置为MaxNum，依次插入中间点k，判断是否检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，若不成立则路径不改变，若成立则更新最短路径，设置Dis(i,j) = Dis(i,k) + Dis(k,j)，直至循环结束，更新后的最短路径入栈，在文件中输出到其余各顶点的最短路径及花费。
运筹学及其应用10.2 最短路问题
3
3,1
v3
0,0
6
1
2
10
v4
1,1
v5 6,2 2
∞,1
v9
6
3
3 4
10 4
v6 2 v7 ∞,1
11,4
∞,1
v8
18
v2 5,3 1
6 2
v1
3
3,1
v3
0,0
6
1
2
10
v4
1,1
v5 6,2 2
∞,1
v9
6
3
3 4
10 4
v6 2 v7 9,5
10,5
12,5
v8
19
v2 5,3 1
9
v2 6,1 1
6 2
v1
3
3,1
v3
0,0
6
1
2
10
v4
1,1
v5 ∞,1 2
6
3
4 10
4
v6
2
v7
∞,1
∞,1
∞,1
v9
3
∞,1
v8
10
v2 6,1 1
6 2
v1
3
3,1
v3
0,0
6
1
2
10
v4
1,1
v5 ∞,1 2
6
3
4 10
4
v6
2
v7
∞,1
∞,1
∞,1
v9
3
∞,1
v8
11
v2 6,1 1
6 2
v1
3
3,1
v3
0,0
6
1
2
最短路径实验报告
D[w] = min+mgraph.arcs[v][w].adj; //更新D[w]
for(j = 0;j<mgraph.vexnum;j++)
//修改P[w]，v0到w经过的顶点包括v0到v经过的顶点再加上顶点w
{
P[w][j] = P[v][j];
}
P[w][w] = true;
}
}
}
}
3、运行与测试
for(w = 0;w<mgraph.vexnum;w++)
{
D[v][w] = mgraph.arcs[v][w].adj;//顶点v到顶点w的直接距离
for(u = 0;u<mgraph.vexnum;u++)
{
P[v][w][u] = false;//路径矩阵初值
}
if(D[v][w]<infinity)
//根据新并入的顶点，更新不在S集的顶点到v0的距离和路径数组
{
if(!final[w]&&min<infinity&&mgraph.arcs[v][w].adj<infinity&&
(min+mgraph.arcs[v][w].adj<D[w]))
// w不属于S集且v0→v→w的距离<目前v0→w的距离
程序运行如图所示。
Step1：运行程序，屏幕显示菜单。
Step2：运行功能选择。
Case1：输入“1”，选择菜单项1，进入图的创建操作。
1.1根据屏幕提示，创建有向网。
1.2屏幕显示网信息。
Case2：输入“2”，选择菜单项2，进入求源点到其他各点的距离操作。
运筹学最短路问题实验报告
运筹学最短路问题实验报告
姓名：雷超敏
学号：
班级：安全101
指导教师：冯树虎
一、实验目的：
1、学会独立建模能力，并用模型解决相关现实问题。
2、通过实验，把所学的运筹学理论知识与实践相结合，从而强化相关理论知识。
3、进一步加强对现实问题的认识，提高独立运用理论知识解决现实问题。
4、通过上机实验检验运筹学理论，发现相关理论知识的适用范围及不足。
二、实验任务：
1、提出一个有关运筹学的实际问题；
2、建立模型；
3、运用软件进行求解；
4、撰写分析报告。
三、实验软件
Excel2003。
最短路径实验报告
一、实验目的学习掌握图的存储结构利用最短路径算法，通过java编程实现最短路径输出。
二、实验环境Eclipse平台三、实验过程最短路径算法问题是计算机科学、运筹学、地理信息系统和交通诱导、导航系统等领域研究的一个热点。
传统的最短路径算法主要有Floyd算法和Dijkstra算法。
Floyd算法用于计算所有结点之间的最短路径。
Dijkstra算法则用于计算一个结点到其他所有结点的最短路径。
本程序利用Dijkstra算法用java语言实现最短路径的可视化。
流程: 画无向邻接矩阵邻接矩阵初始化求取最短路径Java文件如下M ain.java 文件：import java.awt.BorderLayout;import java.awt.Color;import java.awt.FlowLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.ItemEvent;import java.awt.event.ItemListener;import java.util.StringTokenizer;import javax.swing.JButton;import javax.swing.JComboBox;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.border.TitledBorder;public class Main {public static void main(String args[]) {new UI("最短路径");}}@SuppressWarnings("serial")class UI extends JFrame implements ActionListener, ItemListener { JFrame frame;JButton button;JLabel label1, label2, label3;JComboBox list1, list2;JPanel panel1, panel2;ShortCanvas canvas;ShortInit inits;SetFont f;String circlename[];String circle1, circle2;String path[];int circlenum;int list2_index;int D[];int renum[];int num = 0;UI(String s) {super(s);canvas = new ShortCanvas();add(canvas,BorderLayout.CENTER);f=new SetFont();inits = new ShortInit();circlename = inits.getcirclename();circlenum =inits.getcirclenum();circle1 = circlename[0];circle2 = circlename[0];panel2 = new JPanel();panel2.setBorder(new TitledBorder("最短路径"));panel2.setBackground(Color.white);panel2.setLayout(new FlowLayout(FlowLayout.LEADING, 5, 5));label1 = new JLabel("起点", JLabel.LEFT);label1.setFont(f.setSysFontAndFace());panel2.add(label1);list1 = new JComboBox();list1.addItemListener(this);list1.setMaximumRowCount(5);// 设置 JComboBox 显示的最大行数panel2.add(list1);label2 = new JLabel("终点");label2.setFont(f.setSysFontAndFace());panel2.add(label2);list2 = new JComboBox();list2.addItemListener(this);panel2.add(list2);list2.setMaximumRowCount(5);// 设置 JComboBox 显示的最大行数for (int i = 0; i < circlenum; i++) {list1.addItem(circlename[i]);list2.addItem(circlename[i]);}button = new JButton("确定");button.addActionListener(this);button.setFont(f.setSysFontAndFace());panel2.add(button);label3 = new JLabel("");label3.setFont(f.setSysFontAndFace());panel2.add(label3);add(panel2,BorderLayout.SOUTH);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setBounds(100, 100, 530, 547);setVisible(true);validate();}public void itemStateChanged(ItemEvent e) {if (e.getSource() == list1)circle1 = (String) list1.getSelectedItem();if (e.getSource() == list2) {circle2 = (String) list2.getSelectedItem();list2_index = list2.getSelectedIndex();}}public void actionPerformed(ActionEvent e) {if (e.getSource() == button) {ShortPath sp = new ShortPath(circle1, circle2);path = sp.getpath();D = sp.getD();label3.setText("最短路径为:" + D[list2_index]);renum = new int[circlenum];StringTokenizer fenxi = newStringTokenizer(path[list2_index], "->");num = 0;while (fenxi.hasMoreTokens()) {String str = fenxi.nextToken();for (int i = 0; i < circlenum; i++) {if (str.equals(circlename[i])) {renum[num] = i;num++;}}}canvas.flag = 1;canvas.resultroad = renum;canvas.num = num;canvas.repaint();}}}SetFont.java文件import java.awt.Font;import javax.swing.JFrame;import javax.swing.UIManager;import javax.swing.UnsupportedLookAndFeelException;//系统外观处理@SuppressWarnings("serial")public class SetFont extends JFrame {public Font setSysFontAndFace() {try {// 根据类名称设置外观UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel" );} catch (UnsupportedLookAndFeelException ex) {} catch (IllegalAccessException ex) {} catch (InstantiationException ex) {} catch (ClassNotFoundException ex) {}Font font = new Font("新宋体", Font.ITALIC + Font.BOLD, 17);return font;}}ShortCanvas.java文件://画无向邻接矩阵import java.awt.Canvas;import java.awt.Color;import java.awt.Graphics;@SuppressWarnings("serial")public class ShortCanvas extends Canvas {SetFont f;ShortInit init;String circlename[];int roadlength[];int arcs[][]; // 带权邻接矩阵int circlenum;int roadnum;int location[][]; // 各点坐标int flag = 0;int num;int resultroad[];// 结果线路ShortCanvas() {f = new SetFont();init = new ShortInit();circlename = init.getcirclename();roadlength = init.getroadlength();circlenum = init.getcirclenum();roadnum = init.getroadnum();arcs = new int[circlenum][circlenum];location = new int[circlenum][2];for (int i = 0; i < circlenum; i++)for (int j = 0; j < circlenum; j++)arcs[i][j] = 10000;set();}public void paint(Graphics g) {g.setFont(f.setSysFontAndFace());g.drawOval(60, 60, 25, 25); // ag.drawString(circlename[0], 70, 75);g.drawString(String.valueOf(roadlength[0]), 135, 135);g.drawOval(200, 180, 25, 25); // bg.drawString(circlename[1], 210, 195);g.drawLine(70, 85, 200, 192); // a--bg.drawOval(100, 300, 25, 25); // cg.drawString(circlename[2], 110, 315);g.drawString(String.valueOf(roadlength[1]), 90, 195);g.drawLine(70, 85, 112, 300); // a--cg.drawString(String.valueOf(roadlength[2]), 165, 250);g.drawLine(200, 192, 112, 300); // b--cg.drawOval(350, 180, 25, 25); // dg.drawString(circlename[3], 360, 195);g.drawString(String.valueOf(roadlength[3]), 285, 190);g.drawLine(225, 192, 350, 192); // b--dg.drawOval(250, 360, 25, 25); // gg.drawString(circlename[4], 260, 375);g.drawString(String.valueOf(roadlength[4]), 185, 345);g.drawLine(125, 315, 250, 375); // c--gg.drawString(String.valueOf(roadlength[5]), 305, 270);g.drawLine(275, 372, 350, 192); // g--dg.drawOval(450, 80, 25, 25); // eg.drawString(circlename[5], 460, 95);g.drawString(String.valueOf(roadlength[6]), 420, 150);g.drawLine(375, 192, 462, 105); // d--eg.drawOval(480, 300, 25, 25); // fg.drawString(circlename[6], 490, 315);g.drawString(String.valueOf(roadlength[7]), 465, 205);g.drawLine(462, 105, 492, 300); // e--fg.drawString(String.valueOf(roadlength[8]), 420, 280);g.drawLine(375, 192, 480, 312); // d--fg.drawString(String.valueOf(roadlength[9]), 370, 330);g.drawLine(275, 372, 480, 312); // g--fg.drawString(String.valueOf(roadlength[10]), 260, 85);g.drawLine(70, 85, 450, 92); // a--eint i, j;if (flag == 1) {g.setColor(Color.red);for (i = 0; i < num - 1; i++) {j = i + 1;g.drawLine(location[resultroad[i]][0] + 12,location[resultroad[i]][1] + 12,location[resultroad[j]][0] + 12,location[resultroad[j]][1] + 12);}}}public void set() {location[0][0] = 60;location[0][1] = 60;location[1][0] = 200;location[1][1] = 180;location[2][0] = 100;location[2][1] = 300;location[3][0] = 350;location[3][1] = 180;location[4][0] = 250;location[4][1] = 360;location[5][0] = 450;location[5][1] = 80;location[6][0] = 480;location[6][1] = 300;arcs[0][1] = arcs[1][0] = roadlength[0];arcs[0][2] = arcs[2][0] = roadlength[1];arcs[1][2] = arcs[2][1] = roadlength[2];arcs[1][3] = arcs[3][1] = roadlength[3];arcs[2][4] = arcs[4][2] = roadlength[4];arcs[4][3] = arcs[3][4] = roadlength[5];arcs[3][5] = arcs[5][3] = roadlength[6];arcs[5][6] = arcs[6][5] = roadlength[7];arcs[3][6] = arcs[6][3] = roadlength[8];arcs[4][6] = arcs[6][4] = roadlength[9];arcs[0][5] = arcs[5][0] = roadlength[10];}public int[][] getarcs() {return arcs;}}ShortInit.java文件：public class ShortInit {int circlenum=7;int roadnum=9;int num[];String circlename[];int roadlength[];ShortInit (){circlename=new String[10];roadlength=new int[15];circlename[0]="a";circlename[1]="b";circlename[2]="c";circlename[3]="d";circlename[4]="g";circlename[5]="e";circlename[6]="f";roadlength[0]=7;roadlength[1]=6;roadlength[2]=3;roadlength[3]=20;roadlength[4]=5;roadlength[5]=3;roadlength[6]=9;roadlength[7]=6;roadlength[8]=8;roadlength[9]=11;roadlength[10]=8;}public String[] getcirclename(){return circlename;}public int[] getroadlength(){return roadlength;}public int getcirclenum(){return circlenum;}public int getroadnum(){return roadnum;}}Shortpath.java 文件//求取最短路径public class ShortPath {int maxlength = 10000;int maxcirclenum = 30;ShortInit init;ShortCanvas canvas;String circlename[];String start, end;String path[];int arcs[][];int circlenum;int roadnum;int v0;int D[];ShortPath(String s1, String s2) {init = new ShortInit();canvas = new ShortCanvas();circlename = init.getcirclename();circlenum = init.getcirclenum();roadnum = init.getroadnum();start = s1;end = s2;arcs = canvas.getarcs();path = new String[circlenum];for (int p = 0; p < circlenum; p++)path[p] = start;for (int k = 0; k < circlenum; k++) {if (start.equals(circlename[k])) {v0 = k;}}shortestpath(v0);}public void shortestpath(int v0) {int v, i, w;int min;boolean finald[] = new boolean[maxcirclenum];D = new int[maxcirclenum];boolean p[][] = new boolean[maxcirclenum][maxcirclenum];for (v = 0; v < circlenum; v++) {finald[v] = false;D[v] = arcs[v0][v];for (w = 0; w < circlenum; ++w)p[v][w] = false;if (D[v] < maxlength) {p[v][v0] = true;p[v][v] = true;}}D[v0] = 0;finald[v0] = true;for (i = 1; i < circlenum; i++) {min = maxlength;for (w = 0; w < circlenum; w++)if (!finald[w])if (D[w] < min) {v = w;min = D[w];}finald[v] = true;path[v] = path[v] + "->" + circlename[v];for (w = 0; w < circlenum; w++) {if (!finald[w] && (min + arcs[v][w] < D[w])) {D[w] = min + arcs[v][w];path[w] = path[v];p[w][w] = true;}}}for (int j = 0; j < circlenum; ++j) {System.out.println(path[j] + ": "+ String.valueOf(D[j]) + "km");}}public String[] getpath() {return path;}public int[] getD() {return D;}}四、实验结果五、实验体会通过这次实验，懂得了如何通过邻接矩阵存储图，然后利用迪杰斯特拉算法算出最短路径。
最短路径_Dijkstra算法__实验报告
最短路径_Dijkstra算法__实验报告实验六：编程实现Dijkstra 算法求最短路问题.1.需求分析：首先让用户输入一个带权的有向图，输入时可通过一对一对输入存在弧的两个弧头与弧尾顶点以及弧上的权值从而输入整个有向图。
用户输入一对对弧后，我们可以采用数组的形式来进行存储每个顶点之间的权值，最后由用户输入该有向图的源点（即每个最短路径的起点），要求源点必须为刚才输入的各顶点中的某一个，如果用户输入错误，程序要给出错误信息提示并退出程序。
然后，我们可以设计一个Graph这样的类，将对关系的各种操作放入其中，然后我们在主函数中调运这个类就可以实现最短路问题的求解了。
2.概要设计：①.构造一个新的类Graph:class Graph{private: int arcs[MAX][MAX],Path[MAX][MAX],D[MAX];int arcnum,vexnum,weight,v0;Type a,b,vexs[MAX];public:void Creat_Graph();void Show_ShortestPath();void ShortestPath_DIJ();};②.结构化调用类中方法的主函数：int main(){Graph G;G.Creat_Graph();G.ShortestPath_DIJ();G.Show_ShortestPath();return 0;}3.代码实现：#include#define MAX 100#define INFINITY INT_MAXenum BOOL{FALSE,TRUE};using namespace std;templateclass Graph{private: int arcs[MAX][MAX],Path[MAX][MAX],D[MAX]; int arcnum,vexnum,weight,v0;Type a,b,vexs[MAX];public:void Creat_Graph();void Show_ShortestPath();void ShortestPath_DIJ();};templatevoid Graph::Creat_Graph(){int i,j,x,y;cout<<"请输入你要处理的有向图中包含弧的个数："; cin>>arcnum;vexnum=0;for(i=1;i<=MAX;i++)for(j=1;j<=MAX;j++)arcs[i][j]=INT_MAX;for(i=1;i<=arcnum;i++){cout<<"请依次输入第"<<i<<"条弧的弧头与弧尾的顶点以及该弧上所附带的权值："<<endl;< p="">cin>>a>>b>>weight;x=0; y=0;for(j=1;j<=vexnum;j++){if(vexs[j]==a){x=j; continue;}else if(vexs[j]==b){y=j; continue;}}if(x==0){vexs[++vexnum]=a; x=vexnum;}if(y==0){vexs[++vexnum]=b; y=vexnum;}arcs[x][y]=weight;}cout<<"请输入该有向图的源点(即各最短路径的起始顶点)：";cin>>a;for(i=1;i<=vexnum;i++){if(vexs[i]==a){v0=i; break;}}}templatevoid Graph:: Show_ShortestPath(){int i,j,k;for(i=1;i<=vexnum;i++){if(i==v0) continue;if(D[i]!=INT_MAX){cout<<"从源点"<<vexs[v0]<<"到"<<vexs[i]<<"的最短路径为："<<endl;< p="">for(k=1;k<=Path[i][0];k++){if(k!=1)cout<<"-->";for(j=1;j<=vexnum;j++)if(Path[i][j]==k)cout<<vexs[j];< p="">}cout<<" "<<"其最短的路径长度为："<<d[i]<<endl;< p="">}else{cout<<"无法从源点"<<vexs[v0]<<"到达顶点"<<vexs[i]<<"."<<endl;< p="">}}cout<<endl;< p="">}templatevoid Graph::ShortestPath_DIJ(){int v,w,final[MAX],min,i,j;for(v=1;v<=vexnum;v++){final[v]=FALSE; D[v]=arcs[v0][v]; Path[v][0]=0;for(w=0;w<=vexnum;w++)Path[v][w]=FALSE;if(D[v]<int_max)< p="">{ Path[v][v0]=++Path[v][0]; Path[v][v]=++Path[v][0]; }}D[v0]=0; final[v0]=TRUE;for(i=1;i<=vexnum;i++){if(i==v0) continue;min=INT_MAX;for(w=1;w<=vexnum;w++)if(!final[w])if(D[w]<="">final[v]=TRUE;for(w=1;w<=vexnum;w++)if(!final[w]&&(min+arcs[v][w]<d[w])&&min<int_max&&arcs [v][w]<int_max)< p="">{D[w]=min+arcs[v][w];for(j=0;j<=vexnum;j++)Path[w][j]=Path[v][j];Path[w][w]=++Path[w][0];}}}int main(){Graph G;G.Creat_Graph();G.ShortestPath_DIJ();G.Show_ShortestPath();return 0;}4.调试分析：起先在主函数中调用类Graph时将类型参数T赋值为int从而导致用户输入的关系集合R中的元素必须为整数。
运筹学最短路问题及程序
运筹学最短路问题----------关于旅游路线最短及程序摘要：随着社会的发展，人民的生活水平的提高，旅游逐渐成为一种时尚，越来越多的人喜欢旅游。
而如何才能最经济的旅游也成为人民考虑的一项重要环节，是选择旅游时间最短，旅游花费最少还是旅游路线最短等问题随之出现，如何决策成为一道难题。
然而，如果运用运筹学方法来解决这一系列的问题，那么这些问题就能迎刃而解。
本文以旅游路线最短问题为列，给出问题的解法，确定最短路线，实现优化问题。
关键词：最短路 0-1规划约束条件提出问题:从重庆乘飞机到北京、杭州、桂林、哈尔滨、昆明五个城市做旅游，每个城市去且仅去一次，再回到重庆，问如何安排旅游线路，使总旅程最短。
各城市之间的航线距离如下表：重庆北京杭州桂林哈尔滨昆明重庆0 1640 1500 662 2650 649北京1640 0 1200 1887 1010 2266杭州1500 1200 0 1230 2091 2089桂林662 1887 1230 0 2822 859哈尔滨2650 1010 2091 2822 0 3494昆明649 2266 2089 859 3494 0问题分析：1．这是一个求路线最短的问题，题目给出了两两城市之间的距离，而在最短路线中,这些城市有的两个城市是直接相连接的（即紧接着先后到达的关系），有些城市之间就可能没有这种关系，所以给出的两两城市距离中有些在最后的最短路线距离计算中使用到了，有些则没有用。
这是一个0-1规划的问题，也是一个线性规划的问题。
2．由于每个城市去且仅去一次，最终肯定是形成一个圈的结构，这就导致了这六个城市其中有的两个城市是直接相连的，另外也有两个城市是不连接的。
这就可以考虑设0-1变量，如果两个城市紧接着去旅游的则为1，否则为0。
就如同下图3. 因为每个城市只去一次，所以其中任何一个城市的必有且仅有一条进入路线和一条出去的路线。
解法：为了方便解题，给上面六个城市进行编号，如下表（因为重庆是起点，将其标为1）重庆北京杭州桂林哈尔滨昆明123456假设：设变量x11。
运筹学列表法求最短路径
运筹学列表法求最短路径
运筹学中的列表法（或称为迪杰斯特拉算法）用于求解最短路径问题。
它通常用于有向图
中求解从一个节点到其他所有节点的最短路径。
以下是使用列表法求解最短路径的步骤：
1. 创建一个节点列表，存储每个节点的信息。
每个节点包括一个标识符（用于唯一标识节点）、到达该节点的路径长度以及该节点的前驱节点。
2. 初始化列表，将起始节点的路径长度设置为0，将其他节点的路径长度设置为无穷大。
3. 选择起始节点，将其添加到一个已访问节点的集合中。
4. 对于起始节点的每个相邻节点，更新其路径长度和前驱节点，如果经过当前节点可以得到更
短的路径。
5. 从未访问节点中选择一个具有最小路径长度的节点，将其添加到已访问节点的集合中。
6. 重复步骤4和5，直到所有节点都被访问。
7. 根据节点列表中每个节点的前驱节点信息，从目标节点开始回溯，找到最短路径。
运筹学中的列表法是一种有效的算法，可以解决最短路径问题，并且适用于各种图模型。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
下图所示是某地区交通运输的示意图，试问从 出发，经哪条路线达到 才能使总行程最短使用Dijkstra求解。
5 9
4 4 7 5 4
6 4 5 1
7 6
步骤：
1.首先给 以P标号， ,给其余所有的点以T标号，
2.（1）考察点 ，边
（2)比较所有T标号 ， 最小，所以给 以P标号，令 ,记录路径
6. （1） 为刚得到P标号的点，考察
(2) 比较所有T标号, , 最小,给 以P标号,令 ,记录路径
7. （1） 为刚得到P标号的点，考察
(2)比较所有T标号， , 最小,给 以P标号,令 ,记录路径
8. （1） 为刚得到P标号的点，考察
（2）比较所有T标号， 最小，给 ,最短行程为15
实验总结
科学合理的运输路线对物流的成本的大小影响很大。Dijkstra算法就是通过一种方法，使运输路线最短，运费最少，尽可能的降低物流成本，提高产品的竞争力，Dijkstra，根据距 从近到远的顺序，依次求得 到 各顶点的最短路径和距离，直至 ，算法结束。根据记录的最后路径 逆推至 ， ， ，总结出路径为 ，所以最短距离为15.
Dijkstra算法的基本步骤如下：
（1）给起点 以P标号 ,其余各点均给以T标号， 。
（2）若 点为刚得到的ｐ标号的点，考虑这样的点为 ，考虑 这条边，且 为T标号，对 的T标号进行如下更改
（3）比较所有具有Ｔ标号的点，把最小者改为Ｐ标号，即 ，当存在两个以上最小者时，可同时改为Ｐ标号，若全部点均为Ｐ标号，则停止，否则 代 改为第二步重做。
实验项目：最短路径问题
实验学时： 4
实验日期：2012年11月30日
实验要求：案例 模型 分析
实验内容：用最短路径模型解决具体问题
前言
运输是物流过程的主要职能之一，也是物流过程各项业务的中心活动。物流过程中的其它各项活动，如包装、装卸搬运、物流信息等，都是围绕着运输而进行的。可以说，在科学技术不断进步、生产的社会化和专业化程度不断提高的今天，一切物质产品的生产和消费都离不开运输。物流合理化，在很大程度上取决于运输合理化。所以，在物流过程的各项业务活动中，运输是关键，起着举足轻重的作用。而有效的缩减路径可以使得运输费用降低。本文运用Dijkstra算法求出最短路径，以最大限度地节约运输费用降低物流成本，Dijkstra算法用于求解最短路径问题最常用的方法之一。
精心搜集整理，只为你的需要
3. (1) 为刚得到P标号的点，考察边
（2）比较所有T标号， , 最小，给 以P标号，令 ,记录路径
4. （1） 为刚得到P标号的点，考察
（2）比较所有T标号， , 最小，给 以P标号，令
,记录路径
5. （1) 为刚得到P标号的点，考察
（2）比较所有T标号， , 最小,给 以P标号,令 ，记录路径