Dijkstra算法的实现-数据结构与算法课程设计报告
Dijkstra算法原理详细讲解
Dijkstra算法原理详细讲解
Dijkstra算法是图论中的一种贪心算法，用于求解最短路径问题。
该算法的贪心策略是：每次选择当前距离起点最近的节点作为中间节点，并更新起点到其它节点的距离。
通过不断选择距离起点最近的节点，并逐步更新起点到各个节点的距离，最终得到起点到终点的最短路径。
Dijkstra算法的具体实现包括以下几个步骤：
1. 初始化：将起点到各个节点的距离记为无穷大或者一个较大的值，将起点到自己的距离记为0。
2. 选择当前距离起点最近的节点作为中间节点。
这个过程可以通过维护一个距离起点最近的节点集合来实现，初始时集合中只包含起点。
3. 更新起点到与中间节点相邻的节点的距离，即对于每个与中间节点相邻的节点，如果从起点到中间节点的距离加上中间节点到该节点的距离小于起点到该节点的距离，则更新起点到该节点的距离为从起点到中间节点的距离加上中间节点到该节点的距离。
4. 重复步骤2和步骤3，直到起点到终点的距离不再更新。
5. 最终得到起点到终点的最短路径。
Dijkstra算法的时间复杂度为O(N^2)，其中N为节点的数目。
如果使用优先队列来维护距离起点最近的节点集合，则算法的时间复杂度可以降为O(NlogN)，但是实际应用中优先队列的实现可能较为复杂。
Dijkstra算法可以用于有向图和无向图，但是不能处理带有负权边的图。
如果图中存在负权边，则可以使用Bellman-Ford算法来求解最短路径。
dijkstra算法代码实现
dijkstra算法代码实现Dijkstra算法是用来求解单源最短路径问题的一种贪心算法。
下面是Dijkstra算法的代码实现：```import sys# 定义一个类来保存图的节点和边的信息class Node:def __init__(self, name): = nameself.visited = Falseself.distance = sys.maxsizeself.adjacent_nodes = []self.previous_node = None# Dijkstra算法的实现函数def dijkstra(start_node):start_node.distance = 0unvisited_nodes = [start_node]while unvisited_nodes:current_node = unvisited_nodes[0]for neighbor in current_node.adjacent_nodes:if not neighbor.visited:new_distance = current_node.distance +neighbor.distanceif new_distance < neighbor.distance:neighbor.distance = new_distanceneighbor.previous_node = current_nodecurrent_node.visited = Trueunvisited_nodes.remove(current_node)unvisited_nodes.sort(key=lambda node: node.distance)# 测试nodeA = Node("A")nodeB = Node("B")nodeC = Node("C")nodeD = Node("D")nodeE = Node("E")nodeF = Node("F")nodeA.adjacent_nodes = [(nodeB, 10), (nodeC, 15)]nodeB.adjacent_nodes = [(nodeD, 12), (nodeF, 15)]nodeC.adjacent_nodes = [(nodeE, 10)]nodeD.adjacent_nodes = [(nodeE, 2), (nodeF, 1)]nodeF.adjacent_nodes = [(nodeE, 5)]dijkstra(nodeA)print(nodeE.distance)```在上面的代码中，我们定义了一个`Node`类用来保存节点的信息，包括节点的名称、是否已访问、距离起始节点的距离、相邻节点和前置节点等。
Dijkstra算法描述
Dijkstra算法描述目录一、算法概述1二、算法原理及计算12.1算法原理12.2计算过程22.3改良的算法〔Dijkstra-like〕分析5三、源码分析6四、接口调用7一、算法概述Dijkstra〔迪杰斯特拉〕算法是典型的单源最短路径计算算法，用于解决源点到所有结点最短路径计算的问题，它采用了分治和贪心〔动态规划的特殊形式〕的思想搜索全局最优解。
本系统采用了主流、开源的JAVA图论库——Jgrapht来解决源点到终点间所有可能路径输出的问题，它的核心计算引擎采用了一种Dijkstra-like算法，由经典的Dijkstra〔迪杰斯特拉〕算法演化和改良而来。
二、算法原理及计算2.1算法原理Dijkstra算法思想为：设(,)= 是带权有向图，V代表图中顶点集合，E代G V E表图中含权重的边集合。
将全部顶点集合V分成两组，第一组为已求出最短路径的顶点集合，用S表示〔初始时S中只有一个源点，以后每求得一条最短路径，就将该路径的终点参加到集合S中〕；第二组为其余待确定最短路径的顶点集合，用U表示。
按最短路径长度的递增次序依次把U集合的顶点逐个参加到S集合中，约束条件是保持从源点v到S中各顶点的最短路径长度不大于从源点v到U 中任何顶点的最短路径长度。
算法的终止条件是集合U为空集，即集合U的顶点全部参加到集合S中。
2.2计算过程以图1为例讨论Dijkstra算法的计算过程，即计算某源点到网络上其余各结点的最短路径，设源点为①，逐步搜索，每次找出一个结点到源点①的最短路径，直至完成所有结点的计算。
图1 带权有向图记()D v为源点①到某终点v的距离，是源点①到终点v某条路径的所有链路长度之和。
记(,)l w v 是源点w到终点v的距离。
Dijkstra算法归纳如下：S=，U是其余未确〔1〕初始化，令S是已求出最短路径的顶点集合，{}U=，可写出：定最短路径的顶点集合，{}(1,)()l v D v ⎧=⎨∞⎩(1-1) 公式1-1中，(1,)l v 是源点①与终点v 的直连路径长度，而∞代表源点①与终点v 不相连,初始化结果如表1所示；〔2〕遍历集合U 中的所有结点v 并计算[]min (),()(,)D v D w l w v + 。
dijkstra算法代码实现
Dijkstra算法是一种用于解决单源最短路径问题的经典算法，由荷兰计算机科学家艾兹赫尔·迪克斯特拉在1956年提出。
该算法主要用于计算一个顶点到其余各个顶点的最短路径。
Dijkstra算法的基本思想是：假设图G中顶点集合为V，边集合为E，从源点s开始，初始时只有s的已知最短路径，用集合S记录已找到最短路径的顶点。
利用S中顶点的最短路径来更新其余顶点的最短路径，直到找到从s到其余所有顶点的最短路径。
Dijkstra算法具体实现过程如下：1. 创建两个集合，一个用来保存已找到最短路径的顶点集合S，另一个用来保存未找到最短路径的顶点集合V-S。
2. 初始化距离数组dist[]，将源点到各个顶点的距离初始化为无穷大，源点到自身的距离初始化为0。
3. 从源点s开始，将s加入S集合，更新源点到其余各个顶点的距离，如果存在边(u,v)，使得dist[v] > dist[u] + w(u,v)，则更新dist[v] = dist[u] + w(u,v)，其中w(u,v)表示边(u,v)的权值。
4. 重复第3步，直到将所有顶点加入S集合为止，此时dist数组即为源点到各个顶点的最短路径。
根据以上实现思路，我们可以使用代码来实现Dijkstra算法。
以下是Python语言的Dijkstra算法实现示例：```pythondef dijkstra(graph, src):dist = [float('inf')] * len(graph)dist[src] = 0visited = [False] * len(graph)for _ in range(len(graph)):u = min_distance(dist, visited)visited[u] = Truefor v in range(len(graph)):if graph[u][v] > 0 and not visited[v] and dist[v] > dist[u] + graph[u][v]:dist[v] = dist[u] + graph[u][v]print_solution(dist)def min_distance(dist, visited):min_dist = float('inf')min_index = -1for v in range(len(dist)):if dist[v] < min_dist and not visited[v]:min_dist = dist[v]min_index = vreturn min_indexdef print_solution(dist):print("顶点\t最短距离")for i in range(len(dist)):print(f"{i}\t{dist[i]}")```在上面的示例代码中，我们首先定义了一个dijkstra函数，该函数接受图的邻接矩阵表示和源点的索引作为参数。
路由算法中的Dijkstra算法实现原理
路由算法中的Dijkstra算法实现原理路由算法是计算机网络中的一项重要技术，它指导着数据在网络中的传输过程。
路由算法中的Dijkstra算法是其中一种比较常用的算法，它通过计算最短路径来选择数据传输方案，进而实现高效稳定的数据传输。
本文将详细介绍Dijkstra算法的实现原理。
一、Dijkstra算法的概述Dijkstra算法是一种用于计算带权图最短路径的算法。
它的基本思想是：维护一个当前已知的最短路径集合S和距离源点最短的节点v，然后以v为基础扩展出一些新的节点，并计算这些节点到源点的距离并更新路径集合S。
重复这一过程，一直到源点到所有节点的最短路径集合已经确定为止。
该算法求解的是一个有向带权图中一个节点到其他所有节点的最短路径问题，其中「带权」表示图的边权值是一个非负实数。
二、Dijkstra算法的实现Dijkstra算法可以使用多种数据结构的实现，常见的有数组、链表、堆等。
这里我们以使用优先队列为例进行实现。
首先，定义一个数组distance用于存储源点至所有节点的最短距离。
初始状态下，将源点与其它节点的距离初始化为正无穷大。
同时，构建一个优先队列，用于维护已经遍历过的节点。
具体实现过程如下：1. 初始化distance数组和优先队列。
将源点源加入优先队列中，与源点相邻的节点按照距离增序加入队列中。
2. 从队列中取出距离源点最短的节点u，然后遍历所有与节点u相邻的节点v。
通过计算distance[u] + w(u,v)可得到源点到节点v的距离。
如果这个距离比已经存储在distance[v]中的距离更短，则更新distance[v]的值，同时将节点v加入到优先队列中。
3. 重复步骤2，直到所有节点都已经加入到队列中，并且所有节点的最短路径都已经被确定。
三、Dijkstra算法的时间复杂度分析Dijkstra算法的时间复杂度主要取决于寻找当前距离源点最短的节点的过程。
如果使用数组实现，该过程的时间复杂度为O(n^2)，n为节点数量。
数据结构与算法课程设计报告---图的算法实现
数据结构与算法课程设计报告课程设计题目：图的算法实现专业班级：信息与计算科学1002班目录摘要 (1)1、引言 (1)2、需求分析 (1)3、概要设计 (2)4、详细设计 (4)5、程序设计 (10)6、运行结果 (18)7、总结体会 (19)摘要(题目): 图的算法实现实验内容图的算法实现问题描述：（1）将图的信息建立文件；（2）从文件读入图的信息，建立邻接矩阵和邻接表；（3）实现Prim、Kruskal、Dijkstra和拓扑排序算法。
关键字:邻接矩阵、Dijkstra和拓扑排序算法1.引言本次数据结构课程设计共完成图的存储结构的建立、Prim、Kruskal、Dijkstra 和拓扑排序算法等问题。
通过本次课程设计，可以巩固和加深对数据结构的理解，通过上机和程序调试，加深对课本知识的理解和熟练实践操作。
（1）通过本课程的学习，能够熟练掌握数据结构中图的几种基本操作；（2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
使用语言：CPrim算法思想：从连通网N={V,E}中的某一顶点v0出发，选择与它关联的具有最小权值的边(v0,v)，将其顶点加入到生成树的顶点集合V中。
以后每一步从一个顶点在V中，而另一个顶点不在V中的各条边中选择权值最小的边(u,v),把它的顶点加入到集合V中。
如此继续下去，直到网中的所有顶点都加入到生成树顶点集合V中为止。
拓扑排序算法思想：1、从有向图中选取一个没有前驱的顶点，并输出之；2、从有向图中删去此顶点以及所有以它为尾的弧；重复上述两步，直至图空，或者图不空但找不到无前驱的顶点为止。
没有前驱-- 入度为零，删除顶点及以它为尾的弧-- 弧头顶点的入度减1。
2.需求分析1、通过键盘输入建立一个新的有向带权图，建立相应的文件；2、对建立的有向带权图进行处理，要求具有如下功能：（1）用邻接矩阵和邻接表的存储结构输出该有向带权图，并生成相应的输出结果；（2）用Prim、Kruskal算法实现对图的最小生成树的求解，并输出相应的输出结果；（3）用Dijkstra算法实现对图中从某个源点到其余各顶点的最短路径的求解，并输出相应的输出结果；（4）实现该图的拓扑排序算法。
dijkstrafloyd课程设计
dijkstra floyd课程设计一、课程目标知识目标：1. 理解Dijkstra算法与Floyd算法的基本原理，掌握它们在不同图中的应用和求解最短路径的方法。
2. 学会分析算法的时间复杂度，理解它们在不同规模问题中的效率差异。
3. 掌握运用Dijkstra算法与Floyd算法解决实际问题的能力，如地图导航、网络路由等。
技能目标：1. 能够运用Dijkstra算法在加权图中找到单一源点到其他各顶点的最短路径。
2. 能够运用Floyd算法在加权图中找到所有顶点对之间的最短路径。
3. 能够根据实际问题选择合适的算法进行求解，并进行算法分析与优化。
情感态度价值观目标：1. 培养学生对算法学习的兴趣，激发他们探究问题、解决问题的热情。
2. 培养学生团队合作意识，学会在讨论与交流中取长补短，共同进步。
3. 增强学生的逻辑思维能力，使他们认识到算法在解决实际问题中的重要作用，提高对计算机科学的认识。
课程性质：本课程为计算机科学领域的数据结构与算法内容，以Dijkstra算法与Floyd算法为主题，旨在帮助学生掌握图论中的最短路径算法，提高解决实际问题的能力。
学生特点：学生处于高年级阶段，已具备一定的数据结构与算法基础，具有较强的逻辑思维能力和自主学习能力。
教学要求：在教学过程中，注重理论与实践相结合，通过案例分析和实际操作，使学生更好地理解和掌握算法原理，提高解决实际问题的能力。
同时，注重培养学生的团队合作意识和情感态度价值观。
二、教学内容1. 图的基本概念复习：图的定义、分类、邻接矩阵和邻接表表示方法。
2. 最短路径问题介绍：最短路径的定义、单源最短路径与多源最短路径问题的区别。
3. Dijkstra算法：- 算法原理讲解与示例演示- 代码实现与调试- 时间复杂度分析- 应用案例分析4. Floyd算法：- 算法原理讲解与示例演示- 代码实现与调试- 时间复杂度分析- 应用案例分析5. 算法比较与优化：- Dijkstra算法与Floyd算法在不同类型图中的应用比较- 算法优化方法介绍（如堆优化、动态规划优化等）6. 实践项目：- 设计并实现一个基于Dijkstra算法或Floyd算法的地图导航系统- 完成相应的测试用例，验证算法的正确性7. 总结与拓展：- 对比分析两种算法的优缺点- 探讨其他最短路径算法及其应用教学内容依据课程目标进行编排，结合教材章节进行详细讲解。
Dijkstra算法步骤详述
Dijkstra算法步骤详述Dijkstra算法是一种经典的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。
本文将详细介绍Dijkstra算法的步骤和实现。
1. 初始化首先，我们需要将算法的输入进行初始化。
假设我们有一个带权重的有向图，其中节点集合为V，边的集合为E。
对于每个节点v ∈ V，我们设置初始距离d[v]为正无穷大(INF)，表示从起点到节点v的距离为无穷大；同时，我们设置起点s的初始距离d[s]为0，表示从起点到自身的距离为0。
2. 确定最短路径接下来，我们将在图中逐步确定起点到其他节点的最短路径。
首先，我们从起点s开始，将s标记为当前节点。
然后，对于s的所有邻居节点v，我们更新其当前最短路径，并标记v为下一个当前节点。
这一步骤可以通过以下过程实现：a. 对于节点s的所有邻居节点v，计算通过s到达v的距离。
如果该距离小于d[v]，则将d[v]更新为该距离，并将s作为节点v的前驱节点（即最短路径上v的前一个节点）。
b. 从剩余的未标记节点中选择一个距离最短的节点作为下一个当前节点。
具体而言，从未标记节点中选择一个节点u，使得d[u]最小，并将其标记为当前节点。
3. 更新最短路径在上一步中，我们确定了起点到一个节点的最短路径。
现在，我们将以已选择的当前节点继续执行第2步，直到所有节点都被标记为止。
具体而言，重复进行以下步骤：a. 在当前节点的所有邻居节点中，更新其最短路径并选择下一个当前节点，过程与第2步相同。
b. 如果不存在未标记节点，则算法终止。
4. 输出最短路径当算法终止时，我们可以得到从起点到达所有节点的最短路径。
对于每个节点v，最短路径可以通过回溯每个节点的前驱节点得到。
具体而言，从目标节点开始，通过前驱节点一直回溯到起点，即可得到最短路径。
总结：Dijkstra算法通过逐步确定起点到其他节点的最短路径，从而找到整个图中的最短路径。
它的步骤包括初始化、确定最短路径和更新最短路径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
合肥学院计算机科学与技术系课程设计报告2009 ～2010 学年第2 学期课程数据结构与算法课程设计名称Dijkstra算法的实现学生姓名张睿辰学号0804012044专业班级08计科(2)班指导教师王昆仑张贯虹2010 年6月Dijkstra算法的实现一、问题分析与任务定义1、课程设计题目：1.1题目：对任意图，选择合适的数据结构表示图，在此基础上实现求解最短路径的Dijkstra算法1.2 要求：设计合理的数据结构存储图，简单有效的实现Dijkstra算法。
1.3具体任务：建立图的存储模块，建立图的输出模块，在建图后从单源点开始求最短路径，并显示出来！2、原始数据的输入格式：2.1建图模块：2.1.1数字2.2.2数字+空格+数字+空格+数字+回车2.3显示模块：回车3、实现功能：3.1 建立有向图3.2 显示存储的有向图3.3 显示从顶点到其他各顶点的最短路径4、测试用例：4.1正确数据：a）顶点：3；边值信息：0 1 6；0 2 4；1 2 5；2 0 6；0 0 0；b）顶点：0；边值信息：0 0 0；输出结果：a) v0到v1的最短路径是6，v0到v2的最短路径是4b) 没有最短路径4.2错误数据：a) 顶点：ab）顶点：2；边值信息：0 3 6；0 4 4；13 5；0 0 0；c）顶点：3；边值信息：0 1 a；输出结果：边值错误，请从新输入5、问题分析：实现本程序要解决以下几个问题：5.1如何存储一个有向图。
5.2如何在界面中输出该有向图。
5.3如何定义起始源点。
5.4如何选择出最短路径。
5.5找到的最短路径如何输出。
二、数据结构的选择和概要设计1、数据结构的选择：在图的结构中，任意两个顶点之间都可能存在关系，比线性表和树要复杂。
由于不存在严格的前后顺序，因而不能采用简单的数组来存储图;另一方面，如果采用链表，由于图中各顶点的度数不尽相同，最小度数和最大度数可能相差很大，如果按最大度数的顶点来设计链表的指针域，则会浪费很多存储单元，反之，如果按照各个顶点设计不同的链表结点，则会给操作带来很大的困难。
在此我选用邻接矩阵的存储结构。
采用邻接矩阵存储，很容易判断图中两个顶点是否相连，也容易求出各个顶点的度。
不过任何事情都不是完美的，采用邻接矩阵存储图时，测试其边的数目，必须检查边二维数组的所有元素，时间复杂度为O （n 2）,这对于顶点很多而边较少的图（稀疏图）是非常不合算的。
以邻接矩阵存储有向图，如图1中有向图G 所示，其邻接矩阵为图 2 cost 。
图2. 有向图 图2.矩阵cost有向图的邻接矩阵cost[i][j]定义为int cost [n][n]; 2、 概要设计2.1对于最短路径问题：最短路径是在实际应用中非常有用的工具，我们常见的两种最短路径是： （1）从某源点到其余各顶点之间的最短路径。
（2）每一段顶点之间的最短路径在这里我们解决第一类问题。
2.2 Dijkstra 算法用于求最短路径：Dijkstra 算法是按路径长度递增的次序逐步产生源点到其他顶点间的最短路径。
算法建立一个顶点集合S ，初始时该集合只有源点V0，然后逐步将已求得最短路径的顶点加入到集合中，直到全部顶点都在集合S 中，算法结束。
2..3 Dijkstra 算法思想设cost[i,j]=0，S 为已经求得最短路径的顶点集合，distance[i]数组的每个元素表示当前状态下源点V0到Vi 的最短路径。
算法如下： 1) 初始化：S={V0}, distance[i]=cost[0,i]。
2) 选择一个终点Vj ，满足distance[j]=MIN{ distance[i]|Vi ∈V-S}。
3）把Vj 加入到S 中。
4）修改distance 数组元素，修改逻辑为对于所有不在S 中的顶点Vi.20 0 50 10 ∞ 45∞ 0 15 50 10∞ 20 0 ∞ ∞ ∞ ∞ 15 ∞ 20 ∞ 0 35 ∞ ∞ ∞ ∞ 30 0∞ 0∞ 3 ∞ ∞ ∞if(distance[j]+cost[i,j]< distance[i]) { distance[i]= distance[j] ]+cost[i,j] }5)重复操作2）、3）、4），直到全部顶点加入到S中。
2.4 实现流程在任意图中实现求最短路径问题，第一步是要能成功的在内存中输入图的信息，图的信息有两个，一是顶点个数，二是每两点之间的权值信息。
当建立图之后，对图进行遍历才能使用Dijkstra算法求出最短路径；在完成了图的建立之后，用Dijkstra 算法的思想，从单源点开始，求出到各个顶点的最短路径，并能够实现显示功能。
程序流程图：Dijkstra算法流程图：三、详细设计和编码3.1邻接矩阵的定义：我们定义全局变量cost[][],dist[]数组，方便在各子程序中的调用，加快了程序的运行速度。
int cost[MAX][MAX];int dist[MAX];int n;cost二维数组用于存放邻接矩阵，每个位置代表的值为图中的权值，其余用无穷大999表示。
dist为辅助数组，图中每个顶点对应该数组中的一个元素，这个元素存放当前源点到该顶点的最短路径。
此时的路径指示当前结果，并不一定是最终的最短路径。
随着集合S的变化，其他顶点不断地加入到集合中，可能以这些新加入的顶点为“桥梁”产生比以前路径更短的路径，dist数组元素的值是动态变化的。
n是指图中的顶点数目。
3.2结点结构体的定义：struct{int num;int pnode[MAX];}path[MAX];整型变量num是用来记录求V0到每个顶点的最短路径时所经过的顶点的数目。
数组pnode用来存放求V0到每个顶点的最短路径时所经过的顶点，初始为V0。
结构体数组path为从V0到各顶点的最短路径。
3.3创建带权有向图初始化邻接矩阵cost中的值为无穷大，即任意两个顶点之间不存在路径。
首先输入该有向图的顶点数n,然后依次输入各个顶点及边长（输入的顶点的序号应该小于顶点的数目）。
输入0 0 0结束。
定义变量contin，标志输入是否结束。
若contin=1，输入继续，若contin=0，输入完成。
代码：void creatgraph() //创建带权有向图{int i,j,s,e,len,contin=1;printf("\n请输入顶点个数:");scanf("%d",&n);for(i=0;i<n;i++){for(j=0;j<n;j++){cost[i][j]=up;cost[j][i]=up; //初始化所有顶点间的边值均为无穷大}cost[i][i]=0; //每个顶点到自己的边值为0}printf("输入各边，以0，0，0表示结束:\n");i=1; //标志边的数目while(contin==1){printf("\t第%d条边->顶点，顶点，边长:",i);scanf("%d%d%d",&s,&e,&len);if(s==0 && e==0 && len==0)contin=0;else if(s>=0 && s<n && e>=0 && e<n && len>0) //输入的顶点的序号应该小于顶点的数目{cost[s][e]=len;i++;}elseprintf("\t\t边值错误，重复输入!\n");}display(n);//输出所建数组getchar();}3.4邻接矩阵的显示在图的邻接矩阵显示中，分别利用for循环输出了矩阵的行列标，使矩阵很明了。
代码：void display(int n1){int i,j;printf("\n******************************所建图的邻接矩阵**********************************\n");for(i=0;i<n1;i++)printf("_______%d________",i); //利用for循环输出邻接矩阵的行标printf("\n");for(i=0;i<n1;i++){printf("%d",i); //利用for循环输出邻接矩阵的列标for(j=0;j<n1;j++)printf("\t%3d<%d,%d>",cost[i][j],i,j);printf("\n");}}3.5 Dijkstra 求最短路径的实现设图以邻接矩阵cost存储，矩阵中各元素的值为各边的权值。
顶点间无边时其对应权值用无穷大表示。
从顶点V0到其它各顶点间的最短路径的具体步骤如下：a)变量定义：定义整型数组S[],这是一个顶点集合，初始时该集合只有源点v0，然后逐步将以求得最短路径的顶点加入到该集合中，直到全部顶点都在集合S中，算法结束。
定义两个整型变量dis、mindis均用来标志图中最短的那一条路径。
b)初始化：初始化dist数组的值即为cost数组中存放的权值。
dist[i]=cost[v0][i]初始化求到每个顶点的最短路径时都经过v0顶点。
path[i].pnode[0]=v0初始化记录经过的顶点数都为0。
path[i].num=0;初始化顶点集合s为空，即还未开始。
s[i]=0;c)源点的选择:将v0顶点加入到顶点集合s中。
s[v0]=1d)利用for循环选择一个终点Vj,使其满足V0到Vj距离最短，同时将Vj加入集合S中。
e)根据j顶点调整当前的最短路径，若满足dist[i]> dist[j]+cost[j][i],则修改dist[i]的值。
同时V0到Vi的最短路径中经过的顶点数加1，即path[i].num++; 并将经过的顶点存入数组pnode即path[i].pnode[path[i].num]=jf)此时一趟求最短路径完毕，将终点V1添加到路径中。
g)循环执行d),e),f)操作，直到全部顶点加入到S中。
代码：void shortdjs() //求最短路径{int s[MAX];int mindis,dis,i,j,v0=0,u=0; //mindis标志图中最短的那一条路径for(i=0;i<n;i++)//初始化{dist[i]=cost[v0][i];path[i].pnode[0]=v0;path[i].num=0;s[i]=0;}s[v0]=1;for(i=1;i<n;i++)//将最短路径定点加入到s中{mindis=up;for(j=1;j<n;j++) //查找当前的最短路径if(s[j]==0 && dist[j]<mindis){u=j;mindis=dist[j];}s[u]=1;for(j=1;j<n;j++)//根据j定点调整当前的最短路径if(s[j]==0){dis=dist[u]+cost[u][j];if(dist[j]>dis){dist[j]=dis;path[j].num++;path[j].pnode[path[j].num]=u;}}path[i].num++;path[i].pnode[path[i].num]=i;}}3.6最短路径的输出这段函数主要运用for循环，依次输出V 0到Vi的最短长度与最短路径。