《算法图解》读书笔记二第六章广度优先搜索图：图模拟一组连接，由节点（node）和边（edge）组成，一个节点可能与

第六章广度优先搜索

图：

图模拟一组连接，由节点（node）和边（edge）组成，一个节点可能与众多节点直接相连，这些节点被称为邻居。

在下图中，Rama是Alex的邻居。Adit不是Alex的邻居，因为他们不直接相连。但Adit既是Rama的邻居，又是Tom的邻居。

使用散列表实现图，散列表能够将键映射到值。在图中，需要将节点映射到其所有邻居。

有向图含有箭头，关系是单向的；而无向图不包含箭头，直接相连的节点互为邻居。

寻找最短路径步骤：

使用图来建立问题模型
使用广度优先搜索解决问题

广度优先搜索

广度优先搜索是一种能够找出两样东西之间的最短距离的图算法，即用来解决最短路径问题。

用来回答两个问题（通过广度优先搜索从起点开始逐渐向外延伸，即先检查一度关系，再检查二度关系；通过队列queue按添加顺序进行检查）：

从节点A出发，有前往节点B的路径吗？
从节点A出发，前往节点B的哪条路径最短？

算法原理：

def search(name):
    search_queue = deque() # 待检查的队列
    search_queue += graph[name] # 将name的关系网添加到队列中
    searched = [] # 已检测的节点
    while search_queue: 
        person = search_queue.popleft()
        if not person in searched: # 节点未检查过
            if person_is_seller(person):
                print person + " is a mango seller!"
                return True
            else :
                search_queue += graph[person]
                searched.append(person)
                return False

运行时间:

在搜索中，将沿每条边前行，因此运行时间至少为O(边数)；还使用了一个队列存储要检查的人，将所有人添加到队列的总时间为O(人数)。所以，广度优先搜索的运行时间为O(人数 + 边数)，这通常写作O(V + E)，其中V为顶点（vertice）数，E为边数。

队列

队列类似于栈，不能随机地访问队列中的元素。只支持两种操作：入队和出队。

队列是一种先进先出（First In First Out，FIFO）的数据结构，而栈是一种后进先出（Last In First Out，LIFO）的数据结构。

第七章狄克斯特拉算法

在前一章，使用了广度优先搜索来查找两点之间的最短路径，那时“最短路径”的意思是段数最少。在狄克斯特拉算法中，给每段都分配了一个权重（weight），因此狄克斯特拉算法找出的是总权重最小的路径。

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

图还可能有环，这意味着你可从一个节点出发，走一圈后又回到这个节。因此环增加了权重，绕环的路径不可能是最短的路径。无向图意味着两个节点彼此指向对方，其实就是环！因此，狄克斯特拉算法只适用于有向无环图。

狄克斯特拉算法步骤：

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

狄克斯特拉算法实现（以下图为例）：

实现散列表，将节点所有邻居都存储在散列表中；

// 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"] = {}

// costs表（节点开销）
infinity = float("inf") 
costs = {} 
costs["a"] = 6 
costs["b"] = 2 
costs["fin"] = infinity // 无穷大

// parents表（父节点）
parents = {} 
parents["a"] = "start" 
parents["b"] = "start" 
parents["fin"] = None

// 记录处理过的节点
processed = []

实现算法代码

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) #找出接下来要处理的节点，并循环

# 找出开销最低的节点
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

《算法图解》读书笔记二

第六章 广度优先搜索

第七章 狄克斯特拉算法

第六章广度优先搜索

第七章狄克斯特拉算法