狄克斯特拉（Dijkstra）算法原理详细解释与实现(python)

目录

写在前面

1. 简介

2. 原理

2.1 找出最便宜的节点

2.2 计算前往该节点的各个邻居的开销

2.3 重复上面的步骤

实现

总结

---

写在前面

本文原理摘自《算法图解》这本书。

其实Dijkstra算法是广度优先搜索基础上扩展来的。无非是广度优先搜索按照层次关系，每一层级每一个节点都进行重复操作，直到找到合适的解法，接着进入下一层级。

Dijkstra算法是对每一层级每一个节点找到其符合条件解法，然后进行更新，接着进行下一层级。

 

1. 简介

广度优先算法可以找出段数最少的路径，但是对于路径上带权重的图，想要找出最快的路径，则需要使用狄克斯特拉算法。

2. 原理

为了说明狄克斯特拉算法的原理，使用换钢琴的的例子来做说明.
假设Rama想拿自己的乐谱换架钢琴：

Alex说：“这是我最喜欢的乐队Destroyer的海报，我愿意拿它换你的乐谱。
如果你再加5美元，还可拿乐谱换我这张稀有的Rick Astley黑胶唱片。”
Amy说：“哇，我听说这张黑胶唱片里有首非常好听的歌曲，我愿意拿我的吉他或架子鼓换这张海报或黑胶唱片。
Beethoven惊呼：“我一直想要吉他，我愿意拿我的钢琴换Amy的吉他或架子鼓。”
商品兑换的关系如下：

现在需要确定，Rama如何才能以最少的钱换到他想要的钢琴。

狄克斯特拉算法解决问题的思路主要包括以下四步： 

找出最便宜的节点，即可用最便宜的价格可前往的节点。
对于该节点的邻居，检查是否有前往它们的更短路径，如果有，就更新其开销。
重复这个过程，直到对图中的每个节点都这样做了。
计算最终路径
下面结合狄克斯特拉的算法步骤，对该问题进行推算。

2.1 找出最便宜的节点

对于乐谱而言，可以直接兑换唱片和海报，所需的费用分别为5和0.
为了观察的算法过程中数据的变化情况，使用一个表格来计算兑换的开销以及父节点的情况，对于目前开销的未知的节点用无穷大来表示，经过该步骤后，数据的情况如下：

2.2 计算前往该节点的各个邻居的开销

通过步骤1的处理，得知从乐谱->海波的开销是最小的。此时计算从海报到达各邻居节点的开销，如果邻居节点的开销变少了，则更新其开销和父节点。最终的结果如下：

2.3 重复上面的步骤

接下来还没有被遍历的节点中，最便宜的兑换商品为唱片，此时计算从唱片到达各邻居节点的开销，通过计算，从唱片到达吉他只需20,从唱片到达架子鼓只需25,因此需要更新结果表中吉他和架子鼓的父节点以及成本，最终结果如下：

接下来最便宜的节点是吉他，从吉他这个路径走，到钢琴的价格为40.接z最后是架子鼓，从架子鼓这个路径走，到钢琴的价格为35. 于是最终结果如下：

通过上述表格反推，花费最小的兑换路径为：乐谱–>唱片–>架子鼓–>钢琴，需要花费35.

实现

代码的实现中，需要维护三个散列表：

graph:用来描述顶点与边的关系,为了简单演示，可以直接使用字典的形式表示顶点与边。
costs:用来记录途径顶点的开销
parents:用来记录各顶点的父顶点情况
python代码如下：

  

   

    

     

    
    

     

      # -*- coding:utf-8 -*-
     
    
   

    

     

    
    

     

      # @Author：sunaihua
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      使用Dijkstra算法得到带权图的最短路径
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #graph 结构
     
    
   

    

     

    
    

     

      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
     
    
   

    

     

    
    

     

      # parent数据
     
    
   

    

     

    
    

     

      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
     
    
   

    

     

    
    

     
    
      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
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def dijkstra():
     
    
   

    

     

    
    

     

          node = find_lowest_cost_node(costs)
     
    
   

    

     

    
    

     
    
      while node 
      is 
      not 
      None:
     
    
   

    

     

    
    

     

              cost = costs[node]
     
    
   

    

     

    
    

     

              neighbors = graph[node]
     
    
   

    

     

    
    

     
        
      for n 
      in neighbors.keys():
     
    
   

    

     

    
    

     

                  new_cost = cost + neighbors[n]
     
    
   

    

     

    
    

     
            
      if costs[n] > new_cost:
     
    
   

    

     

    
    

     

                      costs[n] = new_cost
     
    
   

    

     

    
    

     

                      parents[n] = node
     
    
   

    

     

    
    

     

              processed.append(node)
     
    
   

    

     

    
    

     

              node = find_lowest_cost_node(costs)
     
    
   

    

     

    
    

     
    
      # 更具parents中的fin，向前反推，就可以得到最终的路径
     
    
   

    

     

    
    

     
    
      print parents
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      '__main__':
     
    
   

    

     

    
    

     

          dijkstra()
     
    
  

总结

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

关于最短路径求解：

最短路径的常用解法有迪杰克斯特拉算法Dijkstra Algorithm, 弗洛伊德算法Floyd-Warshall Algorithm, 和贝尔曼福特算法Bellman-Ford Algorithm，其中，Floyd算法是多源最短路径，即求任意点到任意点到最短路径，而Dijkstra算法和Bellman-Ford算法是单源最短路径，即单个点到任意点到最短路径。

 

 

转载：https://blog.csdn.net/qq_41687938/article/details/117404232