【python】最短路径的求解 —— Dijkstra算法

已于 2024-08-14 22:16:56 修改
阅读量5.2k 收藏 91
点赞数 51
文章标签： 算法 python
于 2024-08-13 20:47:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65032457/article/details/141135370
版权

文章目录

前言

书接上回，之前的博客使用图论求解最短路径，但是只使用了 Matlab 的shortestpath 函数和 python 的 nx.shortest_path 函数进行求解。本文再介绍一种算法求解最短路径。

一、Dijkstra算法(迪克斯特拉算法)

  • Dijkstra算法是一种广泛使用的单源最短路径算法，它能够找到一个加权图中从一个起始节点到其他所有节点的最短路径。这个算法最适合于边的权重都是非负值的图。

算法步骤

以下是Dijkstra算法的详细步骤：

1.初始化:将源节点到自身的距离设为0，其他节点的距离设为无穷大。将所有节点标记为未访问。

2.选择未访问节点中距离最小的节点：将其标记为已访问，如果所有未访问节点的距离都是无穷大,
算法终止。

3.更新邻居节点的距离:对于邻居节点，如果通过当前节点可以获得更短的路径，则更新其距离。

4.重复步骤2和3，直到所有节点都被访问过或者目标节点的最短路径已经确定。

堆 heapq

  • Dijkstra算法求解最短路径问题时，需要选择未访问节点中距离最小的节点。而堆可以用于高效地找到具有最小距离的节点。
  • heapq 是 Python 标准库中的一个模块，提供了堆队列算法的实现，也称为优先队列算法。堆是一种特殊的树状数据结构，可以高效地支持插入和最小值/最大值的提取操作。Python 中的 heapq 实现了最小堆，即堆顶元素是最小值。

基本功能
下面是 heapq 中的一些基本函数及其解释：

  1. heapq.heappush(heap, item): 将元素 item 添加到堆中，保持堆的不变性。
  2. heapq.heappop(heap): 弹出并返回堆中的最小元素，同时保持堆的不变性。如果堆为空，会引发 IndexError。
  3. heapq.heappushpop(heap, item): 将元素 item 添加到堆中，然后弹出并返回堆中的最小元素。这个操作是原子的，效率比分开执行 heappush 和 heappop 更高。
  4. heapq.heapify(iterable): 将可迭代对象转换为堆。
  5. heapq.nlargest(n, iterable, key=None): 返回可迭代对象中最大的 n 个元素。
  6. heapq.nsmallest(n, iterable, key=None): 返回可迭代对象中最小的 n 个元素。

重点强调两个函数：

heapq.heappush(heap, item): 将元素 item 添加到堆中，函数返回值是添加元素 item后的值（既包含原来的元素，也包含元素 item 。

heapq.heappop(heap): 弹出并返回堆中的最小元素，同时保持堆的不变性。函数返回值是堆中的最小元素，并且堆更新为不含有最小元素。

二、示例

  • 求节点 0 到节点 8 的最短路径。

在这里插入图片描述

表示出示例图

# 示例图（邻接表表示）
graph = {
    '0': {'1': 4, '2': 8},
    '1': {'0': 4, '2': 3, '3': 8},
    '2': {'0': 8, '1': 3, '4': 1, '5': 6},
    '3': {'1': 8, '4': 2, '6': 7, '7': 4},
    '4': {'2': 1, '3': 2, '5': 6},
    '5': {'2': 6, '4': 6, '7': 2},
    '6': {'3': 7, '7': 14, '8': 9},
    '7': {'3': 4, '5': 2, '6': 14, '8': 10},
    '8': {'6': 9, '7': 10}
}

定义Dijkstra算法函数

  1. 源节点到自身的距离设为0，其他节点的距离设为无穷大
# 初始化距离字典，将所有节点的距离设为无穷大
distances = {vertex: float('infinity') for vertex in graph}
distances[start] = 0
  1. 初始化父亲节点（由于此时未访问任何节点所以全部设置为 None ）
