python矩阵/字典实现最短路径算法（Dijkstra）

前言：好像感觉各种博客的最短路径python实现都花里胡哨的？输出不明显，唉，可能是因为不想读别人的代码吧（明明自己学过离散）。然后可能有些人是用字典实现的？的确字典的话，比较省空间，随便了。改天，心情好，也用字典试下。先贴个图吧。

然后再贴代码：

_=inf=999999#inf

def Dijkstra_all_minpath(start,matrix):
    length=len(matrix)#该图的节点数
    path_array=[]
    temp_array=[]
    path_array.extend(matrix[start])#深复制
    temp_array.extend(matrix[start])#深复制
    temp_array[start] = inf#临时数组会把处理过的节点的值变成inf，表示不是最小权值的节点了
    already_traversal=[start]#start已处理
    path_parent=[start]*length#用于画路径，记录此路径中该节点的父节点
    while(len(already_traversal)<length):
        i= temp_array.index(min(temp_array))#找最小权值的节点的坐标
        temp_array[i]=inf
        path=[]#用于画路径
        path.append(str(i))
        k=i
        while(path_parent[k]!=start):#找该节点的父节点添加到path，直到父节点是start
            path.append(str(path_parent[k]))
            k=path_parent[k]
        path.append(str(start))
        path.reverse()#path反序产生路径
        print(str(i)+':','->'.join(path))#打印路径
        already_traversal.append(i)#该索引已经处理了
        for j in range(length):#这个不用多说了吧
            if j not in already_traversal:
                if (path_array[i]+matrix[i][j])<path_array[j]:
                    path_array[j] = temp_array[j] =path_array[i]+matrix[i][j]
                    path_parent[j]=i#说明父节点是i
    return path_array

#领接矩阵
adjacency_matrix=[[0,10,_,30,100],
                  [10,0,50,_,_],
                  [_,50,0,20,10],
                  [30,_,20,0,60],
                  [100,_,10,60,0]
                  ]
print(Dijkstra_all_minpath(4,adjacency_matrix))

然后输出：

2: 4->2
3: 4->2->3
0: 4->2->3->0
1: 4->2->1
[60, 60, 10, 30, 0]

主要是这样输出的话比较好看，然后这样算是直接算一个点到所有点的最短路径吧。那么写下字典实现吧

def Dijkstra_all_minpath_for_graph(start,graph):
    inf = 999999  # inf
    length=len(graph)
    path_graph={k:inf for k in graph.keys()}
    already_traversal=set()
    path_graph[start]=0
    min_node=start#初始化最小权值点
    already_traversal.add(min_node)#把找到的最小节点添加进去
    path_parent={k:start for k in graph.keys()}
    while(len(already_traversal)<=length):
        p = min_node
        if p!=start:
            path = []
            path.append(str(p))
            while (path_parent[p] != start):#找该节点的父节点添加到path，直到父节点是start
                path.append(str(path_parent[p]))
                p=path_parent[p]
            path.append(str(start))
            path.reverse()#反序
            print(str(min_node) + ':', '->'.join(path))#打印
        if(len(already_traversal)==length):break
        for k in path_graph.keys():#更新距离
            if k not in already_traversal:
                if  k in graph[min_node].keys() and (path_graph[min_node]+graph[min_node][k])<path_graph[k]:
                    path_graph[k]=path_graph[min_node]+graph[min_node][k]
                    path_parent[k]=min_node
        min_value=inf
        for k in path_graph.keys():#找最小节点
            if k not in already_traversal:
                if path_graph[k]<min_value:
                    min_node=k
                    min_value=path_graph[k]
        already_traversal.add(min_node)#把找到最小节点添加进去
    return path_graph
adjacency_graph={0:{1:10,3:30,4:100},
                 1:{0:10,2:50},
                 2:{1:50,3:20,4:10},
                 3:{0:30,2:20,4:60},
                 4:{0:100,2:10,3:60}}
print(Dijkstra_all_minpath_for_graph(4,adjacency_graph))

输出：

2: 4->2
3: 4->2->3
0: 4->2->3->0
1: 4->2->1
{0: 60, 1: 60, 2: 10, 3: 30, 4: 0}

还行吧，有时间再看看networkx这个库怎么说。