数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现

目录

前言

1. 介绍

2. 加权图

2.1 概念

3. 最短路径 -- Dijkstra 算法

3.1 历史

3.2 Dijkstra 算法的基本思路

3.3 Dijkstra 算法图解

4.  python中dijkstra算法的实现

5. 总结 


前言

前两章我们讲到了关于图的基本知识,和广度/深度优先搜索。

本章,我们将介绍加权图最短路径的相关知识。


1. 介绍

最短路径是图论中常见问题。

最短路径是指在一个图中找到两个节点之间的最短路径。

最短路径算法常见的有 floyd算法(弗洛伊德算法)和 dijkstra算法(迪杰斯特拉)。本文只介绍dijkstra算法
最短路径运用非常广泛,比如在导航系统中,确定两个地点间哪条路线最短;在网络路由中,路由器需要找到最短路径来转发数据包。


2. 加权图

2.1 概念

加权图是指每条边都带有权重的图。每个边的权重可以表示两个顶点之间的距离、成本或任何其他可以量化的指标。实际上,边的权重可以为负数,但是本章只介绍最短路径中的dijkstra算法且这种算法的前提条件就是权重不能为负数,所以不将负数的权重拓展到本文

下面的加权图中,每一个红色的数字都代表着那条边的权重。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第1张图片


3. 最短路径 -- Dijkstra 算法

3.1 历史

这个算法由荷兰杰出计算机科学家、软件工程师艾兹赫尔·戴克斯特拉 (Edsger W. Dijkstra)(1930年5月11日~2002年8月6日)发明。他是计算机先驱之一,与高德纳(Donald Ervin Knuth)并称为我们这个时代最伟大的计算机科学家。

从 Rotterdam 到 Groningen 的最短路线是什么?我花了大概 20 分钟时间设计了这个寻找最短路径的算法。一天早上我正和我年轻的未婚妻在 Amsterdam 逛街,觉得有点累了,我们就坐在咖啡厅的露台上喝了一杯咖啡,我在想是否能够解决这个问题,然后,我设计出了这个最短路径算法。我说过,这是一个 20 分钟的设计。事实上,三年之后的 1959 年它才被发布,现在看来依然很不错,其原因之一是我当时设计的时候没有纸和笔,从而不得不极力避免所有可避免的复杂性。最终,令我惊讶的是,这个算法成为了我成名的基石之一。

节选自文章《An interview with Edsger W. Dijkstra》

3.2 Dijkstra 算法的基本思路

首先将起始节点的距离标记为0,其他节点的距离因为还不确定所以先需要标记为无穷大。

然后,在图中找到距离起始节点最近的节点,更新其相邻节点的距离,距离为从起始节点到该节点的距离加上该节点到相邻节点的距离。

不断循环此过程,直到所有节点都被访问过。

这就是Dijkstra 算法的基本思路。

3.3 Dijkstra 算法图解

在下面这个图的基础上,我们可以一步一步来分析Dijkstra 算法的过程。

我们的目的是用此算法找到节点D到任意其他节点的最短路径。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第2张图片

1. 首先我们创建一个表格来记录节点D到所有节点的距离(自身为0,其余初始化为无穷大),还需要记录最短路径中每个节点的先驱节点(初始化为空)。最后需要一个flag去标记已经访问过的节点(初始化为F)。

节点 Flag 距离 先驱节点
A F
B F
C F
D F 0
E F
F F
G F
H F

2. 检查所有未标记节点中距离最短的节点,就是节点D,将其加入最短路径中,并标记。 

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第3张图片

节点 Flag 距离 先驱节点
A F
B F
C F
D T 0
E F
F F
G F
H F

3. 更新经过节点D的相邻节点距离到起始节点的距离,也就是D-B,D-E,D-G的距离,分别是4,1,5,同时使节点D作为他们的先驱节点。

节点 Flag 距离 先驱节点
A F
B F 4 D
C F
D T 0
E F 1 D
F F
G F 5 D
H F

4. 检查所有未标记节点中距离最短的节点,就是节点E,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第4张图片

节点 Flag 距离 先驱节点
A F
B F 4 D
C F
D T 0
E T 1 D
F F
G F 5 D
H F

5.  更新经过节点E的相邻节点到起始节点的距离,也就是D-E-B,D-E-C,D-E-F,D-E-G和D-E-H的距离,分别是9,11,12,7,13。但是因为D-B和D-G的路径在上一步已经更新过了,并且距离要小于D-E-B和D-E-G的距离,所以不更新节点B和节点G的距离,更新节点C,F和H的距离,同时使节点E作为他们的先驱节点。

节点 Flag 距离 先驱节点
A F
B F 4 D
C F 11 E
D T

0

E T 1 D
F F 12 E
G F 5 D
H F 13 E

6.  检查所有未标记节点中距离最短的节点,就是节点B,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第5张图片

节点 Flag 距离 先驱节点
A F
B T 4 D
C F 11 E
D T

0

E T 1 D
F F 12 E
G F 5 D
H F 13 E

7. 更新经过节点B的相邻节点到起始节点的距离,也就是D-B-A,距离为6,同时使节点B作为他的先驱节点。 

节点 Flag 距离 先驱节点
A F 6 B
B T 4 D
C F 11 E
D T

0

E T 1 D
F F 12 E
G F 5 D
H F 13 E

8.  检查所有未标记节点中距离最短的节点,就是节点G,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第6张图片

节点 Flag 距离 先驱节点
A F 6 B
B T 4 D
C F 11 E
D T

0

