Dijkstra Algorithm 迪克特斯拉算法--Python

迪克斯拉特算法：

1、找出代价最小的节点，即可在最短时间内到达的节点；

2、更新节点的邻居的开销；

3、重复这个过程，直到图中的每个节点都这样做了；

4、计算最终路径。

'''

迪克斯特拉算法：

1、以字典的方式更新图，包括权重

2、创建开销字典，关键在于起点临近的点开销为实际数值，其他点为暂时未到达，开销为无穷，随后更新

3、创建父节点列表保存每个点的父节点，以便记录走过的路径

'''

from queue import LifoQueue

graph = {}

graph['start'] = {}

graph['start']['a'] = 6

graph['start']['b'] = 2

graph['a'] = {}

graph['a']['end'] = 4

graph['b'] = {}

graph['b']['a'] = 3

graph['b']['c'] = 2

graph['c'] = {}

graph['c']['end'] = 3

graph['end'] = {}

print(graph)

infinity = float('inf')

costs = {}

costs['a'] = 6

costs['b'] = 2

costs['c'] = infinity

costs['end'] = infinity

parents = {}

parents['a'] = 'start'

parents['b'] = 'start'

parents['c'] = 'b'

parents['end'] = 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

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)

#输出最短路径

p = 'end'

path = LifoQueue()

while(True):

    path.put(p)

    if(p == 'start'):

        break

    p = parents[p]

while not path.empty():

    print(path.get())