07_第七章 迪克斯特拉算法

最新推荐文章于 2023-09-03 11:01:10 发布
最新推荐文章于 2023-09-03 11:01:10 发布
阅读量2.2k 收藏 4
点赞数 2
分类专栏： # Python算法 文章标签： 算法 python 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44917390/article/details/105937723
版权

本章内容：

  • 继续图的讨论，介绍加权图——提高或降低某些边的权重
  • 介绍迪克斯特拉算法，让你能够找出加权图中前往x的最短路径
  • 介绍图中的环，迪克斯特拉算法只适用于有向无环图

在上一章中，我用广度优先算法可以找出段数最少的路径，但是如果要找出最快的路径，要用到另一种算法——迪克斯特拉算法（Dijkstra's algorithm）

 

目录

1  使用迪克斯特拉算法

2  术语

3  算法实现

4  解决上一章的问题（猪猪去珊珊家的最短路径）

5  小结

 

1  使用迪克斯特拉算法

关键理念：找出图中最便宜的节点，并确保没有到该节点的更便宜的路径！

迪克斯特拉算法包含4个步骤：

  1. 找出“最便宜”的节点，即可在最短时间内到达的节点
  2. 更新该节点的邻居的开销，检查是否有前往它们更短的路径
  3. 重复这个过程，直到对图中的每个节点都这样做了
  4. 计算最终路径

下面来看看如何对下图使用这种算法（每个数字都代表时间，单位分钟）

第一步：找出最便宜的节点。你站在起点，不知道是前往节点A还是B。

前往A需要6分钟，而前往B需哟啊2分钟，至于其他节点，你还不知道需要多久。由于你还不知道前往终点需要多长的时间，因此需要假设为无穷大。节点B是最近的——2分钟就可以到达。

节点耗时
A6
B

2

终点∞

第二步：计算经节点B前往各个邻居的所需要的时间。

找到了一条通往A的更加近的路！经B到A的时间只需要5分钟！

节点耗时
A5（=2+3）
B

2

终点7（=2+5）

对于节点B的邻居，如果找到前往它的更短的路径，就更新其开销。在这里你找到了：

  • 前往节点A的更短路径（时间从6分钟缩短为5分钟

  • 前往终点的路径更短（时间从无穷大缩短为7分钟）

第三步：重复！

重复第一步：找出可在最短时间内前往的节点，你对节点B执行了第二步，处节点B外，可在最短时间内前往的节点是节点A。

重复第二步：更新节点A的所有邻居的路径。

对每一个节点都需要运行迪克特斯拉算法，但是对终点无需这样做！

发现前往终点的时间只需要6分钟！

节点耗时
A5
B

2

终点6

第四步：计算路径

先放着...

 

要是有一些一些疑惑，不妨看看这个

视频：迪科斯彻算法分解

 

 

 

2  术语

  1. 迪克斯特拉算法用于每条边都关联数字的图，这些数字称为权重（weight）
  2. 带权重的图称为加权图（weighted graph），不带权重的图称为非加权图（unweighted graph）
  3. 无向图意味着两个节点彼此指向对方，其实就是环。在无向图中，每条边都是一个环
  4. 迪克斯特拉算法只适用于有向无环图（directed acyclic graph    DAG）
  5. 如果有负权边，就不能使用迪克斯特拉算法，因为会导致算法不管用。需要用另外一种算法——贝尔曼-福德算法（Bellman-Ford algorithm）

 

3  算法实现

要编写这个问题的代码，需要三个散列表。

1、需要同时存储邻居和前往邻居的开销，还要使用另外一个散列表来表示边的权重（散列表里面包含散列表）

graph = {}
graph['start'] = {}
graph['start']['a'] = 6
graph['start']['b'] = 2
graph['a'] = {}
graph['a']['fin'] = 1
graph['b'] = {}
graph['b']['a'] = 3
graph['b']['fin'] = 5
graph['fin'] = {}
#获取关系节点图
print(graph)
#获取某一节点的邻居
print(graph['start'].keys())
#获取从一个节点到邻居节点的权重
print(graph['start']['a'])

#输出
{'start': {'a': 6, 'b': 2}, 'a': {'fin': 1}, 'b': {'a': 3, 'fin': 5}, 'fin': {}}
dict_keys(['a', 'b'])
6

2、需要用一个散列表来存储每个节点的开销（即从出发到节点之间需要花多少时间）

当然这个散列表会更新的！