E T 1 D
F F 12 E
G T 5 D
H F 13 E

9.   更新经过节点G的相邻节点到起始节点的距离,也就是D-G-E,距离为11,但是因为之前保存过D-E的距离为1,很明显D-E的距离要更近一些,所以不更新表格。

10. 检查所有未标记节点中距离最短的节点,就是节点A,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第7张图片

节点 Flag 距离 先驱节点
A T 6 B
B T 4 D
C F 11 E
D T

0

E T 1 D
F F 12 E
G T 5 D
H F 13 E

11.  更新经过节点A的相邻节点到起始节点的距离,也就是D-B-A-C,距离为15,但是因为之前保存过D-E-C的距离为11,D-E-C的距离要近于D-B-A-C,所以不更新表格。

12.  检查所有未标记节点中距离最短的节点,就是节点C,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第8张图片

节点 Flag 距离 先驱节点
A T 6 B
B T 4 D
C T 11 E
D T

0

E T 1 D
F F 12 E
G T 5 D
H F 13 E

13. 更新经过节点C的相邻节点到起始节点的距离,也就是D-E-C-F,距离为14,但是因为之前保存过D-E-F的距离为12,D-E-F的距离要近于D-E-C-F,所以不更新表格。 

14. 检查所有未标记节点中距离最短的节点,就是节点F,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第9张图片

节点 Flag 距离 先驱节点
A T 6 B
B T 4 D
C T 11 E
D T

0

E T 1 D
F T 12 E
G T 5 D
H F 13 E

15. 更新经过节点F的相邻节点到起始节点的距离,也就是D-E-F-H,距离为29,但是因为之前保存过D-E-H的距离为13,D-E-H的距离要近于D-E-F-H,所以不更新表格。

16.   检查所有未标记节点中距离最短的节点,就是节点H,将其加入最短路径中,并标记。

数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现_第10张图片

节点 Flag 距离 先驱节点
A T 6 B
B T 4 D
C T 11 E
D T

0

E T 1 D
F T 12 E
G T 5 D
H T 13 E

17. 算法结束,此时我们拥有了从出发点D到任意一个节点的距离以及路径。最短路径可以根据先驱节点倒推出来,比如从D到H的最短距离为13,最短路径为D-E-H。

节点 Flag 距离 先驱节点
A T 6 B
B T 4 D
C T 11 E
D T

0

E T 1 D
F T 12 E
G T 5 D
H T 13 E

最短距离:看节点H,发现与起始点D的最短距离为13。
最短路径:看H的先驱节点,发现是E,在看E的先驱节点,发现是D。那么,从D到H的最短路径就是D-E-H了。 


4.  python中dijkstra算法的实现

import sys

def dijkstra(graph, start_node):
    unvisited_nodes = {node: sys.maxsize for node in graph}  # 初始化所有节点距离为无穷大
    unvisited_nodes[start_node] = 0  # 起始节点距离为0
    shortest_paths = {start_node: (0, [])}  # 起始节点的路径和距离

    while unvisited_nodes:
        current_node = min(unvisited_nodes, key=unvisited_nodes.get)  # 找到未访问节点中距离最小的节点
        current_distance = unvisited_nodes[current_node]

        for neighbor, distance in graph[current_node].items():
            if neighbor not in unvisited_nodes: continue  # 已访问过的节点跳过
            new_distance = current_distance + distance
            if new_distance < unvisited_nodes[neighbor]:  # 如果找到更短路径,更新
                unvisited_nodes[neighbor] = new_distance
                shortest_paths[neighbor] = (new_distance, shortest_paths[current_node][1] + [current_node])  # 更新路径和距离

        unvisited_nodes.pop(current_node)  # 当前节点已访问过,从未访问节点中删除

    return shortest_paths  # 返回最短路径和距离

# 测试Dijkstra算法
if __name__ == "__main__":
    graph = {
        'A': {'B': 2, 'C': 9},
        'B': {'A': 2, 'D': 4, 'E': 8},
        'C': {'A': 9, 'E': 10, 'F': 3},
        'D': {'B': 4, 'E': 1, 'G': 5},
        'E': {'B': 8, 'C': 10, 'D': 1, 'F': 11, 'G': 6, 'H': 12},
        'F': {'C': 3, 'E': 11, 'H': 17},
        'G': {'D': 5, 'E': 6},
        'H': {'E': 12, 'F': 17},
    }
    start_node = 'D'
    shortest_paths = dijkstra(graph, start_node)
    print(shortest_paths)

首先我创建了一个上面举例子的图,然后设置顶点D为起始顶点。

运行上面代码之后会打印出:

{'D': (0, []), 'B': (4, ['D']), 'E': (1, ['D']), 'G': (5, ['D']), 'C': (11, ['D', 'E']), 'F': (12, ['D', 'E']), 'H': (13, ['D', 'E']), 'A': (6, ['D', 'B'])}

我们可以很明显找到从D到任意一个顶点的最短路径和距离。


5. 总结 

Dijkstra算法是非常经典的最短路径算法,这种算法可以找到起始顶点与图中任意一个顶点的最短路径。但是其也有限制,图的权重必须不能有负数。如果图的权重带有负数,则需要使用Bellman-ford算法,如果想要确定任意两点的最短路径,则需要使用floyd算法。


ps. 本来打算把最小生成树也在这一章总结的,但是最近学校事情比较多,只能往后拖一拖了TOT 

希望大家能从这篇文章中对Dijkstra算法有更清晰的了解,如果我有什么地方讲的不对,欢迎大家指出!

你可能感兴趣的:(算法,python,图论)