《算法图解》学习笔记—第7章 狄克斯特拉算法

前言

• 加权图（weighted graph）——带权重的图
• 狄克斯特拉算法，让你能够找出加权图中前往X的最短路径。
• 狄克斯特拉算法只适用于有向无环图（directed acyclic graph，DAG）。
• 狄克斯特拉算法假设：对于处理过的海报节点，没有前往该节点的更短路径。这种假设仅在没有负权边时才成立。因此，不能将狄克斯特拉算法用于包含负权边的图。在包含负权边的图中，要找出最短路径，可使用另一种算法——贝尔曼-福德算法（Bellman-Ford
  algorithm）。

---

狄克斯特拉算法

算法步骤

要计算非加权图中的最短路径，可使用广度优先搜索。要计算加权图中的最短路径，可使用狄克斯特拉算法

狄克斯特拉算法包含4个步骤。
(1) 找出“最便宜”的节点，即可在最短时间内到达的节点。
(2) 更新该节点的邻居的开销，其含义将稍后介绍。
(3) 重复这个过程，直到对图中的每个节点都这样做了。
(4) 计算最终路径。

实例：拿一本乐谱换架钢琴。

第一步：找出最便宜的节点。在这里，换海报最便宜，不需要支付额外的费用。找出图中最便宜的节点，并确保没有到该节点的更便宜的路径！

第二步：计算前往该节点的各个邻居的开销。

现在的表中包含低音吉他和架子鼓的开销。这些开销是用海报交换它们时需要支付的额外费用，因此父节点为海报。这意味着，要到达低音吉他，需要沿从海报出发的边前行，对架子鼓来说亦如此。

再次执行第一步：下一个最便宜的节点是黑胶唱片——需要额外支付5美元。

再次执行第二步：更新黑胶唱片的各个邻居的开销。

你更新了架子鼓和吉他的开销！这意味着经“黑胶唱片”前往“架子鼓”和“吉他”的开销更低，因此你将这些乐器的父节点改为黑胶唱片。
下一个最便宜的是吉他，因此更新其邻居的开销。

最后，对最后一个节点——架子鼓，做同样的处理。

通过沿父节点回溯，便得到了完整的交换路径。

实现

使用代码来实现狄克斯特拉算法，这里以下面的图为例。

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

存储邻居的散列表代码如下：

graph = {}
graph["start"] = {}
graph["start"]["a"] = 6
graph["start"]["b"] = 2

因此graph[“start”]是一个散列表。要获取起点的所有邻居，可像下面这样做。

>>> print graph["start"].keys()
["a", "b"]

有一条从起点到A的边，还有一条从起点到B的边。要获悉这些边的权重，可以

>>> print graph["start"]["a"]
2
>>> print graph["start"]["b"]
6

添加其他节点及其邻居。

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

狄克斯特拉算法代码如下：

node = find_lowest_cost_node(costs) #在未处理的节点中找出开销最小的节点
while node is not None: #这个while循环在所有节点都被处理过后结束
     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) #找出接下来要处理的节点，并循环

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

代码的执行过程：

找出开销最低的节点。

获取该节点的开销和邻居。

遍历邻居。

每个节点都有开销。开销指的是从起点前往该节点需要多长时间。在这里，你计算从起点出发，经节点B前往节点A（而不是直接前往节点A）需要多长时间。

接下来对新旧开销进行比较。

找到了一条前往节点A的更短路径！因此更新节点A的开销。

这条新路径经由节点B，因此节点A的父节点改为节点B。

现在回到了for循环开头。下一个邻居是终点节点。

经节点B前往终点需要多长时间呢？

需要7分钟。终点原来的开销为无穷大，比7分钟长。设置终点节点的开销和父节点。

你更新了节点B的所有邻居的开销。现在，将节点B标记为处理过。

找出接下来要处理的节点，直到处理完所有的节点。