# 初始化父亲节点
parent = {vertex: None for vertex in graph}
  1. 初始化要比较的节点
# 初始化优先队列，并将起始节点入队
priority_queue = [(0, start)]
  1. 从起始节点开始访问

（1）取出当前访问节点中距离最小的节点

（2）更新该节点相邻的节点和距离

（3）比较节点间的距离，若有更短的路径，则更新距离和该节点的父亲节点，并将该节点加入待比较的节点

while priority_queue:
    # 弹出堆中距离最小的节点
    current_distance, current_vertex = heapq.heappop(priority_queue)
    # print("距离最小的节点是:",current_distance, current_vertex, "更新后的队列:",priority_queue)

    # 如果当前距离已经大于已知的最短距离，则跳过
    if current_distance > distances[current_vertex]:
        continue

    # 更新相邻节点的距离
    for neighbor, weight in graph[current_vertex].items():
        distance = current_distance + weight
        # print("相邻节点的距离:",neighbor,distance)

        # 如果找到更短的路径，则更新距离，并将节点加入优先队列
        if distance < distances[neighbor]:
            distances[neighbor] = distance
            parent[neighbor] = current_vertex
            heapq.heappush(priority_queue, (distance, neighbor))
            # print("加入后的队列:",priority_queue)

当访问到最后一个节点时，heapq.heappop(heap) 函数弹出堆中最小的元素，堆中元素为空，退出循环。

Dijkstra算法函数代码

def dijkstra(graph,start):
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0

    # 初始化父亲节点
    parent = {vertex: None for vertex in graph}
    priority_queue = [(0,start)]

    while priority_queue:
        # 弹出堆中距离最小的节点
        current_distance, current_vertex = heapq.heappop(priority_queue)
        # print("距离最小的节点是:",current_distance, current_vertex, "更新后的队列:",priority_queue)

        # 如果当前距离已经大于已知的最短距离，则跳过
        if current_distance > distances[current_vertex]:
            continue

        # 更新相邻节点的距离
        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight
            # print("相邻节点的距离:",neighbor,distance)

            # 如果找到更短的路径，则更新距离，并将节点加入优先队列
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                parent[neighbor] = current_vertex
                heapq.heappush(priority_queue, (distance, neighbor))
                # print("加入后的队列:",priority_queue)
    return distances, parent

函数返回值：从起始点到每个节点的最短距离，和每个节点对应的父亲节点。

根据父亲节点，回溯最短路径

访问所有节点后得到的结果：

在这里插入图片描述

在这里插入图片描述
要求从 0 到 8 的最短距离，就从 8 开始回溯，8 的父亲节点是 7 ，7 的父亲节点是 3 ，3 的父亲节点是 4 ，4 的父亲节点是 2 ，2 的父亲节点是 1 ，1 的父亲节点是 0 ；所以从 0 到 8 的最短路径为： 0 —> 1 —> 2 —> 4 —> 3 —> 7 —> 8

代码如下：

# 输出路径回溯
def get_path(parent, start, end):
    path = []
    current = end
    while current is not None:
        path.append(current)
        current = parent[current]
    path.reverse()
    return path

三、python 代码

import heapq

graph = {
    '0': {'1': 4, '2': 8},
    '1': {'0': 4, '2': 3, '3': 8},
    '2': {'0': 8, '1': 3, '4': 1, '5': 6},
    '3': {'1': 8, '4': 2, '6': 7, '7': 4},
    '4': {'2': 1, '3': 2, '5': 6},
    '5': {'2': 6, '4': 6, '7': 2},
    '6': {'3': 7, '7': 14, '8': 9},
    '7': {'3': 4, '5': 2, '6': 14, '8': 10},
    '8': {'6': 9, '7': 10}
}