infinity = float('inf')
#这个用于记录python的无穷大
costs = {}
costs['a'] = 6
costs['b'] = 2
costs['fin'] = infinity
print(costs)

#输出
{'a': 6, 'b': 2, 'fin': inf}

3、需要一个散列表存储父节点

parents = {}
parents['a'] = 'start'
parents['b'] = 'start'
parents['fin'] = None
print(parents)

#输出
{'a': 'start', 'b': 'start', 'fin': None}

4、最后需要一个数组记录用过的节点，因为对于同一个节点，你不用多次修改

processed = []

最终的代码如下：

graph = {}
graph['start'] = {}
graph['start']['a'] = 6
graph['start']['b'] = 2
graph['a'] = {}
graph['a']['fin'] = 1
graph['b'] = {}
graph['b']['a'] = 3
graph['b']['fin'] = 5
graph['fin'] = {}

infinity = float('inf')
costs = {}
costs['a'] = 6
costs['b'] = 2
costs['fin'] = infinity

parents = {}
parents['a'] = 'start'
parents['b'] = 'start'
parents['fin'] = None

processed = []

def find_lowest_cost_node(costs):
    #这个找出所有节点的花销里面中最小的那一个
    lowest_cost = float('inf')
    lowest_cost_node = None
    #这个是初始化预设花销为最大，节点为none
    for node in costs:
        #对花销里面的节点进行遍历
        cost = costs[node]
        #从起点到这个节点的花销
        if cost < lowest_cost and node not in processed:
            #如果这个花销比最低的花销还小，同时这个节点还没有被处理过
            lowest_cost = cost
            lowest_cost_node = node
            #那么便对这些值进行赋值（直到找到最小的那一个）
    return lowest_cost_node
    #返回所找的花销最小的那个节点

node = find_lowest_cost_node(costs)
#在未处理的节点中找出开销最小的节点
while node is not None:
    #这个while循环在所有的节点都被处理了之后结束
    cost = costs[node]
    #从起点到node节点所需要的花销
    neighbors = graph[node]
    #这个找到花销最小的节点node的邻居有哪些
    for n in neighbors.keys():
        #对这个节点的邻居进行遍历
        new_costs = cost + neighbors[n]
        #新的总花销就是从起点到node节点所需要的花销以及该节点到他的其中一个邻居的花销的和
        if costs[n] > new_costs:
            #如果起点到这个邻居的花销比新的总花销贵
            costs[n] = new_costs
            #那么就把这个起点到这个邻居的花销换成便宜的这个
            parents[n] = node
            #同时要把这个邻居的父节点换成node这个节点，因为经过node这个节点，起点到这个邻居的节点的花销会少一点
    processed.append(node)
    #同时记录一下这个被处理过的节点
    node = find_lowest_cost_node(costs)
    #然后再从剩下的花销节点里面找出花销最少的那个，重新一轮while循环
print(parents)

#输出
{'a': 'b', 'b': 'start', 'fin': 'a'}

5、对最后的结果进行处理优化

starting_point = 'start'
#起点
destination = 'fin'
#终点
line = [starting_point]
#我们很清楚的看到这个parents中键值对的关系：键代表父节点，值代表子节点
def find_son(father,diction):
    #根据子节点找到父节点
    for key_value in diction:
        #这个里面返回的key_value是键
        if diction[key_value] == father:
            #如果某个键返回的值是这个要找的节点的孩子
            line.append(key_value)
            #那么就把这个父节点加入到这个数组里面去
            return find_son(key_value,diction)
        #进行递归，把这个找到的子节点作为父节点重新开始新一轮的找儿子哈哈哈哈
find_son(starting_point,parents)

spend = costs[destination]
#这个表示最少的花销
print('加权后的最短路径是：',line)
print('最少花销是：',spend)

输出：

加权后的最短路径是： ['start', 'b', 'a', 'fin']
最少花销是： 6

 

4  解决上一章的问题（猪猪去珊珊家的最短路径）

简单的举一反三一下

代码实现如下：

graph = {}
graph['浙江'] = {}
graph['浙江']['安徽'] = 200
graph['浙江']['江西'] = 400
graph['浙江']['福建'] = 350
graph['安徽'] = {}
graph['安徽']['湖北'] = 250
graph['安徽']['江西'] = 300
graph['江西'] = {}
graph['江西']['湖南'] = 350
graph['福建'] = {}
graph['福建']['江西'] = 250
graph['湖北'] = {}
graph['湖北']['湖南'] = 150
graph['湖南'] = {}

