zoukankan      html  css  js  c++  java
  • [笔记]《算法图解》第七章 狄克斯特拉算法

    算法介绍

    dijkstra算法介绍:是从一个顶点到其余各顶点的[最短路径算法,解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。

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

    相关术语

    狄克斯特拉算法用于每条边都有关联数字的图,这些数字称为权重(weight)。
    带权重的图称为加权图(weighted graph),不带权重的图称为非加权图(unweighted graph)。
    要计算非加权图中的最短路径,可使用广度优先搜索。要计算加权图中的最短路径,可使用狄克斯特拉算法。
    狄克斯特拉算法只适用于有向无环图(directed acyclic graph,DAG)

    代码实现

        # -*-coding:utf-8-*-  
        # 用散列表实现图的关系  
        graph = {}  
        graph["start"] = {}  
        graph["start"]["a"] = 6  
        graph["start"]["b"] = 2  
        
        graph["a"] = {}  
        graph["a"]["end"] = 1  
        
        graph["b"] = {}  
        graph["b"]["a"] = 3  
        graph["b"]["end"] = 5  
        
        graph["end"] = {}  
          
        # 创建节点的开销表,开销是指从start到该节点的权重  
        # 无穷大   
        infinity = float("inf")  
        costs = {}  
        costs["a"] = 6  
        costs["b"] = 2  
        costs["end"] = infinity  
          
        # 父节点散列表  
        parents = {}  
        parents["a"] = "start"  
        parents["b"] = "start"  
        parents["end"] = None  
          
        # 已经处理过的节点,需要记录  
        processed = []  
          
        # 找到开销最小的节点  
        def find_lowest_cost_node(costs):  
            # 初始化数据  
            lowest_cost = infinity  
            lowest_cost_node = None  
            # 遍历所有节点  
            for node in costs:  
                # 该节点没有被处理  
                if not node in processed:  
                    # 如果当前节点的开销比已经存在的开销小,则更新该节点为开销最小的节点  
                    if costs[node] < lowest_cost:  
                        lowest_cost = costs[node]  
                        lowest_cost_node = node  
            return lowest_cost_node  
          
        # 找到最短路径  
        def find_shortest_path():  
            node = "end"  
            shortest_path = ["end"]  
            while parents[node] != "start":  
                shortest_path.append(parents[node])  
                node = parents[node]  
            shortest_path.append("start")  
            return shortest_path  
          
          
        #寻找加权的最短路径  
        def dijkstra():  
            # 查询到目前开销最小的节点  
            node = find_lowest_cost_node(costs)  
            # 只要有开销最小的节点就循环  
            while node is not None:  
                # 获取该节点当前开销  
                cost = costs[node]  
                # 获取该节点相邻的节点  
                neighbors = graph[node]  
                # 遍历这些相邻节点  
                for n in neighbors :  
                    # 计算经过当前节点到达相邻结点的开销,即当前节点的开销加上当前节点到相邻节点的开销  
                    new_cost = cost + neighbors[n]  
                    # 如果计算获得的开销比原本该节点的开销小,更新该节点的开销和父节点  
                    if new_cost < costs[n]:  
                        costs[n] = new_cost  
                        parents[n] = node  
                # 遍历完毕该节点的所有相邻节点,说明该节点已经处理完毕  
                processed.append(node)  
                # 去查找下一个开销最小的节点,若存在则继续执行循环,若不存在结束循环  
                node = find_lowest_cost_node(costs)  
            # 循环完毕说明所有节点都已经处理完毕  
            shortest_path = find_shortest_path()  
            shortest_path.reverse()  
            print(shortest_path)  
                  
          
        # 测试  
        dijkstra()
    
    

    小结:

    • 广度优先搜索用于在非加权图中查找最短路径。
    • 狄克斯特拉算法用于在加权图中查找最短路径。
    • 仅当权重为正时狄克斯特拉算法才管用。
    • 如果图中包含负权边,请使用贝尔曼-福德算法。
  • 相关阅读:
    MD5算法MFC实现
    asp.net2.0新特点
    file format
    C专家编程第二章学习笔记
    Bye Czech golden generation
    中间层
    学完谭C之后
    C语言学习之路
    荀子劝学篇
    C语言常用转义字符表
  • 原文地址:https://www.cnblogs.com/everfight/p/grokking_algorithms_note_7.html
Copyright © 2011-2022 走看看