最短路径之Dijkstra算法和Floyd-Warshall算法
最短路径算法
Dijkstra算法
理解
步骤 | 描述 | 前驱结点 |
---|---|---|
1 | 将当前结点到其它结点的路径都初始化为无穷大 | 无 |
2 | 依次计算每个结点的路径长度,此时可以获得结点1到其它的结点2、3、4、5、6的路径长度为[7, 9, ∞,∞,14]`,取其中最小的值7,结点2作为前驱结点 | 无 |
3 | 此时通过结点2可以到达结点4和5,并且其路径等于起始结点到前驱结点的路径加上前驱结点到目标结点的路径长度,因此此时结点1到其它结点3、4、5、6的路径长度为[17, 22, ∞, ∞],此时将现在的路径长度和之前的路径长度进行比较,取对应的较小值,得到最短距离[9, 22, ∞, 14],取其最小值9,结点3更新成前驱结点 | 2 |
4 | 同样的道理,此时结点1到其它的结点4、5、6的路径长度为[20, ∞, 11],和之前的路径长度进行比较,得到最短距离[20, ∞, 11],取最小值11,结点6作为前驱结点 | 3 |
5 | 同样的道理,得到结点1到其它的结点4, 5的路径长度为[20, 20],和之前对比,最短距离更新成[20,20] | 6 |
6 | 因为此时剩下了两个相等路径长度的结点,取任意一个结点,结果都是一样的,所以取哪个都可以 |
function Dijkstra(G, w, s)
for each vertex v in V[G] # 初始化
d[v] := infinity # 將各點的已知最短距離先設成無窮大
previous[v] := undefined # 各点的已知最短路径上的前趋都未知
d[s] := 0 # 因为出发点到出发点间不需移动任何距离,所以可以直接将s到s的最小距离设为0
S := empty set
Q := set of all vertices
while Q is not an empty set # Dijkstra演算法主體
u := Extract_Min(Q)
S.append(u)
for each edge outgoing from u as (u,v)
if d[v] > d[u] + w(u,v) # 拓展边(u,v)。w(u,v)为从u到v的路径长度。
d[v] := d[u] + w(u,v) # 更新路径长度到更小的那个和值。
previous[v] := u # 紀錄前趨頂點
实现
import sys
class Graph():
def __init__(self, vertices):
self.V = vertices
self.graph = [[0 for _ in range(self.V)] for _ in range(self.V)]
# 打印距离
def print_distance(self, dist, parent):
for node in range(self.V):
print('distance')
print(node, dist[node])
print('path')
self.print_path(parent, node)
print('---------')
# 打印路径
def print_path(self, parent, j):
if parent[j] == -1:
print(j)
return
self.print_path(parent, parent[j])
print(j)
# 找出最小距离的结点
def min_distance(self, dist, sptSet):
min_val = sys.maxsize
min_index = 0
for v in range(self.V):
if dist[v] < min_val and not sptSet[v]:
min_val = dist[v]
min_index = v
return min_index
# 核心算法
def dijkstra(self, src):
dist = [sys.maxsize] * self.V
dist[src] = 0
sptSet = [False] * self.V
parent = [-1] * self.V
for count in range(self.V):
# 找出前驱结点
u = self.min_distance(dist, sptSet)
sptSet[u] = True
# 如果某个节点的路径大于经过前驱结点的路径,则更新结果成经过前驱结点的路径
for v in range(self.V):
if self.graph[u][v] > 0 and not sptSet[v] and dist[v] > dist[u] + self.graph[u][v]:
dist[v] = dist[u] + self.graph[u][v]
parent[v] = u
self.print_distance(dist, parent)
g = Graph(8)
g.graph = [[0, 0, 7, 7, 2, 0, 0, 0],
[0, 0, 3, 8, 0, 0, 8, 0],
[7, 3, 0, 0, 0, 7, 0, 0],
[7, 8, 0, 0, 0, 0, 0, 0],
[2, 0, 0, 0, 0, 0, 0, 8],
[0, 0, 7, 0, 0, 0, 8, 0],
[0, 8, 0, 0, 0, 8, 0, 6],
[0, 0, 0, 0, 8, 0, 6, 0]]
g.dijkstra(0)
Floyd
理解
实现
import copy
INF = 1e9
class Graph():
def __init__(self, graph):
self.V = len(graph)
self.graph = graph
# 打印距离
def print_distance(self, dist):
for i in range(self.V):
for j in range(self.V):
print('%5s' % (dist[i][j] if dist[i][j] != INF else 'INF'), end='')
print('')
# 核心算法
def floydwarshall(self):
dist = copy.deepcopy(self.graph)
for k in range(self.V):
for i in range(self.V):
for j in range(self.V):
# 不考虑自己指向自己的情况
if i == j:
continue
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
self.print_distance(dist)
g = Graph([[INF, INF, 1, INF, INF, INF, INF, INF],
[INF, INF, 2, 8, INF, 5, INF, INF],
[9, INF, INF, INF, 2, INF, INF, INF],
[INF, INF, INF, INF, INF, 2, INF, INF],
[INF, INF, INF, INF, INF, INF, INF, 9],
[INF, INF, INF, INF, INF, INF, INF, INF],
[INF, INF, INF, INF, 1, INF, INF, INF],
[INF, INF, INF, INF, INF, 7, 7, INF]])
g.floydwarshall()
![](https://i.loli.net/2018/11/17/5beff4d639cbb.jpg)
关注公众号:数据结构与算法那些事儿,每天一篇数据结构与算法