infinity = float('inf')
costs = {}
costs['安徽'] = 200
costs['江西'] = 400
costs['福建'] = 350
costs['湖北'] = infinity
costs['湖南'] = infinity

parents = {}
parents['安徽'] = '浙江'
parents['江西'] = '浙江'
parents['福建'] = '浙江'
parents['湖北'] = None
parents['湖南'] = None

processed = []

def find_lowest_cost_node(costs):
    #这个找出所有节点的花销里面中最小的那一个
    lowest_cost = float('inf')
    lowest_cost_node = None
    #这个是初始化预设花销为最大，节点为none
    for node in costs:
        #对花销里面的节点进行遍历
        cost = costs[node]
        #从起点到这个节点的花销
        if cost < lowest_cost and node not in processed:
            #如果这个花销比最低的花销还小，同时这个节点还没有被处理过
            lowest_cost = cost
            lowest_cost_node = node
            #那么便对这些值进行赋值（直到找到最小的那一个）
    return lowest_cost_node
    #返回所找的花销最小的那个节点

node = find_lowest_cost_node(costs)
#在未处理的节点中找出开销最小的节点
while node is not None:
    #这个while循环在所有的节点都被处理了之后结束
    cost = costs[node]
    #从起点到node节点所需要的花销
    neighbors = graph[node]
    #这个找到花销最小的节点node的邻居有哪些
    for n in neighbors.keys():
        #对这个节点的邻居进行遍历
        new_costs = cost + neighbors[n]
        #新的总花销就是从起点到node节点所需要的花销以及该节点到他的其中一个邻居的花销的和
        if costs[n] > new_costs:
            #如果起点到这个邻居的花销比新的总花销贵
            costs[n] = new_costs
            #那么就把这个起点到这个邻居的花销换成便宜的这个
            parents[n] = node
            #同时要把这个邻居的父节点换成node这个节点，因为经过node这个节点，起点到这个邻居的节点的花销会少一点
    processed.append(node)
    #同时记录一下这个被处理过的节点
    node = find_lowest_cost_node(costs)
    #然后再从剩下的花销节点里面找出花销最少的那个，重新一轮while循环

print(parents)

starting_point = '浙江'
#起点
destination = '湖南'
#终点
line = [starting_point]
#我们很清楚的看到这个parents中键值对的关系：键代表父节点，值代表子节点
def find_son(father,diction):
    #根据子节点找到父节点
    for key_value in diction:
        #这个里面返回的key_value是键
        if diction[key_value] == father:
            #如果某个键返回的值是这个要找的节点的孩子
            line.append(key_value)
            #那么就把这个父节点加入到这个数组里面去
            return find_son(key_value,diction)
        #进行递归，把这个找到的子节点作为父节点重新开始新一轮的找儿子哈哈哈哈
find_son(starting_point,parents)

spend = costs[destination]
#这个表示最少的花销
print('猪猪去珊珊家的最短的路线是：',line)
print('猪猪去珊珊家的最少路程是：',spend)

输出：

{'安徽': '浙江', '江西': '浙江', '福建': '浙江', '湖北': '安徽', '湖南': '湖北'}
猪猪去珊珊家的最短的路线是： ['浙江', '安徽', '湖北', '湖南']
猪猪去珊珊家的最少路程是： 600

爱你哦，等我来！

 

5  小结

  • 广度优先搜索用于在非加权图中查找最短路径
  • 迪克斯特拉算法用于在加权图中查找最短路径
  • 仅当权重为正时迪克斯特拉算法才管用
  • 如果图中包含负权边，去使用贝尔曼-福德算法

 

 

 

 

 

 

 

 

 

 

 

 