def dijkstra(graph,start):
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0

    # 初始化父亲节点
    parent = {vertex: None for vertex in graph}
    priority_queue = [(0,start)]

    while priority_queue:
        # 弹出堆中距离最小的节点
        current_distance, current_vertex = heapq.heappop(priority_queue)
        # print("距离最小的节点是:",current_distance, current_vertex, "更新后的队列:",priority_queue)

        # 如果当前距离已经大于已知的最短距离，则跳过
        if current_distance > distances[current_vertex]:
            continue

        # 更新相邻节点的距离
        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight
            # print("相邻节点的距离:",neighbor,distance)

            # 如果找到更短的路径，则更新距离，并将节点加入优先队列
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                parent[neighbor] = current_vertex
                heapq.heappush(priority_queue, (distance, neighbor))
                # print("加入后的队列:",priority_queue)
    return distances, parent

distances, parent = dijkstra(graph, '0')
# print(parent)
# print(distances)

# 输出路径回溯
def get_path(parent, start, end):
    path = []
    current = end
    while current is not None:
        path.append(current)
        current = parent[current]
    path.reverse()
    return path

end_node = '8'
path = get_path(parent, '0', end_node)
print(f"从节点 '0' 到节点 {end_node} 的路径:", path)

运行结果：

在这里插入图片描述

总结

本文说明了如何使用Dijkstra算法求解最短路径的问题，并使用python进行了代码编写。

