最短路径算法实验报告
最短路径的实验报告
最短路径的实验报告最短路径的实验报告引言：最短路径问题是图论中一个经典的问题，涉及到在一个带有权重的图中找到两个顶点之间的最短路径。
本实验旨在通过实际操作和算法分析，深入探讨最短路径算法的性能和应用。
实验设计：本次实验使用了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算法来计算两个城市之间的最短路径，并将结果与实际的驾车时间进行比较。
最短路径规划实验报告
1.实验题目：单源最短路径的dijkstra解法两点间最短路径的动态规划解法Dijkstra算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。
主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。
Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。
注意该算法要求图中不存在负权边。
问题描述：在无向图G=(V,E) 中，假设每条边E[i] 的长度为w[i]，找到由顶点V0 到其余各点的最短路径。
（单源最短路径）2.算法描述:1)算法思想：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径, 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。
在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v 到U中任何顶点的最短路径长度。
此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
2)算法步骤：a.初始时，S只包含源点，即S＝{v}，v的距离为0。
U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则<u,v>正常有权值，若u不是v的出边邻接点，则<u,v>权值为∞。
b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。
c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。
d.重复步骤b和c直到所有顶点都包含在S中。
实验三最短路径的算法（离散数学实验报告）
实验三最短路径的算法（离散数学实验报告）实验3：最短路径算法⼀、实验⽬的通过本实验的学习，理解Floyd（弗洛伊得）最短路径算法的思想⼆、实验内容⽤C语⾔编程实现求赋权图中任意两点间最短路径的Floyd算法，并能对给定的两结点⾃动求出最短路径三、实验原理、⽅法和⼿段1、Floyd算法的原理定义：Dk[i,j] 表⽰赋权图中从结点vi出发仅通过v0，v1，┉，vk-1中的某些结点到达vj的最短路径的长度，若从vi到vj没有仅通过v0，v1，┉，vk-1 的路径，则D[i,j]=∝即D-1[i,j] 表⽰赋权图中从结点vi到vj的边的长度，若没有从结点vi到vj的边，则D[i,j]=∝D0[i,j] 表⽰赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0外没有其它结点D1[i,j] 表⽰赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0，v1外没有其它结点┉┉┉根据此定义，D k[i,j]=min{ D k-1[i,j] , D k-1[i,k-1]+D k-1[k-1,j] }定义：path[i,j]表⽰从结点vi到vj的“最短”路径上vi的后继结点四、实验要求要求输出每对结点之间的最短路径长度以及其最短路径五、实验步骤（⼀）算法描述Step 1 初始化有向图的成本邻矩阵D、路径矩阵path若从结点vi到vj有边，则D[i,j]= vi到vj的边的长度，path[i,j]= i；否则D[i,j]=∝，path[i,j]=-1Step 2 刷新D、path 对k=1,2,┉n 重复Step 3和Step 4Step 3 刷新⾏对i=1,2,┉n 重复Step 4Step 4 刷新Mij 对j=1,2,┉n若D k-1[i,k]+D k-1[k,j][结束循环][结束Step 3循环][结束Step 2循环]Step 5 退出（⼆）程序框图参考主程序框图其中，打印最短路径中间结点调⽤递归函数dist()，其框图如下，其中fist,end是当前有向边的起点和终点dist(int first, int end)七、测试⽤例：1、输⼊成本邻接矩阵：D ：06380532290141003210∝∝∝∝V V V V V V V V （其中∝可⽤某个⾜够⼤的数据值代替，⽐如100）可得最短路径矩阵：P ：131132122211111010103210--------V V V V V V V V以及各顶点之间的最短路径和最短路径长度：从V0到V1的最短路径长度为：1 ；最短路径为：V0→V1 从V0到V2的最短路径长度为：9 ；最短路径为：V0→V1→V3→V2 从V0到V3的最短路径长度为：3 ；最短路径为：V0→V1→V3 从V1到V0的最短路径长度为：11；最短路径为：V1→V3→V2→V0从V1到V2的最短路径长度为：8 ；最短路径为：V1→V3→V2 从V1到V3的最短路径长度为：2 ；最短路径为：V1→V3 从V2到V0的最短路径长度为：3 ；最短路径为：V2→V0 从V2到V1的最短路径长度为：4 ；最短路径为：V2→V0→V1 从V2到V3的最短路径长度为：6 ；最短路径为：V2→V0→V1→V3 从V3到V0的最短路径长度为：9 ；最短路径为：V3→V2→V0 从V3到V1的最短路径长度为：10；最短路径为：V3→V2→V0→V1 从V3到V2的最短路径长度为：6 ；最短路径为：V3→V2 参考程序： #include #define INFINITY 100 #define Max 10int a[Max][Max],P[Max][Max]; main() {void Print_Flod(int d);int i,j,k,D=4;printf("请输⼊成本邻接矩阵：\n");for(i=0;ifor(j=0;j{scanf("%d",&a[i][j]);}for(i=0;ifor(j=0;j{if(a[i][j]>0&& a[i][j]elseP[i][j]=-1;}for(k=0;kfor(i=0;ifor(j=0;jif (a[i][k]+a[k][j]{a[i][j]=a[i][k]+a[k][j];P[i][j]=k;}Print_Flod(D);}void Print_Flod(int d){void dist(int first,int end);int i,j;for(i=0;ifor(j=0;jif(i!=j){ printf("from V%d to V%d: ",i,j); dist(i,j);printf("V%d",j);printf(" (The length is: %d)\n",a[i][j]); }}void dist(int first,int end){ int x;x=P[first][end];if(x!=first){ dist(first,x); dist(x,end); }else printf("V%d->",x);}输出结果：。
最短路径实验报告
最短路径实验报告最短路径实验报告引言：最短路径算法是计算机科学中的一个经典问题，它在许多领域中都有广泛的应用，如交通规划、电路设计、网络通信等。
本实验旨在通过实践探索最短路径算法的实际应用，并对其性能进行评估。
一、问题描述：我们将研究一个城市的交通网络，其中包含多个节点和连接这些节点的道路。
每条道路都有一个权重，表示通过该道路所需的时间或距离。
我们的目标是找到两个节点之间的最短路径，即使得路径上各个道路权重之和最小的路径。
二、算法选择：为了解决这个问题，我们选择了Dijkstra算法和Floyd-Warshall算法作为比较对象。
Dijkstra算法是一种单源最短路径算法，它通过不断选择当前最短路径的节点来逐步扩展最短路径树。
Floyd-Warshall算法则是一种多源最短路径算法，它通过动态规划的方式计算任意两个节点之间的最短路径。
三、实验设计：我们首先构建了一个包含10个节点和15条道路的交通网络，每条道路的权重随机生成。
然后，我们分别使用Dijkstra算法和Floyd-Warshall算法计算两个节点之间的最短路径，并记录计算时间。
四、实验结果：经过实验，我们发现Dijkstra算法在计算单源最短路径时表现出色，但是在计算多源最短路径时效率较低。
而Floyd-Warshall算法在计算多源最短路径时表现出色，但是对于大型网络的单源最短路径计算则需要较长的时间。
五、性能评估：为了评估算法的性能，我们对不同规模的交通网络进行了测试，并记录了算法的计算时间。
实验结果显示，随着交通网络规模的增大，Dijkstra算法的计算时间呈指数级增长，而Floyd-Warshall算法的计算时间则呈多项式级增长。
因此，在处理大型网络时，Floyd-Warshall算法具有一定的优势。
六、实际应用：最短路径算法在实际应用中有着广泛的用途。
例如，在交通规划中，最短路径算法可以帮助我们找到最优的行车路线，减少交通拥堵。
matlab最短路径实验报告
matlab最短路径实验报告一、实验目的本实验的目的是通过使用Matlab软件来实现最短路径算法，掌握最短路径算法的基本思路和实现方法，加深对图论知识的理解和应用能力。
二、实验原理最短路径算法是图论中一个重要的问题，它是指在一个加权有向图或无向图中从一个顶点到另一个顶点之间经过的边权值之和最小的路径。
常见的最短路径算法有Dijkstra算法、Bellman-Ford算法、Floyd-Warshall算法等。
本次实验采用Dijkstra算法来求解最短路径。
Dijkstra算法是一种贪心算法，它通过维护一个集合S来不断扩展已知最短路径集合S中所有节点到未知节点v之间的距离，并选取其中距离最小的节点u加入S中，直到所有节点都被加入S为止。
三、实验步骤1. 构建图首先需要构建一个加权有向图或无向图。
本次实验采用无向图，并使用邻接矩阵表示。
具体步骤如下：（1）定义节点数n和边数m；（2）定义邻接矩阵A（n*n），其中A(i,j)表示从i到j是否有边，如果有则为边的权值，如果没有则为无穷大。
2. 初始化（1）定义两个数组dist和visited，其中dist(i)表示从起点到节点i 的最短距离，visited(i)表示节点i是否已经加入集合S中；（2）将起点加入集合S中，并将visited数组对应位置设为1；（3）初始化dist数组，将所有非起点节点的距离设为无穷大。
3. 迭代更新（1）遍历集合S中所有节点u的邻居节点v，如果v未被加入集合S 中，则更新dist(v)的值。
具体而言，如果dist(u)+A(u,v)<dist(v)，则更新dist(v)=dist(u)+A(u,v)；（2）在所有未加入集合S中的节点中选取距离最小的节点u，并将其加入集合S中。
4. 输出结果输出起点到各个终点的最短路径长度和路径。
四、实验结果与分析本次实验构建了一个无向图，并使用Dijkstra算法求解了最短路径。
具体实现过程如下：1. 构建图构建了一个6个节点、8条边的无向图，邻接矩阵如下：0 6 4 Inf Inf Inf6 0 1 5 Inf Inf4 1 0 Inf Inf InfInf5InfInf0 Inf 1InfInfInf Inf0 2InfInfInf 1 2 0其中，Inf表示两个节点之间没有边。
Dijkstra最短路径算法实习报告
Dijkstra最短路径算法实习报告1.引言交通诱导系统的一个核心技术是最优路径的选择技术。
根据交通网络模型中各顶点和顶点之间的长度、时间或费用等属性权值，通过Dijkstra最短路径算法，解决有向图即交通网络模型中源点到其他顶点的最短路径问题。
2.建立交通道路网络模型交通道路网是路径诱导的基础和对象，首先需要建立交通道路网络模型。
交通道路网中的路段具有属性，且同一路段的两个方向其属性一般不完全相同，有向图能够很好地表达实际的交通网络，便于处理同路段两个方向的不同属性和单行线、交叉口转向限制等特殊交通属性。
综上，采用带权有向图来表达交通道路网。
其中，道路的终点和十字路口通常定义为一个顶点，两个顶点之间的道路定义为一条弧，每条弧根据其距离、途中所需时间或交通费用等定义为路段权值。
在有向图上，一条以i为起点，以j为终点的路径是一些顶点的序列，其中前一条弧的终点是后一条弧的起点，一条路线用一个有序的点集描述，而一条路线的长度、时间或者费用等属性为这条路径上的所有弧的权值之和。
这样便建立好了交通道路网络的模型。
3.最短路径算法迪杰斯特拉（Dijkstra）算法是经典路径诱导规划算法，Dijkstra算法是一个按路径长度递增的次序产生最短路径的算法，算法比较简单，容易实现，但计算量较大。
3.1算法分析：首先引进辅助向量D，它的每个分量D[i]表示当前所找到的从始点v0到每个终点vi的最短路径的长度。
为D[i]赋初值，若从v0到vi有弧，则D[i]为弧上的权值，否则置D[i]为∞。
则长度为D[j]=Min{D[i]|vi∈v}的路径就是从v0出发的长度最短的一条最短路径，此路径为v0—vj。
设下一条长度次短的路径的终点是vk，则这条路径或者是v0—vk，或者是v0—vj—vk。
它的长度是v0到vk弧上的权值或D[j]和vj到vk弧上权值之和。
3.2算法正确性证明：设s为为已切得最短路径的终点的集合，则有结论：下一条最短路径（设其终点为vx）或者是v0—vx，或者是中间只经过s中的顶点而最后到达顶点x的路径。
matlab最短路径实验报告
最短路径实验报告1. 背景最短路径问题是图论中的一个经典问题，它在很多实际应用中都具有重要的意义。
解决最短路径问题可以帮助我们找到两个节点之间最短的路径，这在交通规划、网络通信等领域都有广泛应用。
在本次实验中，我们将使用Matlab编程语言来解决最短路径问题。
Matlab是一种高级技术计算语言和环境，它提供了丰富的工具箱和函数库，可以方便地进行数值计算、数据可视化等操作。
通过使用Matlab，我们可以快速有效地解决最短路径问题，并得到结果。
2. 分析本次实验的目标是使用Matlab解决最短路径问题。
为了达到这个目标，我们需要进行以下步骤：2.1 数据准备首先，我们需要准备一些数据来表示图的结构。
这些数据包括节点和边的信息。
节点可以用数字或字符串来表示，边可以用两个节点之间的关系来表示。
2.2 图的表示在Matlab中，我们可以使用邻接矩阵或邻接表来表示图的结构。
邻接矩阵是一个二维数组，其中元素表示两个节点之间是否存在边。
邻接表是一个列表，其中每个节点都有一个相邻节点列表。
2.3 最短路径算法解决最短路径问题的常用算法有迪杰斯特拉算法和弗洛伊德算法。
迪杰斯特拉算法是一种贪心算法，通过不断选择当前最短路径的节点来求解最短路径。
弗洛伊德算法是一种动态规划算法，通过逐步更新节点之间的最短距离来求解最短路径。
2.4 编程实现在Matlab中，我们可以使用内置函数或编写自定义函数来实现最短路径算法。
内置函数如graphshortestpath和shortestpath可以直接调用，而自定义函数需要我们根据具体问题进行编写。
3. 结果经过实验，我们成功地使用Matlab解决了最短路径问题，并得到了正确的结果。
下面是我们得到的一些结果示例：输入：节点：A, B, C, D边：(A,B), (B,C), (C,D)输出：最短路径：A -> B -> C -> D距离：3输入：节点：A, B, C, D边：(A,B), (B,C), (C,D)输出：最短路径：A -> C -> D距离：2通过这些结果，我们可以看出Matlab的最短路径算法在解决最短路径问题上具有较高的准确性和效率。
单源最短路径问题并行算法分析
单源最短路径问题并行算法分析实验报告一、实验名称单源最短路径问题并行算法分析。
二、实验目的分析单源最短路径Dijkstra并行算法和MPI源程序，并分析比较Dijkstra并行算法和Moore并行算法的性能。
三、实验内容1、分析单源最短路径Dijkstra并行算法和MPI源程序。
2、分析单源最短路径问题的Moore并行算法，比较两种并行算法的性能。
四、实验步骤1、问题描述单源最短路径问题即指：已知一个n结点有向图G=(V,E)和边的权函数c(e)，求由G中某指定结点v0到其他各个结点的最短路径。
这里还假定所有的权值都是正的。
2、比较串行Dijkstra算法和Moore算法2.1、Dijkstra算法基本思想假定有一个待搜索顶点表VL，初始化时做：dist(s)←0；dist(i)←∞(i≠s)；VL←V。
算法执行时，每次从VL（≠Φ）中选取这样一个顶点u，它的dist(u)值最小。
将选出的u作为搜索顶点，若<u，v>∈E，而且dist(u)+w(u,v)<dist(v)，则更新dist(v)为dist(u)+w(u,v)，直到VL=Φ时算法终止。
算法描述如下：输入：加权邻接矩阵W，约定i，j之间无边连接时w(i,j)=∞，且w(i,i)=∞；输出：dist(1:n)，其中，dist(i)表示顶点s到顶点i的最短路径（1≤i≤n）。
begin/*初始化*/(1)dist(s)←0；(2)for i←1 to n doif i≠s then dist(i)←∞endifendfor；(3)VL←V；(4)for i←1 to n do /*找最短距离*/(5)find a vertex u∈VL,such that dist(u) is minimal；(6)for each(<u，v>∈E) ∧(v∈VL) doif dist(u)+w(u,v)<dist(v) thendist(v)←dist(u)+w(u,v)endifendfor；(7)VL←VL-{u}endforend.2.2、Moore算法的基本思想设源点为s∈V,从s到其它各顶点的最短路径长度用一个一维数组dist存储。
动态规划算法实现多段图的最短路径问题算法设计与分析实验报告
动态规划算法实现多段图的最短路径问题算法设计与分析实验报告算法设计与分析实验报告实验名称 动态规划算法实现多段图的最短路径问题 评分 实验日期 年 月 日 指导教师 姓名 专业班级 学号一.实验要求1. 理解最优子结构的问题。
有一类问题的活动过程可以分成若干个阶段，而且在任一阶段后的行为依赖于该阶段的状态，与该阶段之前的过程如何达到这种状态的方式无关。
这类问题的解决是多阶段的决策过程。
在50年代，贝尔曼（Richard Bellman ）等人提出了解决这类问题的“最优化原理”，从而创建了最优化问题的一种新的算法设计方法－动态规划。
对于一个多阶段过程问题，是否可以分段实现最优决策，依赖于该问题是否有最优子结构性质，能否采用动态规划的方法，还要看该问题的子问题是否具有重叠性质。
最优子结构性质：原问题的最优解包含了其子问题的最优解。
子问题重叠性质：每次产生的子问题并不总是新问题，有些子问题被反复计算多次。
问题的最优子结构性质和子问题重叠性质是采用动态规划算法的两个基本要素。
2.理解分段决策Bellman 方程。
每一点最优都是上一点最优加上这段长度。
即当前最优只与上一步有关。
U s 初始值，u j 第j 段的最优值。
⎪⎩⎪⎨⎧+==≠}.{min ,0ijiji js w u u u3.一般方法1）找出最优解的性质，并刻画其结构特征；2）递归地定义最优值（写出动态规划方程）；3）以自底向上的方式计算出最优值；4）根据计算最优值时得到的信息，构造一个最优解。
步骤1-3是动态规划算法的基本步骤。
在只需要求出最优值的情形，步骤4可以省略，步骤3中记录的信息也较少；若需要求出问题的一个最优解，则必须执行步骤4，步骤3中记录的信息必须足够多以便构造最优解。
二.实验内容1.编程实现多段图的最短路径问题的动态规划算法。
2.图的数据结构采用邻接表。
3.要求用文件装入5个多段图数据，编写从文件到邻接表的函数。
4.验证算法的时间复杂性。
实验报告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)，直至循环结束，更新后的最短路径入栈，在文件中输出到其余各顶点的最短路径及花费。
数据结构实验报告 最短路径
实验报告实验名称最短路径课程名称数据结构与算法实验||专业班级：信息安全学号：姓名：实验六最短路径一、实验目的1.学习掌握图的存储结构2.学会编写求最短路径的算法二、实验内容1、实验题目编写代码实现Dijkstra生成最短路径的算法，其中要有完整的图的输入输出2、简单介绍图的存储：用邻接矩阵，这样会方便不少。
邻接矩阵是一个二维数组，数组中的元素是边的权（一些数值），数组下标号为结点的标号。
（1）例如二维数组中的一个元素M[5][6]的值为39，则表示结点5、6连接，且其上的权值为39。
（2）用邻接矩阵存储图，对图的读写就简单了。
因为邻接矩阵就是一个二维数组，因此对图的读写就是对二维数组的操作。
只要能弄清楚边的编号，就能把图读入了。
用一对结点表示边（也就是输入的时候输入一对结点的编号）求最短路径的算法：求最短路径就是求图中的每一个点到图中某一个给定点（这里认为是编号为0的点）的最短距离。
具体算法就是初始有一个旧图，一个新图。
开始的时候旧图中有所有的结点，新图中初始为只有一个结点（源点，路径的源头）。
整个算法就是不停的从旧图中往新图中添加点，直到所有的点都添加到新图中为止。
要实现这个算法，除了用二维数组保存图，还需要使用到两个辅助的数组数组find[N]：此数组是用来表示标号对应的结点是否已经被添加到新图中（因为只有旧图中的点我们才需要添加到新图中，并且只有旧图中点到源点的距离，我们才需要进行更新）其中N为图中结点的个数。
数组distance[N]：此数组记录图中的点到源点的距离。
这个数组里面存放的值是不断进行更新的。
其中N为图中结点的个数。
3、程序简单模板只是参考，不需要照着这个来写//最短路径#ifndef MYGRAPH_H_#define MYGRAPH_H_class MyGraph{public:void readDirectedGraph();MyGraph(int size);//构造函数中设置图的大小，分配空间void writeGraph();void shortPath(int source);//求最短路径protected:private:int **m_graph;//用二维数组保存图int m_size;//图的大小};#endif///////////////////////////////////////////// //////////////////////////构造函数中设置图的大小，分配空间MyGraph::MyGraph(int size){int i,j;m_size=size;//给图分配空间m_graph=new int* [m_size];for (i=0;i<m_size;i++){m_graph[i]=new int[m_size];}for (i=0;i<m_size;i++){for(j=0;j<m_size;j++){m_graph[i][j]=INT_MAX;}}}三、实验代码#include<iostream>#include <iomanip>#include <stack>#include <deque>#include <fstream>using namespace std;struct primnode{public:char begvex;char endvex;int lowcost;};struct adknode{int dist;//最近距离char way[50];//顶点数组int nodenum;//经过的顶点数};class Mgraph//邻接矩阵储存结构{public:Mgraph(){}~Mgraph(){}void CreatMGraph();void DFS (int );//用递归实现void DFS1(int );//非递归void BFS(int );void print();void prim();int mini();int low();//最短距离函数的辅助函数int LocateVex(char);void kruskal();void Dijkstra();void Floyd();private:int number;//顶点数目int arcnum;//边的数目char vexs[50];int arcs[50][50];int visited[50];//便利时的辅助工具primnode closeedge[50];//primadknode dist[50];//最短路径int D[20][20];//floyd算法距离int P[20][20][20];//floyd算法路径};int Mgraph::LocateVex(char s){for(int i=0;i<number;i++)if (vexs[i]==s)return i;return -1;}void Mgraph::print(){cout<<"顶点为：";for(int k=0;k<number;k++)cout<<vexs[k];cout<<endl;for(int i=0;i<number;i++){for(int j=0;j<number;j++)cout<<setw(6)<<left<<arcs[i][j]<<" ";cout<<endl;}for(int m=0;m<number;m++)cout<<visited[m];cout<<endl;}void Mgraph::CreatMGraph()//图的邻接矩阵储存结构{char vex1,vex2;int i,j,k,m;cout<<"请输入定点数，边数："<<endl;cin>>number>>arcnum;cout<<"请输入顶点（字符串类型）："<<endl;for(i=0;i<number;i++)cin>>vexs[i];for(i=0;i<number;i++)for(j=0;j<number;j++)arcs[i][j]=1000;for(k=0;k<arcnum;k++){cout<<"请输入边的两个顶点及边的权值："<<endl; cin>>vex1>>vex2>>m;i=LocateVex(vex1);j=LocateVex(vex2);arcs[i][j]=m;arcs[j][i]=m;}}void Mgraph::DFS(int i=0)//用递归实现{int j;cout<<vexs[i]<<"------>";visited[i]=1;for (j=0;j<number;j++){if(!(arcs[i][j]==1000)&&!visited[j])DFS(j);}}void Mgraph::DFS1(int i=0)//非递归{stack<int> st;st.push(i);while(!st.empty()){int j=st.top();st.pop();cout<<vexs[j]<<"---->";visited[j]=1;for(int k=0;k<number;k++){if((!(arcs[j][k]==1000))&&!visited[k])st.push(k);}}}void Mgraph::BFS(int i=0)//广度优先遍历{deque<int> de;de.push_back(i);cout<<vexs[i]<<"------>";visited[i]=1;while(!de.empty()){int k=de.front();for(int j=0;j<number;j++){if(arcs[k][j]!=1000&&!visited[j]){cout<<vexs[j]<<"------>";visited[j]=1;de.push_back(j);}}de.pop_front();}}int Mgraph::mini(){static int i;int min=0;for (int j=0;j<number;j++){if(!visited[j]){if (closeedge[min].lowcost>closeedge[j].lowcost){min=j;}}}i=min;cout<<"包括边("<<closeedge[i].begvex<<","<<closeedge[i].endvex<<")"; return i;}void Mgraph::prim(){char u;cout<<"请输入起始顶点："<<endl;cin>>u;int i=LocateVex(u);visited[i]=1;for(int j=0;j<number;j++){closeedge[j].begvex=u;closeedge[j].endvex=vexs[j]; closeedge[j].lowcost=arcs[i][j];}for (int m=1;m<number;m++){int n=mini();visited[n]=1;closeedge[n].lowcost=1000;for (int p=0;p<number;p++){if(!visited[p]){if(arcs[p][n]<closeedge[p].lowcost){closeedge[p].lowcost=arcs[p][n];closeedge[p].begvex=vexs[n];}}}}}void Mgraph::kruskal(){int a,b,k=0;int min=1000;int arcs1[20][20];for (int m=0;m<number;m++)visited[m]=m;//每一个顶点属于一颗树for (int i=0;i<number;i++)for(int j=0;j<number;j++)arcs1[i][j]=arcs[i][j];while (k<number-1){min=1000;for (int i=0;i<number;i++){for (int j=0;j<number;j++){if (arcs1[i][j]<min){a=i;b=j;min=arcs1[i][j];}}}if (visited[a]!=visited[b]){cout<<"包括边("<<vexs[a]<<","<<vexs[b]<<")";k++;for (int n=0;n<number;n++){if (visited[n]==visited[b])visited[n]=visited[a];}}elsearcs1[a][b]=arcs[b][a]=1000;}}void Mgraph::Dijkstra(){cout<<"请输入起始点"<<endl;char u;cin>>u;int i=LocateVex(u);visited[i]=1;for (int j=0;j<number;j++){dist[j].dist=arcs[i][j];dist[j].nodenum=0;}for (j=1;j<number;j++){int distance=1000;int min=0;for (int n=0;n<number;n++){if(!visited[n]){if (distance>dist[n].dist){distance=dist[n].dist;min=n;}}}int m=min;visited[m]=1;for (n=0;n<number;n++){if(!visited[n]){if((dist[m].dist+arcs[m][n])<dist[n].dist){dist[n].dist=dist[m].dist+arcs[m][n];dist[n].nodenum=0;for (int x=0;x<dist[m].nodenum;x++){dist[n].way[x]=dist[m].way[x];dist[n].nodenum++;}dist[n].way[dist[n].nodenum++]=vexs[m];} } } }//输出功能for (int n=0;n<number;n++){if (n!=i){ if(dist[n].dist<1000){cout<<vexs[i]<<"到"<<vexs[n]<<"的最近距离为："<<dist[n].dist<<endl;cout<<"经过的顶点为："<<vexs[i]<<"---->";for (int p=0;p<dist[n].nodenum;p++){ cout<<dist[n].way[p]<<"----->";}cout<<vexs[n]<<endl;}elsecout<<vexs[i]<<"到"<<vexs[n]<<"没有通路"<<endl;} } }void Mgraph::Floyd(){int i,j,m,n;for ( i=0;i<number;i++)for ( j=0;j<number;j++)for (m=0;m<number;m++)P[i][j][m]=0;for ( i=0;i<number;i++)for ( j=0;j<number;j++){D[i][j]=arcs[i][j];if(D[i][j]<1000){P[i][j][i]=1;P[i][j][j]=1;} }for ( i=0;i<number;i++)for ( j=0;j<number;j++)for (m=0;m<number;m++){if (i==j||j==m||i==m)continue;if (D[i][m]+D[m][j]<D[i][j]){D[i][j]=D[i][m]+D[m][j];for (n=0;n<number;n++){P[i][j][n]=P[i][m][n]||P[m][j][n];} } }for ( i=0;i<number;i++)for ( j=0;j<number;j++){if (D[i][j]<1000){cout<<vexs[i]<<"到"<<vexs[j]<<"的最近距离为："<<D[i][j]<<endl;cout<<"经过的顶点为：";for (m=0;m<number;m++){if (P[i][j][m]){cout<<vexs[m]<<"------>";} }cout<<endl;}elseif (i!=j)cout<<vexs[i]<<"到"<<vexs[j]<<"没有通路"<<endl;}}int main(){Mgraph g;g.CreatMGraph();g.Floyd();return 0;}四、实验结果五、实验总结本次实验主要是学习掌握图的存储结构，学会编写求最短路径的算法。
求最短路径的实验报告
《求最短路径的实验报告》1.需解决的的问题创建一个网的存储结构，并求最短路径2.数据结构的定义typedef struct{VertexType vexs[MVNum]; //顶点数组，类型假定为char型Adjmatrix arcs[MVNum][MVNum]; //邻接矩阵，类型假定为int型}MGraph;int D1[MVNum],P1[MVNum];int D[MVNum][MVNum],P[MVNum][MVNum];3.程序的结构图4.函数的功能（1）迪杰斯特拉算法void Dijkstra(MGraph *G,int v1,int n){ //用迪杰斯特拉算法求有向图G的v1顶点到其他顶点v的最短路径P[v]和其权D[v] //设G是有向图的邻接矩阵，若边<i,j>不存在，则G[i][j]=Maxint//S[v]为真当且仅当v在S中int D2[MVNum],P2[MVNum];int v,i,w,min;enum boolean S[MVNum];for(v=1;v<=n;v++){//初始化S和DS[v]=FALSE; //设置最短路径终点集D2[v]=G->arcs[v1][v]; //设置初始的最短路径值if(D2[v]<Maxint)P2[v]=v1; //v1是v的前驱elseP2[v]=0; //v无前驱}D2[v1]=0;S[v1]=TURE; //S集初始时只有源点，源点到其自身的距离为0//开始循环，每次求得v1到某个v顶点的最短路径，并加v到S集中for(i=2;i<n;i++){min=Maxint;for(w=1;w<=n;w++)if(!S[w]&&D2[w]<min){ //w顶点离v1顶点更近v=w;min=D2[w];}S[v]=TURE;for(w=1;w<=n;w++) //更新当前最短路径及距离if(!S[w]&&(D2[v]+G->arcs[v][w]<D2[w])){ //修改D2[w]和P2[w]D2[w]=D2[v]+G->arcs[v][w];P2[w]=v;}}printf("路径长度路径\n");for(i=1;i<=n;i++){printf("%5d",D2[i]);printf("%5d",i);v=P2[i];while(v!=0){printf("<-%d",v);v=P2[v];}printf("\n");}}（2）费洛伊德算法void Floyd(MGraph *G,int n){int i,j,k,v,w;for(i=1;i<=n;i++) //设置路径长度D和路径path初值for(j=1;j<=n;j++){if(G->arcs[i][j]!=Maxint)P[i][j]=j; //j是i的后继elseP[i][j]=0;D[i][j]=G->arcs[i][j];}for(k=1;k<=n;k++){ //做k次迭代，每次均试图将顶点k扩充到当前求得的从i到j的最短路径P[i][j]上for(i=1;i<=n;i++)for(j=1;j<=n;j++){if(D[i][k]+D[k][j]<D[i][j]){D[i][j]=D[i][k]+D[k][j]; //修改长度P[i][j]=P[i][k];printf("dij=%d,pij=%d\n",D[i][j],P[i][j]);}}}}5.输入/输出数据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，进入求源点到其他各点的距离操作。
实验11 最短路径问题实验报告
确定起点的最短路径问题，即已知起始结点，求最短路径的问题。适合使用Dijkstra算法。
确定终点的最短路径问题，与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。
确定起点终点的最短路径问题，即已知起点和终点，求两结点之间的最短路径。
return i;
return i;
}
int next(Docu*D , int v , int w)
{
int i;
for(i=w+1 ; i<D->n ; i++)
(D->edge[v][i])!=-1)
return i;
return i;
}
int weight(Docu*D,int v,int w)
for(j=0 ; j<D->n ; j++)
fin>>D->edge[i][j]; //从文件中读取边权值
int start , end;
cout<<"起点:"<<endl;
cin>>start;
cout<<"终点:"<<endl;
cin>>end;
int *B;
B=(int *)malloc(D->n*sizeof(int));
v=i;
return v;
}
void Dijkstra(Docu*D , int *B , int s)
{
int i,v,w;
数据结构实验报告-最短路径
最短路径
--《数据结构实验报告》
1.基本思想
最短路径，顾名思义，就是两个点之间的最短距离。
本实验采用Dijkstra算法和Floyd算法。
Dijkstra算法和Prim算法思想很像，都是一种贪心的算法。
Dijkstra算法只能算出一个点到其他点的最短距离，而Floyd算法一次可以算出各点之间的最短距离。
2.用到的数据结构
邻接矩阵G表示图。
Dijkstra：
数组D[n]表示源点到其他点的最短距离，数组P[n]表示最后经过的上一个顶点。
Floyd：
A[n][n]存放迭代过程中的最短路径长度。
3.基本操作实现
Dijkstra：将V分为两个集合S和V-S，初始D[i]=C[1][i],P[i]=1。
从S外选取一个顶点w，是D[w]最小，于是从源点到达w中通过S中的顶点，且是一条最短路径，w加入S，从原来的D[v]和D[w]+C[w][v]中选择最小值作为D[v]新值，且P[v]=w，重复以上步骤。
Floyd：将每一个顶点都尝试着插入到两个顶点之间，若插入之后得到的路径长度小于插入之前，则保留插入点，将每一个点都尝试插入，得到最终的最短路径。
4.测试数据及测试结果
Dijkstra:
测试数据：
测试结果：
(输入节点，下面输出这个节点到源点0的最短路径)
Floyd：
测试数据：
测试数据：
生成的距离矩阵。
最短路径实验报告
一、实验目的学习掌握图的存储结构利用最短路径算法，通过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中的元素必须为整数。
最短路径问题实验报告
徐州工程学院管理学院实验报告实验课程名称：最短路径问题实验地点：南主楼七楼机房经济管理实验中心 2015 年 5 月至 2015 年 6 月}，ｎ；之间最短路时,每次都要计算i V 经过节点r V 到达点j V 的路长不会比原来的短,于是不用再计(1)1k k ir rjd d --+,进入下一个节点的搜索。
对于问题(2),构造一个序号矩阵()()k k ij A a =，(0,1,)k =，记录算法第二步中第ｋ次迭代插入节点的情况.优化后的Floyd 算法(记为算法2)如下:第一步，作初始距离矩阵(0)(0)()ij D d =和序号矩阵(0)0)()ij A a =（，其中：(0),,(,1,2,3,),ij ij W i j d i j n i j ⎧==⎨∞⎩相邻对，，不相邻或无路时， (0)0,,,1,2,,,ij i j a i j n i j ⎧==⎨Φ⎩相邻时，（），不相邻或无路， 此时距离矩阵(0)D 中的元素(0)ij d 表示任意两点i V 、j V 不经过其它节点的路长。
第二步,构造迭代矩阵()()()k k ij D d =和序号矩阵(0))()k ij A a =（。
① 对于迭代矩阵()k D 的元素()k ij d : r 从1到n ,且,r i j ≠时,如果(1)(1)k k ir ijd d --≥或(1)(1)k k ri ij d d --≥,说明插入点r V 后路长(1)k ij d -不会变短,此时无须计算(1)1k k ir rjd d --+。
否则{}()(1)(1)(1)min ,k k k k ij ij ir rj d d d d ---=+。
② 相应地,序号矩阵()k A 的各元素变化为:若()(1)(1)k k k ij il lj d d d --=+,且(1)(1)k k ir rjd d --<,则记下点l V ,并在序号矩阵中()k A 对应的元素)k ij a （变为:{}()(1)(1),,k k k ij il l lj a a V a --=。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
东华大学计算机学院离散数学
实验五：最短路径
实验所属系列：离散数学课后实验
实验对象：本科
相关课程及专业：离散数学，计算机专业
实验类型：课后实验
实验时数（学分）：4学时
实验目的
学习图的最短路径算法的实现。
实验内容与要求
根据输入的图形（实验四），输入起点和终点，求出最短路径和最短路径的长度。
实验的软硬件环境
PC机一台，装有VC++6.0或其它C语言集成开发环境。
实验准备
熟悉最短路径算法。
实验步骤
1．编写一段代码，接收键盘的输入定点的数量，并以输入的整数对作为边来建立图形的邻接矩阵（无向权重图）。
例如：5，6，12
表示定点5和定点6间有边，边的权重为12。
2 打印出邻接矩阵。
3．输入起点和终点。
4、打印最短路径和最短路径的长
#include<stdio.h>
#define BIG 9999
void dijkstra(int cost[][6],int n,int st,int distance[])
{
int s[6];
int mindis,dis;
int i,j,u;
for(i=0;i<n;i++)
{
distance[i]=cost[st][i];
s[i]=0;
}
s[st]=1;
for(i=0;i<n;i++)
{
mindis=BIG;
for(j=0;j<n;j++)
{
if(s[j]==0&&distance[j]<mindis)
{
mindis=distance[j];
u=j;
}
}
for(j=0;j<n;j++)
{
if(s[j]==0)
{
dis=distance[u]+cost[u][j];
distance[j]=(distance[j]<dis)?distance[j]:dis;
}
}
s[u]=1;
}
}
void main()
{
int y,j;
char *vertex[6]={"V1","V2","V3","V4","V5","V6"};
int cost[6][6];
for(y=0;y<6;y++)
{
for(j=0;j<6;j++)
{
cost[y][j]=BIG;
}
}
int start,end,weight,i;
printf("input start&end&weight:");
for(i=0;weight!=0;i++)
{
scanf("%d,%d,%d",&start,&end,&weight);
cost[start-1][end-1]=weight;
cost[end-1][start-1]=weight;
}
int distance[6];
int s,e;
printf("input start-vertex &&end-vertex(no more than 6):");
scanf("%d,%d",&s,&e);
dijkstra(cost,6,s-1,distance);
printf("%s---->%s %d\n",vertex[s-1],vertex[e-1],distance[e-1]);
}
数据测试
输入：
1，3，5
1，4，30
2，1，2
3，2，15
3，6，7
5，4，4
6，4，10
6，5，18
计算1，5两点之间距离
输出：。