手可摘星辰不去高声语
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dijkatra_matlab；迪克斯特拉算法_
09-29
实现matlab的矢量迪克斯特拉算法，解决寻找最短路径的问题
狄克斯特拉(Dijkstra)算法详解
Wopelo的博客
06-26 3万+
最近在看《算法图解》，其中第七章狄克斯特拉算法个人感觉并没有讲的清楚，比如看完7.1节给人的感觉是狄克斯特拉算法会遍历图中的每一条边，后续狄克斯特拉不适用负权边的说法就站不住脚了。后续在查阅诸多资料之后，总结文章一篇，尽可能以通俗易懂且思路清晰的方式来讲解狄克斯特拉算法。...
迪克斯特拉算法（Dijkstra 最短路算法）（简单易懂）
空白的博客
05-16 2984
Dijkstra 最短路算法 上周我们介绍了神奇的只有五行的 Floyd 最短路算法，它可以方便的求得任意两点的最短路径，这称为“多源最短路”。本周来来介绍指定一个点（源点）到其余各个顶点的最短路径，也叫做“单源最短路径”。例如求下图中的 1 号顶点到 2、3、4、5、6 号顶点的最短路径。 与 Floyd-Warshall 算法一样这里仍然使用二维数组 e 来存储顶点之间边的关系，初始值如下。...
一文秒懂迪克斯特拉Dijkstra算法
最新发布
m0_72397750的博客
09-03 1563
迪克斯特拉Dijkstra算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块，且权值不能为负。
Dijkstra算法图文详解
热门推荐
black_hole6的博客
11-20 36万+
Dijkstra算法 Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。 问题引入： 指定一个点（源点）到其余各个顶点的最短路径，也叫做“单源最短路径”。例如求下图中...
迪杰斯特拉(Dijkstra)算法
xiaoxi_hahaha的博客
11-29 6万+
一 算法介绍 迪杰斯特拉算法是由荷兰计算机科学家在1956年发现的算法，此算法使用类似广度优先搜索的方法解决了带权图的单源最短路径问题。它是一个贪心算法。 二 核心思想 1. 选定一个点，这个点满足两个条件：1.未被选过，2.距离最短 2. 对于这个点的所有邻近点去尝试松弛 三 算法步骤 首先，可以设置两个集合分别是A和B，A用来存放已经求出最短路径的点，B用来存放还未计算出最短路径的点，接下来就可以开始做题啦！！！ 我们从图中任选一点来解题，假设我们将源点source选择..
matlab迪克斯特拉算法的程序.zip
04-18
这是用MATLAB写的迪克斯特拉算法，求最短路径的。D（i）表示点a到第i顶点之间的最短距离，S2（i）表示点a到第i顶点的最短路径中第i顶点前一顶点的序号。
zuiduanlujing.rar_最短路径_迪杰斯特拉_迪杰斯特拉算法
09-24
这是一个用来求最短路径的程序,用的是迪杰斯特拉算法
zdlj.rar_迪杰斯特拉_迪杰斯特拉算法
09-21
图的迪杰斯特拉算法，本人亲自将课本的代码打出来并进行了修改
第七章_拓展内容_2_迪杰斯特拉算法.pdf
08-04
课件
图论：Dijkstra算法——最详细的分析，图文并茂，一次看懂！
普罗米修斯的博客
08-25 1万+
Dijstra算法
狄克斯特拉算法(Dijkstra)详细解释
qq_52320085的博客
01-22 5133
文章目录算法用途（目的）算法思想与本质图文解释代码解析 算法用途（目的） 狄克斯特拉算法的用途或者说是目的是计算单源最短路径。单源最短路径的意思是从一个点出发到另外一个点最为的容易.举个例子解释, #mermaid-svg-nbf0pioDLfxvaYAO .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-nbf0
狄克斯特拉算法
qq_37287621的博客
10-16 398
狄克斯特拉算法 是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。 迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 示例： 找出从起点到终点的最短路径 当前起点到各点的花费 |B| 5| |C|1| | D|?| | E|?| | fin|?| 第一步，选择C扩展 |B| 5...
Dijkstra(迪杰斯特拉)算法
Zllvincent的博客
06-23 2180
一.简介 迪克斯特拉算法又名Dijkstra算法(属于贪心算法)。Dijkstra算法是从一节点到其余各节点最短路径计算方法。 迪杰斯特拉算法以起始点为中心向外层层扩展，直到扩展到终点为止。 二.实现 package com.vincent; import java.util.*; public class Main { public static void main(String[] args) throws Exception { char[] datas = {'a',
算法——迪克斯特拉算法
吃四碗饭的嘤嘤怪的博客
08-09 1万+
迪克斯特拉算法主要分四个步骤： 找到“最便宜”的节点（可在最短时间内到达的节点）。 更新该节点的邻居节点的开销。 重复这个过程，直到对图中每个节点都做了。 计算最终路径。 这个算法的核心理念是：找到图中最便宜的节点，并确保没有到该节点更便宜的路径。 （所以需要注意的是如果你的图包含负权边，就不能用这个算法，因为这会导致已经处理过的节点更新。） 假设我现在有上面的一张图，计算A-&gt...
迪克斯特拉算法
m0_60304650的博客
12-24 643
前言 最近学习了迪克斯特拉算法来求解无向图的最短路径问题，简单来说该算法的核心思路就是通过每一步寻找dist列表中的最小距离的点来更新path列表。废话少说，直接上步骤。 步骤： （1）找到“最便宜”的节点（可在最短时间内到达的节点）。 （2）更新该节点的邻居节点的开销。 （3）重复这个过程，直到对图中每个节点都做了。 （4）计算最终路径。 接下来让我们来计算A到E的最短路径 先创建我们所需要的表格 dis是存储A点到每个点的距离，先设为INF dis ...
迪克斯特拉（Dijkstra）算法原理及实现（Java）
weixin_43405649的博客
04-26 1708
  迪克斯特拉（Dijkstra）算法：解决有权图中的最短路径（使用优先队列）问题；   最短路径树（Shortest Path Tree）：所有节点的最短路径（相对于初始节点）组成的树。 算法原理   Cut和Crossing edge   Prims算法 java代码 To be a sailor of the world bound for all ports. ...
迪克斯特拉算法--Dijkstra's Algorithm
lisiyu的博客
11-21 785
在图形应用中，常常需要求从图中某个结点至其余各结点的最短路径，如对于一个物流配送系统计算从配送中心到各订货点的最短路径。 Dijkstra's Algorithm 基本思想： 若给定带权有向图G=(V,E)和源顶点v0，构筑一个源集合S，将v0加入其中。 ① 对差集V\S中 个顶点vi，逐一计算从v0 至它的距离 D(v0 , vi ),若该两顶点之间没有边，则其距离为无穷大。求出其中距离最...
关于狄克斯特拉算法（dijkstra）总结
weixin_33827965的博客
06-17 159
1，2，4是四个定点其他的是距离，从2到4最直接的就是2-4，但是不是最近的，需要舒展一下2-1-4，这样只有8.所以才是最短的。这个过程就是狄克斯特拉算法。下面进入正题： 我们这里定义图的编号为： 1 2 3 4 5 6 7 8 9 图1：初始化的图，其中包含边的权值（耗时）。（这里图是有向图）。 图2：确定起点，然后向能直接走到的点走一下，记录此时的估...
迪克斯特拉算法 matlab
08-26
迪克斯特拉算法（Dijkstra's algorithm）是一种用于解决单源最短路径问题的算法。它可以找到从一个顶点到其他所有顶点的最短路径。 以下是使用 MATLAB 实现迪克斯特拉算法的示例代码： ```matlab function [distances, path] = dijkstra(graph, start) nodes = size(graph, 1); distances = inf(1, nodes); visited = false(1, nodes); previous = zeros(1, nodes); distances(start) = 0; for i = 1:nodes current = min_distance(distances, visited); visited(current) = true; neighbors = find(graph(current, :)); for j = 1:length(neighbors) neighbor = neighbors(j); if distances(current) + graph(current, neighbor) < distances(neighbor) distances(neighbor) = distances(current) + graph(current, neighbor); previous(neighbor) = current; end end end path = get_path(previous, start); end function index = min_distance(distances, visited) minDist = inf; index = -1; for i = 1:length(distances) if ~visited(i) && distances(i) < minDist minDist = distances(i); index = i; end end end function path = get_path(previous, start) path = []; current = start; while current ~= 0 path = [current path]; current = previous(current); end end ``` 你可以将这段代码保存为一个名为 `dijkstra.m` 的文件。然后，你可以通过以下方式调用该函数来计算最短路径： ```matlab graph = [0 4 0 0 0 0 0 8 0; 4 0 8 0 0 0 0 11 0; 0 8 0 7 0 4 0 0 2; 0 0 7 0 9 14 0 0 0; 0 0 0 9 0 10 0 0 0; 0 0 4 0 10 0 2 0 0; 0 0 0 14 0 2 0 1 6; 8 11 0 0 0 0 1 0 7; 0 0 2 0 0 0 6 7 0]; [start_node, end_node] = deal(1, 5); [distances, path] = dijkstra(graph, start_node); disp(['最短路径长度为：', num2str(distances(end_node))]); disp('最短路径为：'); disp(path); ``` 这是一个计算给定图形中从节点1到节点5的最短路径的示例。你可以根据自己的需求修改输入图形和起始节点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值