算法快学笔记（十三）：狄克斯特拉（Dijkstra）算法原理与实现

约定不等于承诺〃 2022-01-15 14:19 314阅读 0赞

# 1. 简介 #

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

# 2. 原理 #

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

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

商品兑换的关系如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bjc1NDU1MjY_size_16_color_FFFFFF_t_70]

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

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

1.  找出最便宜的节点，即可用最便宜的价格可前往的节点。
2.  对于该节点的邻居，检查是否有前往它们的更短路径，如果有，就更新其开销。
3.  重复这个过程，直到对图中的每个节点都这样做了。
4.  计算最终路径

下面结合狄克斯特拉的算法步骤，对该问题进行推算。

## 2.1 找出最便宜的节点 ##

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

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

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

# 2.3 重复上面的步骤 #

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

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

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

# 实现 #

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

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

代码如下：

# -*- 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.  如果图中包含负权边，请使用贝尔曼-福德算法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N1bjc1NDU1MjY_size_16_color_FFFFFF_t_70]: /images/20220115/9c302ac896494445b88bb5f0e3bda4d6.png