最短路算法
多源最短路算法
多源最短路算法多源最短路算法是指在图中找出多个起点到各个终点的最短路径的算法。
它是单源最短路算法的扩展，单源最短路算法只能求出一个起点到所有终点的最短路径，而多源最短路算法可以求出多个起点到所有终点的最短路径。
一、问题描述在一个有向带权图中，给定多个起点和终点，求每个起点到每个终点的最短路径。
二、常见算法1. Floyd算法Floyd算法是一种基于动态规划思想的多源最短路算法。
它通过不断地更新两个顶点之间的距离来得到任意两个顶点之间的最短路径。
Floyd 算法时间复杂度为O(n^3)，空间复杂度为O(n^2)。
2. Dijkstra算法Dijkstra算法是一种单源最短路算法，但可以通过对每个起点运行一次Dijkstra算法来实现多源最短路。
Dijkstra算法时间复杂度为O(ElogV)，空间复杂度为O(V)。
3. Bellman-Ford算法Bellman-Ford算法是一种解决带负权边图上单源最短路径问题的经典动态规划算法。
通过对每个起点运行一次Bellman-Ford算法来实现多源最短路。
Bellman-Ford算法时间复杂度为O(VE)，空间复杂度为O(V)。
三、算法实现1. Floyd算法实现Floyd算法的核心思想是动态规划，即从i到j的最短路径可以通过i到k的最短路径和k到j的最短路径来得到。
因此，我们可以用一个二维数组dis[i][j]表示从i到j的最短路径长度，初始化为图中两点之间的距离，如果两点之间没有边相连，则距离为INF（无穷大）。
然后，我们用三重循环遍历所有顶点，每次更新dis[i][j]的值。
代码如下：```pythondef floyd(graph):n = len(graph)dis = [[graph[i][j] for j in range(n)] for i in range(n)]for k in range(n):for i in range(n):for j in range(n):if dis[i][k] != float('inf') and dis[k][j] != float('inf'):dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j])return dis```2. Dijkstra算法实现Dijkstra算法是一种贪心算法，它通过不断地选择当前起点到其他顶点中距离最小的顶点来更新最短路径。
最短路问题(整理版)
最短路问题(short-path problem)若网络中的每条边都有一个权值值(长度、成本、时间等)，则找出两节点(通常是源节点与结束点)之间总权和最小的路径就是最短路问题。
最短路问题是网络理论解决的典型问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。
最短路问题，我们通常归属为三类：单源最短路径问题（确定起点或确定终点的最短路径问题）、确定起点终点的最短路径问题（两节点之间的最短路径）1、Dijkstra算法：用邻接矩阵a表示带权有向图，d为从v0出发到图上其余各顶点可能达到的最短路径长度值，以v0为起点做一次dijkstra，便可以求出从结点v0到其他结点的最短路径长度代码：procedure dijkstra（v0：longint）；//v0为起点做一次dijkstrabegin//a数组是邻接矩阵，a[i,j]表示i到j的距离，无边就为maxlongintfor i:=1 to n do d[i]:=a[v0,i];//初始化d数组（用于记录从v0到结点i的最短路径）， fillchar(visit,sizeof(visit),false);//每个结点都未被连接到路径里visit[v0]:=true;//已经连接v0结点for i:=1 to n-1 do//剩下n-1个节点未加入路径里；beginmin:=maxlongint;//初始化minfor j:=1 to n do//找从v0开始到目前为止，哪个结点作为下一个连接起点（*可优化） if (not visit[j]) and (min>d[j]) then//结点k要未被连接进去且最小begin min:=d[j];k:=j;end;visit[k]:=true;//连接进去for j:=1 to n do//刷新数组d，通过k来更新到达未连接进去的节点最小值，if (not visit[j]) and (d[j]>d[k]+a[k,j]) then d[j]:=a[k,j]+d[k];end;writeln(d[n]);//结点v0到结点n的最短路。
最短路问题的求解方法
最短路问题的求解方法最短路问题是图论中一个经典的问题，它在实际生活中有着广泛的应用，比如在交通规划、网络通信、物流配送等领域都有着重要的作用。
在解决最短路问题时，我们通常会采用不同的算法来求解，本文将介绍几种常见的最短路求解方法。
首先，我们来介绍最简单的最短路求解方法——暴力法。
暴力法的思路是枚举所有可能的路径，并找出其中的最短路。
虽然暴力法在理论上是可行的，但在实际应用中，由于其时间复杂度较高，往往不适用于大规模的图。
因此，我们需要寻找更加高效的算法来解决最短路问题。
其次，我们可以考虑使用迪杰斯特拉算法（Dijkstra algorithm）来求解最短路问题。
迪杰斯特拉算法是一种贪心算法，它通过不断地选择距离起点最近的顶点，并更新其邻居顶点的距离，来逐步求解最短路。
迪杰斯特拉算法的时间复杂度为O(V^2)，其中V表示顶点的个数。
这使得它在实际应用中具有较高的效率，尤其适用于稠密图的求解。
除了迪杰斯特拉算法外，我们还可以使用弗洛伊德算法（Floydalgorithm）来解决最短路问题。
弗洛伊德算法采用动态规划的思想，通过不断更新图中任意两点之间的最短路径长度，来逐步求解整个图的最短路。
弗洛伊德算法的时间复杂度为O(V^3)，因此在大规模图的求解中也具有较高的效率。
除了上述算法外，我们还可以考虑使用A算法、贝尔曼-福特算法等其他算法来解决最短路问题。
这些算法各有特点，适用于不同类型的图和不同的应用场景。
总的来说，最短路问题是一个重要且经典的问题，在实际应用中有着广泛的应用。
在求解最短路问题时，我们可以根据具体的情况选择合适的算法来求解，以提高效率和准确性。
希望本文介绍的几种最短路求解方法能够对读者有所帮助，谢谢阅读！。
最短路算法
最短路径在一个无权的图中，若从一个顶点到另一个顶点存在着一条路径，则称该路径长度为该路径上所经过的边的数目，它等于该路径上的顶点数减1。
由于从一个顶点到另一个顶点可能存在着多条路径，每条路径上所经过的边数可能不同，即路径长度不同，把路径长度最短（即经过的边数最少）的那条路径叫作最短路径或者最短距离。
对于带权的图，考虑路径上各边的权值，则通常把一条路径上所经边的权值之和定义为该路径的路径长度或带权路径长度。
从源点到终点可能不止一条路径，把带权路径长度最短的那条路径称为最短路径，其路径长度（权值之和）称为最短路径长度或最短距离。
最短路径算法Dijkstra算法：该算法是用于求解单源点最短路径的实用算法。
Dijkstra算法的基本思想如下：设置并逐步扩充一个集合S，存放已求出其最短路径的顶点，则尚未确定最短路径的顶点集合是V-S其中，V为网中所有顶点集合。
按最短路径长度递增的顺序逐个用V-S中的顶点加到S中，直到S中包含全部顶点，而V-S为空。
Dijkstra算法的具体步骤；（1）设源点为V1，则S中只包含顶点V1，令W=V-S，则W中包含除V1外图中所有顶点。
V1对应的距离值为0，即D[1]=0。
W中顶点对应的距离值是这样规定的：若图中有弧 <v1,vk>，则Vj顶点的距离为此弧权值，否则为一个无穷大的数；（2）从W中选择一个其距离值最小的顶点 vk，并加入到S中；（3）每往S中加入一个顶点vk后，就要对W中各个顶点的距离值进行一次修改。
若加进vk做中间顶点，使<v1,vk> + <vk+vj>的值小于<v1,vj> 值，则用<v1,vk> + <vk+vj>代替原来vj 的距离值；（4）重复步骤2和3，即在修改过的W中的选距离值最小的顶点加入到S 中，并修改W中的各个顶点的距离值，如此进行下去，知道S中包含图中所有顶点为之，即S=V。
最短路dijkstra算法详解
最短路dijkstra算法详解最短路问题是图论中的一个经典问题，其目标是在给定图中找到从一个起点到其他所有节点的最短路径。
Dijkstra算法是解决最短路问题的一种常用算法，本文将详细介绍Dijkstra算法的原理、实现以及时间复杂度等相关内容。
一、Dijkstra算法的原理Dijkstra算法是一种贪心算法，其基本思想是从起点开始，逐步扩展到其他节点。
具体而言，Dijkstra算法通过维护一个集合S来记录已经找到了最短路径的节点，以及一个数组dist来记录每个节点到起点的距离。
初始时，S集合为空，dist数组中除了起点外所有节点都被初始化为无穷大。
接下来，重复以下步骤直到所有节点都被加入S集合：1. 从dist数组中选择距离起点最近的未加入S集合的节点u；2. 将u加入S集合；3. 更新与u相邻的未加入S集合的节点v的距离：如果从起点出发经过u可以得到更短的路径，则更新v对应位置上dist数组中存储的值。
重复以上步骤直至所有节点都被加入S集合，并且dist数组中存储了每个节点到起点的最短距离。
最后，根据dist数组中存储的信息可以得到起点到任意节点的最短路径。
二、Dijkstra算法的实现在实现Dijkstra算法时，需要使用一个优先队列来维护未加入S集合的节点，并且每次从队列中选择距离起点最近的节点。
由于C++标准库中没有提供优先队列，因此需要手动实现或者使用第三方库。
以下是一个基于STL堆实现的Dijkstra算法代码示例：```c++#include <iostream>#include <vector>#include <queue>using namespace std;const int INF = 0x3f3f3f3f;vector<pair<int, int>> adj[10001];int dist[10001];void dijkstra(int start) {priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;pq.push(make_pair(0, start));dist[start] = 0;while (!pq.empty()) {int u = pq.top().second;pq.pop();for (auto v : adj[u]) {if (dist[u] + v.second < dist[v.first]) {dist[v.first] = dist[u] + v.second;pq.push(make_pair(dist[v.first], v.first));}}}}int main() {int n, m, start;cin >> n >> m >> start;for (int i = 1; i <= n; i++) {dist[i] = INF;}for (int i = 1; i <= m; i++) {int u, v, w;cin >> u >> v >> w;adj[u].push_back(make_pair(v, w));}dijkstra(start);for (int i = 1; i <= n; i++) {if (dist[i] == INF) {cout << "INF" << endl;} else {cout << dist[i] << endl;}}return 0;}```以上代码中，adj数组用于存储图的邻接表，dist数组用于存储每个节点到起点的最短距离。
第三节 最短路问题
作业
195页
习题8
8.4题
( X , X ) { (V1 ,V4 ) ,(V2 ,V4 ) ,(V5 ,V4 ) ,(V5 ,V9 )} 1、 2、K14 K 24 8 K54 5 3 8 K59 1 3 4
3、 (V5 ,V9 ) V9 ( 4 ,
5)
第五轮： V1 (0,0) V2 (2,1) V5 (3,2) V9 (4,5) V7 (7,9) 1、 ( X , X ) { (V1 ,V4 ) ,(V2 ,V4 ) ,(V5 ,V4 ),(V9 ,V6 ),(V9 ,V7 ),(V9 ,V8 )} 2、 K14 K24 K54 8 3、 (V9 ,V7 ) V7 ( 7 ,
V1
(i , i )
V2
5
7
1
V4
6
2 2
V3
1
V5
第三步： 找出第二步中 K ij 最小的那条弧，给它的终 点以标号
(V1 ,V3 ) V3 (2,1)
8
如果有几个 K ij 都取最小值，就同时标号
以后每一轮都重复第二轮的三个步骤， 从而使某个顶点获得标号； 当终点获得标号后，计算结束； 然后逆向追踪获得最短路．
( X , X ) { (V1 ,V4 ) ,(V2 ,V4 ) ,(V5 ,V4 ) ,(V5 ,V9 )} 1、 2、K14 K 24 8 K54 3 5 8 K59 3 1 4
3、 (V5 ,V9 ) V9 ( 4 ,
5)
第三轮： V1 (0,0) V2 (2,1) V5 (3,2)
9)
1)
V4 (8,1) V1 V2 (2,1) V5 (3,2) V9 (4,5) V7 (7,9) V6 (10,9)
(完整)Dijkstra算法的流程图
Dijkstra算法的流程图需求和规格说明：Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止.Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低.算法本身并不是按照我们的思维习惯——求解从原点到第一个点的最短路径,再到第二个点的最短路径，直至最后求解完成到第n个点的最短路径，而是求解从原点出发的各有向路径的从小到大的排列，但是算法最终确实得到了从原点到图中其余各点的最短路径，可以说这是个副产品,对于算法的终结条件也应该以求得了原点到图中其余各点的最短路径为宜.清楚了算法的这种巧妙构思后，理解算法本身就不是难题了.实现注释：想要实现的功能：Dijkstra算法是用来求任意两个顶点之间的最短路径。
在该实验中，我们用邻接矩阵来存储图。
在该程序中设置一个二维数组来存储任意两个顶点之间的边的权值。
用户可以将任意一个图的信息通过键盘输入，让后在输入要查找的两个顶点，程序可以自动求出这两个顶点之间的最短路径.已经实现的功能:在该实验中，我们用邻接矩阵来存储图。
在该程序中设置一个全局变量的二维数组,用它来存储任意两个顶点之间的边的权值。
然后通过最短路径的计算,输入从任意两个顶点之间的最短路径的大小。
用户手册：对于改程序，不需要客户进行什么复杂的输入，关键是用来存放图的任意两个顶点之间的边的权值的二维数组的初始化,即将要通过Dijkstra算法求最短路径的图各条边的权值放入二维数组中。
这样程序就可以自动的计算出任意两个顶点之间的最短路径并且进行输出.设计思想：s为源，w［u，v] 为点u 和v 之间的边的长度，结果保存在 dist［]初始化：源的距离dist[s]设为0，其他的点距离设为无穷大，同时把所有的点状态设为没有扩展过。
循环n-1次：1. 在没有扩展过的点中取一距离最小的点u，并将其状态设为已扩展.2. 对于每个与u相邻的点v，如果dist［u] + w［u，v] < dist［v］，那么把dist ［v]更新成更短的距离dist［u］ + w[u，v]。
最短路算法 题
最短路算法题最短路算法是用于解决图论中一类重要问题的算法，即寻找图中从一个顶点到另一个顶点的最短路径。
这里的最短路径可以是路径的长度（边的数量）或路径的权重之和（边的权重）。
以下是一些常见的最短路算法题目类型及其解法：1.单源最短路问题：给定一个图和一个起点，找到从起点到图中所有其他点的最短路径。
2.Dijkstra算法：适用于带权重的图，且权重非负。
该算法每次迭代都会选取当前距离起点最近的一个顶点，并更新该顶点与起点的最短距离。
所有顶点都被访问后，算法结束。
3.Bellman-Ford算法：适用于带权重的图，权重可以为负。
该算法通过对图中的所有边进行迭代松弛操作来找到最短路径。
此外，它还可以检测并处理负权重环。
4.Floyd-Warshall算法：适用于所有顶点对之间的最短路径问题。
它使用动态规划的思想，逐步构建中间点集合，并利用中间点来更新最短路径。
5.多源最短路问题：给定一个图和多个起点，找到从这些起点到图中所有其他点的最短路径。
一种常见的解决方法是对每个起点分别运行单源最短路算法。
但这种方法可能不够高效，特别是当起点数量较大时。
另一种方法是使用更高级的数据结构或算法，如优先队列优化的Dijkstra算法或基于矩阵乘法的Floyd-Warshall算法变种。
5.特定条件下的最短路问题：除了基本的最短路问题外，还有一些特定条件下的最短路问题，如有向无环图（DAG）中的最短路径、边权重受限制的最短路径等。
这些问题通常需要结合特定的图论知识和技巧来解决。
6.在解决最短路问题时，需要注意以下几点：确保理解问题的具体要求，如路径的长度是按边的数量还是按边的权重计算。
根据问题的特点选择合适的算法和数据结构。
例如，对于稠密图，邻接矩阵可能是更好的选择；而对于稀疏图，邻接表可能更合适。
注意处理特殊情况，如负权重环、不连通图等。
这些情况可能导致最短路径不存在或无穷大。
在实现算法时，注意优化性能和减少不必要的计算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
• • • • • • • •
• • • •
function bellman(v:longint):boolean; var i,j,k:longint; begin for i:=1 to n do d[i]:=wq; {顶点v到各顶点的初值为正无穷} d[v]:=0; for i:=1 to n do for j:=1 to ne do {存储结构用边集数组，ne表示边的个数} if (d[edge[j].st]<>wq) and (d[edge[j].en]>d[edge[j].st]+edge[j].w) then d[edge[j].en]:=d[edge[j].st]+edge[j].w); for j:=1 to ne do if (d[edge[j].en]>d[edge[j].st]+edge[j].w) then exit(false); bellman:=true; end;
Floyd算法——解决多源最短路径问题
• 该算法使用了动态规划的思想，首先，将图中顶点编 号为1——n,以两点之间最短路径经过的顶点中最大 的顶点编号作为阶段，而两点间目前算出的最短路径 作为状态的值。 • 设F[i,j,k]为顶点编号为i和j两点经过最大顶点编号 不超过k的最短路径的长度，那么，
DIJKSTRA算法——单源最短路径算法
• • • • • • • • • • • • • • • • • • • • • • procedure shortpath(v:integer); var wm:integer; begin for i:=1 to n do begin dist[i]:=g[v,i]; if dist[i]<max1 then path[i]:=[v]+[i] else path[i]:=[]; end; s:=[v]; for k:=1 to n-1 do begin wm:=max1; j:=v; for i:=1 to n do if not (i in s) and (dist[i]<wm) then begin j:=i; wm:=dist[i] end; s:=s+[j]; for i:=1 to n do if not (i in s) and (dist[j]+g[j,i]<dist[i]) then begin dist[i]:=dist[j]+g[j,i]; path[i]:=path[j]+[i] end end; end;
Floyd算法——解决多源最短路径问题
• 算法本质：通过某个点，是否可以使两个点的距离变短， 而不是两个点之间的距离是否可以通过某个点变短，所以 最外成的循环（相当于动态规划的阶段）不能和里面的两 层循环顺序颠倒。 • 空间复杂度O(n^2),时间复杂度O(n^3)。
DIJKSTRA算法——单源最短路径算法 Node
New
Head
Tail
缺点：NewNode需要之前的元素全部出队后才能扩展 中断了迭代的连续性
猜想： 能否把NewNode放在Head后面进行下一次扩展？
小结
Dijkstra算法的效率高，但是也有局限性，就是对于含负权回路 的图无能为力。 Bellman-Ford算法对于所有最短路存在的图都适用，但是效率常常 不尽人意。 SPFA算法可以说是综合了上述两者的优点。它的效率同样很不错， 而且对于最短路长存在的图都适用，无论是否存在负权。它的编程 复杂度也很低，是高性价比的算法。
注意：
• 当图中不存在负权回路时，程序能正常工作；如果存在负 权回路，由于负权回路上的顶点无法收敛，总有顶点在入 队和出队中往返，队列无法为空，这种情况下SPFA无法正 常结束。 • 处理方法：增加一个一维数组times来统计每个顶点进栈 的次数，如果times[i]>n，说明存在负权回路。
传统的队列实现:
• 每实施一次松弛操作，最短路径树上就会有一层顶点达到 其最短距离，此后这层顶点的最短距离值就会保持不变， 不再受后续松弛操作的影响。 • 如果没有负权回路，由于最短路径的高度最多是V-1，所 以最多经过V-1遍松弛操作后，所有从s可达的顶点必将求 出其最短距离。如果d[v]仍保持+∞，则表明从s到v不可 达。 • 如果有负权回路，那么第V-1遍松弛操作仍然会成功，这 时，负权回路上的顶点不会收敛。
Dijkstra算法
适用条件: 所有边的权值非负 效率:
用一维数组来实现优先队列Q，O( V 2 )，适用于中等规模 的稠密图
二叉堆来实现优先队列Q，O((E+logV)V)，适用于稀疏图
Bellman-Ford算法
Bellman-Ford算法运用了松弛技术，对 每一结点V，逐步减小从源s到v的最短路径的 估计值d[v]直至其达到实际最短路径的权 d(s,v)，如果图中存在负权回路，算法将会报 告最短路不存在;若不存在这样的回路，算法 将给出从源点S到图G的任意顶点v的最短路 径值d[v]。
算法流程
• (1)初始化：将除源点外的所有顶点的最短距离估计值 d[v]:=+∞； d[s]:=0; • (2)迭代求解：反复对边集E中的每条边进行松弛操作，使 得顶点V集中的每个顶点v的最短距离估计值逐步逼近其最 短距离； • (3)检验负权回路：判断边集E中的每一条边的两个端点是 否收敛。如果存在未收敛的顶点，则算法返回false，表 明问题无解；否则算法返回true，并且从源点可达的顶点 v的最短距离保存在d[v]中。
SPFA算法
适用条件: 任意边权为实数的图
定理3 只要最短路径存在，上述SPFA算法必定能求出最小值。 证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的 优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d 越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短 路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到 达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最 短路径值。（证毕） 定理4 在平均情况下，SPFA算法的期望时间复杂度为O(E)。 证明：上述算法每次取出队首结点u，并访问u的所有临结点的复杂度 为O(d)，其中d为点u的出度。运用均摊分析的思想，对于|V|个点|E|条 E E 边的图，点的平均出度为 V，所以每处理一个点的复杂度为O(V )。假 设结点入队次数为h，显然h随图的不同而不同。但它仅与边权值分布 E h T O h O E O(kE ) 有关。我们设h=kV，则算法SPFA的时间复杂度为 V V 在平均的情况下，可以将k看成一个比较小的常数，所以SPFA算法在 一般情况下的时间复杂度为O(E)。（证毕）
算法证明
• 首先，图的任意一条最短路径既不能包含负权回路，也不 会包含正权回路，因此它最多包含V-1条边。 • 其次，从源点s可达的所有顶点如果存在最短路径，则这 些最短路径构成一个以s为根的最短路径树。BellmanFord算法的迭代松弛操作，实际上就是按顶点距离s的层 次，逐层生成这棵最短路径树的过程。 • 在对每条边进行第1遍松弛的时候，生成了从s出发，层次 至多为1的那些树枝。也就是说，找到了与s至多有1条边 相连的那些顶点的最短路径；在对每条边进行第2遍松弛 的时候，生成了从s出发，层次至多为2的那些树枝……
SPFA(shortest path faster algorithm)
• 在Bellman-ford算法优化的基础上发现，只有那些在前一 遍松弛中改变了距离估计值的点，才可能引起它们的邻接 点的距离估计值的改变。 • 因此，用一个先进先出的队列来存放被成功松弛的顶点。 初始时，源点s入队。当队列不空时，取出队首顶点，对 它的邻接点进行松弛。如果某个邻接点松弛成功，且该邻 接点不在队列中，则将其入队。经过有限次的松弛操作后 ，队列为空，算法结束。 • 算法的实现需要用一个先进先出的队列queue和一个指示 顶点是否在队列中的标记数组mark。为了方便查找某个顶 点的邻接点，图采用邻接表存储。
Bellman-Ford算法
适用条件: 任意边权为实数的图 效率: Bellman-Ford算法的运行时间为O(VE)。很多时候， 我们的算法并不需要运行|V|-1次就能得到最优值。 对于一次完整的松弛操作，要是一个结点的最短路 径估计值也没能更新，就可以退出了。 经过优化后，对于多数情况而言，程序的实际运行效 率将远离O(VE)而变为O(kE)，其中k是一个比|V|小很 多的数。
• 该算法基于一种贪心思想，主要用到松弛操作。 • 对一条边进行松弛操作时，考查该边的起点S和终点T，权 值W是否满足如下不等式： • DS+W<DT • 如果该边满足不等式，那么以源点到S的最短路径加上这 一条边会使得源点到点T的最短路径比目前的值更小，此 时，更新源点到点T的最短路径。 • 算法思想:每次找到源点最短路径最短的一个顶点，然后 以该顶点为中心进行扩展，最终得到给定源点到所有其余 顶点的最短路径。
• • • • • • • • • • • • • • for i:=1 to n do //初始化 for j:=1 to n do if i<>j then d[i,j]:=maxlongint else d[i,j]:=0; for i:=1 to m do //读入边的权值 begin readln(u,v,w); d[u,v]:=w; end; for k:=1 to n do for i:=1 to n do for j:=1 to n do if d[i,k]+d[k,j]<d[i,j] then d[i,j]:=d[i,k]+d[k,j];
算法框架
Bellman-Ford(G,w,s) 1. For each vertex v∈ V[G] do //初始化 2. d[v]:=+ ∞; 3. d[s]:=0; 4. For i ← 1 to |V[G]|-1 do 5. For 每条边(u,v) ∈ E[G] do 6. If d[v] > d[u] + w(u, v) then d[v] := d[u] + w(u, v) 7. For 每条边(u,v) ∈ E[G] do 8. If d[v] > d[u] + w(u, v) //检查负权回路 9. Then Return FALSE 10. Return TRUE