望月12138
关注
Python实现最短路径——Dijkstra算法
与其临渊羡鱼,不如退而结网
06-14 1027
算法的起始点为s，对于s到其他节点的距离需要进行初始化。然后每次选择当前距离起始点最短的一个节点u，将其加入到已访问的节点集合中，更新其它节点到起始点的距离值。Dijkstra算法是一种经典的单源最短路径算法，使用广泛，可以应用于很多领域，比如路由算法、城市交通规划等。下面是Python实现Dijkstra算法的核心代码，其中graph表示图，start表示起始节点，length表示各个节点之间的距离值。下面是完整的Python源代码和测试示例，用于演示如何使用Dijkstra算法计算最短路径。
最短路径算法-Dijkstra（迪杰斯特拉）-python
王叔叔
03-07 4860
如果不清楚原理的话，看下这个视频（简单易懂，只有4分钟） B站：dijkstra算法求最短路径 看过之后就知道基本原理了。 算法实现步骤： ① 每次找出当前图中距离源点1最近的点k， ② 计算源点1经过该点k到达某个点j是否比原来更近，如果更近，则把源点1到某个点j的距离，替换为这个更近的距离。 ③ 经过n-1次查找（把除了源点之外的点都遍历一遍，每个点都当一次中介值），即可得出源点到每个点最近的距离。 如图： 实现代码如下：（注释非常详细） # -*- coding: utf-8 -*- def ge
Python使用Dijkstra算法实现求解图中最短路径距离问题详解
12-24
本文实例讲述了Python使用Dijkstra算法实现求解图中最短路径距离问题。分享给大家供大家参考，具体如下： 这里继续前面一篇《Python基于Floyd算法求解最短路径距离问题》的内容，这里要做的是Dijkstra算法，与Floyd算法类似，二者的用途均为求解最短路径距离，在图中有着广泛的应用，二者的原理都是老生常谈了，毕竟本科学习数据结构的同学是不可能不学习这两个算法的，所以在这里我也不再累赘，只简单概述一下这个算法的核心思想： Dijkstra算法的输入有两个参数，一个是原始的数据矩阵，一个是起始的顶点下标，算法的思想也很简单容易理解，在开始的时候，需要设置两个集合，用于存储顶点和路
【启发式算法】Dijkstra算法详细介绍（Python）
最新发布
追风赶月莫停留，平芜尽处是春山
03-06 3293
Dijkstra算法，全称迪杰斯特拉算法，是由荷兰计算机科学家艾兹赫尔·戴克斯特拉（Edsger W. Dijkstra）在1956年提出的，是一种用于解决图中的最短路径问题的算法。这种算法适用于带权重的图，其中每条边有一个非负的权重值。在这篇论文中，他不仅描述了这个算法，还提供了第一次正式的最短路径问题算法理论证明。这篇论文的题目虽然翻译成中文是《关于与图相关的两个问题的说明》，但它在算法史上有着非常重要的地位，因为其中描述的Dijkstra算法成为了解决图中最短路径问题的基石。
python棋盘最短路径_python Dijkstra算法实现最短路径问题的方法
weixin_39579548的博客
11-29 311
这篇文章主要介绍了python Dijkstra算法实现最短路径问题的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧从某源点到其余各顶点的最短路径Dijkstra算法可用于求解图中某源点到其余各顶点的最短路径。假设G={V，{E｝｝是含有n个顶点的有向图，以该图中顶点v为源点，使用Dijkstra算法求顶点v到图中其余各顶...
python实现Dijkstra算法求解最短路径问题（Shortest Path Problem）
南军Opt的博客
02-19 5157
python实现Dijkstra算法求解最短路径问题（Shortest Path Problem）
【算法】python实现最短路径Dijkstra算法
qq_32643313的博客
08-30 1195
# -*- coding: utf-8 -*- # /usr/bin/python # 作者：kimicr # 实验日期：20190827 # Python版本：3.6.3 # 解决边的权重非负的最短路径问题的经典Dijkstra算法（适用范围：有向图、非负权重） # 注意：最小路径不唯一 from collections import deque import math inf = mat...
Python语言实现最短路径算法（Shortest Path）
zy0412326的专栏
07-29 262
Python语言实现最短路径算法（Shortest Path）在Python中实现最短路径算法，可以使用Dijkstra算法。在这个示例中，我们创建了一个包含6个顶点的图，并添加了一些边。然后，我们从顶点0开始运行Dijkstra算法，计算并打印出从顶点0到所有其他顶点的最短路径距离。代码使用了Python的。模块来实现优先队列，以确保每次都选择距离最短的顶点进行处理。
python Dijkstra算法实现最短路径问题的方法
09-18
Dijkstra算法是一种用于在加权图中找到最短路径的算法，由荷兰计算机科学家艾兹赫尔·戴克斯特拉于1956年提出，并在1959年发表。该算法能够解决单源最短路径问题，即在有向图或无向图中，找到某一个顶点（源点）到图...
Python解决最短路径问题—Dijkstra算法+堆优化
qq_37217601的博客
07-23 4130
Python解决最短路径问题—Dijkstra算法+堆优化最短路问题介绍Dijkstra算法介绍算法思想Dijkstra算法步骤代码 宇智波一打七今天学习了一个新算法，迫不及待和大家分享一下 。 最短路问题介绍 在一个赋权图中，从一个顶点出发到达另外一个顶点的路的权和最小的路径，称为最短路径。Dijkstra算法是解决这一问题的经典算法，接下来我们介绍如何用python实现这一算法。 Dijkstra算法介绍 Dijkstra算法由Dijkstra在1959年发现，这个算法不仅找到了最短的 (u0,v0)(
python实现Dijkstra算法的最短路径问题
09-19
主要介绍了python实现Dijkstra算法的最短路径问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
python编写的最短路径算法
09-22
本文给大家分享的是python 无向图最短路径算法：请各位大大指教，继续改进。(修改了中文字符串，使py2exe中文没烦恼）,需要的朋友可以参考下
Python实现最短路径Dijkstra算法
majian1245的博客
04-27 392
Python实现最短路径Dijkstra算法
最短路径算法Dijkstra算法(with python code)
sdf57的博客
09-19 293
想写一篇关于最短路径的算法发现自己画图不够好，看到一篇博客简单清楚的解释了算法的含义，搬运过来了，后面是我补充的。 转自https://www.cnblogs.com/nigang/p/3658990.html 以顶点A作为出发点为例，来说明Dijkstra算法过程。 （1）设置两个集合，S集合和V集合。S集合初始只有源顶点即顶点A，V集合初始为除了源顶点以外的其他所有顶点。 设置一个数组dist用来表...
Python 指南-最短路径（Dijkstra 算法）：
gis收藏家的博客
03-25 1569
Dijkstra 算法可在 Python 库 OSMNX 中实现，可用于查找两个位置之间按距离或时间加权的最短路径。使用起始位置和目标位置获取属于网络一部分的最近节点。可以使用 osmnx 函数获取节点的代码。我们将从图中提取节点的几何图形并创建表示最短路径的 LineString 几何图形。正如我提到的，我将做一个分步指南，所以让我们开始吧。然后，我们将提取将用于生成最短路径的图。您可以使用此数据来创建您自己的地图。我们将通过绘制所有元素来检查我们的工作是否正确。将地图的网络和路径保存在本地磁盘中。
Python 实现Dijkstra（迪杰斯特拉）最短路径算法
qq_51471471的博客
04-05 1553
通过Python实现的Dijkstra（迪杰斯特拉）最短路径算法 。😎
Dijkstra算法的python实现（算法证明、记录最短路径长度及路径信息）
weixin_42639395的博客
01-09 3354
Dijkstra算法的python实现，能够求解起始节点到各个节点的最短路径长度及路径信息； 并且进行了算法有效性证明
python 经典算法之--最短路径算法(Shortest Path Algorithm)
qq_42852699的博客
09-08 6108
Bellman-Ford算法中，对于一条边(u, v)，先从源点s到u的最短路径dist[u]已经求得，通过松弛操作，可以尝试更新从源点s到v的最短路径dist[v]，如果更新成功，则表示有一条更短的路径从源点s到v。Bellman-Ford算法中，对于一条边(u, v)，先从源点s到u的最短路径dist[u]已经求得，通过松弛操作，可以尝试更新从源点s到v的最短路径dist[v]，如果更新成功，则表示有一条更短的路径从源点s到v。最短路径算法是一类算法，用于寻找图中两个节点之间的最短路径。
Dijkstra算法python
01-01
### 关于Dijkstra算法的Python实现 #### Dijkstra算法简介 Dijkstra算法是一种经典的单源最短路径算法，用于在加权图中找出从一个指定起点节点到其他所有节点的最短路径。该算法适用于含有非负权重边的有向和无向图[^1]。 #### Python代码示例及解释 下面是一个基于优先队列优化版本的Dijkstra算法Python实现： ```python import heapq def dijkstra(graph, start): # 初始化距离字典，默认值为无穷大 distances = {node: float('infinity') for node in graph} # 起始节点的距离设为0 distances[start] = 0 # 创建最小堆，存储 (distance, node) 对 priority_queue = [(0, start)] while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) # 如果当前计算的距离大于记录的距离，则跳过此轮循环 if current_distance > distances[current_node]: continue # 遍历邻接表中的邻居节点 for neighbor, weight in graph[current_node].items(): distance = current_distance + weight # 只更新更短的新发现路径 if distance < distances[neighbor]: distances[neighbor] = distance # 将新发现的较短路径加入优先队列 heapq.heappush(priority_queue, (distance, neighbor)) return distances if __name__ == "__main__": # 构建测试用图结构 test_graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } result = dijkstra(test_graph, 'A') print(result) ``` 这段程序实现了如下功能： - 使用`heapq`模块来维护一个小顶堆作为优先级队列； - `distances`字典用来保存各个结点到起始结点之间的最短路径长度； - 当前处理过的结点会被标记并移入已访问列表（这里通过比较`current_distance`与已有记录决定是否继续），从而避免重复遍历； - 每次从未被确认最短路经的集合U选取离原点最近的一个点u，并将其纳入S集合作进一步扩展操作直至完成整个过程[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值