最短路径算法——Dijkstra介绍

个人心得体会：理解这种或这类算法，可以先从小规模的问题入手，并逐渐推广到问题变复杂的情况，这样理解起来也可以更方便和透彻。——和数学归纳法很相似。

图简介

以使用地图APP为例，假设你想前往某个目的地，此间有很多条线路可以选，如地铁、不同的公交换乘方案。而不同的方案所需换乘的次数不同。那么怎么才能选出换乘次数最少的方案呢？

有向图：节点和节点之间的连接是有方向的。

无向图：节点和节点之间相互联系。

上文提到的最优换乘方案选择，即可以用有向图进行抽象（总不能在同样的两个公交站之间来回换乘吧）。根据这个图，可以做的事：1. 观察是否有从“双子峰”前往“金门大桥”的路径，2. 最短路径是哪条。

此时图是为无权重的，即去每条路线的cost都相同。那么当考虑加权呢，即乘坐不同公交耗费时间不同，怎么来寻找前往目的地的最短时间？就需要适用于加权图的搜索算法出场，接下来介绍Dijkstra算法。

Dijkstra

主要解决的问题是给定起点S和目标点E，如何得出S到E的最短路径。算法主要思想是

带权的有向图

为什么不能处理负权边？

可能出现这样一种情况：因为dijktra算法每次都先寻找前往节点的最小值（正数），并将节点加入已访问集合之中，之后不再对其进行更新。

举个例子，目标：寻找A-C的最短路径。使用Dijkstra算法时，比较从A->B和A->C的开销，显然A->C的更小，于是选择到C的路径，并将C处理成处理过的节点。到这里发现了什么问题呢，A->B->C不是更短吗？就是负权边的情况。

Dijkstra算法实现步骤

1. 寻找某点开始，相邻的最短路径；
2. 选另一条路径，比较同样前往此节点的，更新开销最小的，并更新路径；
3. 重复此步骤，直到最后一个节点；
4. 计算最终路径。

示例

使用的数据结构：

1. graph：键值对，保存路径的长短信息
2. costs：数组，保存到达当前节点的最短路径
3. parent：键值对，保存最短路径

# coding: utf-8
# 以《图解算法》7.5中的图为例

def graph_gen():
    graph = {}
    graph['start'] = {}
    graph['start']['a'] = 6
    graph['start']['b'] = 2
    graph['b'] = {}
    graph['b']['a'] = 3
    graph['b']['end'] = 5
    graph['a'] = {}
    graph['a']['end'] = 1
    graph['end'] = {}
    return graph

def cost_gen():
    inifity = float('inf')
    costs = {}
    costs['a'] = 6
    costs['b'] = 2
    costs['end'] = inifity
    return costs

def parent_gen():
    parent = {}
    parent['a'] = 'start'
    parent['b'] = 'start'
    parent['end'] = None
    return parent

def find_lowest_cost_node(costs, processed):
    lowest_cost = float('inf')
    lowest_node = None
    for key in costs.keys():
        if key not in processed and lowest_cost > costs[key]:
                lowest_cost = costs[key]
                lowest_node = key
    return lowest_node

def Dijkstra(graph, costs, relation):
    processed = []
    node = find_lowest_cost_node(costs, processed)
    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
                relation[n] = node
        processed.append(node)
        node = find_lowest_cost_node(costs, processed)
    return relation

def output(realtion):
    begin = relation['end']
    str_ = 'end--'

    while begin is not None:
        for key, value in relation.items():
            if key == begin:
                str_ += begin + '__'
                begin = value
                break
        else:
            begin = None
    print str_ + 'start'

relation = Dijkstra(graph_gen(), cost_gen(), parent_gen())
# print relation
output(relation)

结果输出：因Dijkstra算法是从末尾指向头的key value类型，倒着就是最短路径

end--a__b__start