首先，非常感谢b站up主对于Dijkstra算法的介绍，受益匪浅，关于这个算法的视频链接在这[Python学习]实现迪杰斯特拉算法并生成最短路径。我也是跟着这位up主才算慢慢懂了这个算法的具体情况。下面，本文就关于Dijksta算法进行相关解释以及python代码实现和案例分析。
目录
一、背景
最短路算法不仅可以解决任意两个地点之间的最短路径，还可以解决诸如管道铺设、线路安全、工厂布局、设备更新等问题。
这里就不讲关于图论的一些东西，讲起来有点复杂，在能理解本文的基础上，给大家先说一下如何去理解下面这个图
可以看到，图上有些点是直接连接的，有些是没有。对于直连的，如A到B，线上有标注2，即为A到B的距离，但对于A到C，这种没有直接连接的点，记它的距离为无穷大。节点即图上的点。本文使用的例图为无向图，即表示可以从A到B，也可以从B到A。对于有向图的即表示只能顺着箭头方向走，不能往回走，距离也就为无穷大。
本文主要讲最短路算法中的Dijksta算法，它适用于路权非负的情况。具体步骤简化理解大概就是（个人理解，如有误，欢迎大佬批评指正）：
1.先确定起始点，起始点与起始点之间的距离为0
2.确定终点，找出起始点能到达终点的全部路径
3.通过迭代，找出起始点到终点的最短距离，并对它进行标记
乍一看，很简单，然而，并不然，如果起始点与终点之间存在很多中间点时，就很难通过人工计算。下面，通过python去实现诸如上述三个步骤。
二、 代码及解释
以上图为例子， 我们输入的矩阵就是network，也就是常说的邻接矩阵，这个矩阵为方阵。第一行第一列的数据为A到自A的距离。但里面的零并不一定表示自己到自己的距离，例如第一行第五列，表示A到E是没有直连的，这可能跟我上面说的无穷有些矛盾，不过算法真正运行的不是这个矩阵，所以先不用管。仔细观察，可以发现这个矩阵是对称的，当然，也仅限于无向图。
定义函数，s为起始点，d为终点
path是一个空列表，用于储存从某点到某点的最短路径，从这里看出s到d的最短路径需要经过哪些点。
n为节点个数。
对于fmax，引用numpy库中的inf，意味无穷大。
w为构造的与输入矩阵network同样维数的0矩阵，用于算法运行。
book为一个列表，元素个数为节点数，它的作用是，当已经确定某点到某点的最小距离时，进行标记，若有其他路径包括这条路径，即可减少程序的计算。
dis为最终返回的路径列表，表示从某点到某点的最小路径，一共有n个。
minpath存储某点到某点的中会经过的节点。path中的节点由它决定。
import numpy as np
network = np.array([[0,2,4,0,0,0,0],
[2,0,0,3,3,1,0],
[4,0,0,2,3,1,0],
[0,3,2,0,0,0,1],
[0,3,3,0,0,0,3],
[0,1,1,0,0,0,4],
[0,0,0,1,3,4,0]])
def Dijkstra(network,s,d): # 迪杰斯特拉算法算s到t的最短路径，并返回该路径和距离
print("Start Dijstra Path……")
path = [] # 储存s到d的最短路径
n = len(network) # 节点个数
fmax = np.inf
w = [[0 for i in range(n)] for j in range(n)]
book = [0 for i in range(n)] # 是否已经是最小的标记列表
dis = [fmax for i in range(n)] # s到其他节点的最小距离
book[s-1] = 1 # 节点编号从1开始，列表序号从0开始
midpath = [-1 for i in range(n)] # 上一跳列表这一步就是将w矩阵初始化，变成程序能够处理的标准矩阵，处理后的w中直连或者本身为fmax。对于i=s-1，其实是因为列表的序号是从0开始的，而我们习惯是从1开始
'''这个循环把原矩阵中的0标价为fmax，且认为直连就是最短（但事实并非如此）'''
for i in range(n):
for j in range(n):
if network[i][j] != 0:
w[i][j] = network[i][j] # 0→max
else:
w[i][j] = fmax
if i == s-1 and network[i][j] != 0: # 直连的节点最小距离就是network[i][j]
dis[j] = network[i][j]接下来就是算法的主体部分，n-1次循环就是除了s的节点外的其他节点，for循环中第一个min是会不断更新的，直到找到最短距离，它的作用即在下方的if判断中，检查是不是距离是不是小于min，如果是的话，对min进行更新，否则用u进行记录，标记出已经找出最小路径的点。dis最初的元素全为fmax，通过迭代更新其中的元素，此时通过这个for循环得到的还不是最小的，要在经过下一个循环。不过，最终得到的都是最小路径。例如dis输出为[inf, 2, 4, 5, 5, 3, 6]，即表示从第一个点出发，依次到各个点的最小距离。
下一个以v为元素遍历的for循环中，这一步用于比较直连是否是最短，如果不是，则换其他的，同时对minpath列表进行更新。此时最短距离已经更新完毕，接下来是得到路径。
j=d-1的解释和上面的i一样，都是由于习惯不同。
'''算法主体'''
for i in range(n-1): # n-1次遍历，除了s节点
min = fmax # min的值是一直变化的
for j in range(n):
if book[j] == 0 and dis[j] < min: # 如果未遍历且距离最小，反复比较得出最短距离
min = dis[j]
u = j
book[u] = 1 # 标记已到达的节点
# u处于一个循环体内，从2到7遍历
for v in range(1,n): # u直连的节点遍历一遍
'''关键步骤，用于比较与此节点直连的节点的长度'''
if dis[v] > dis[u] + w[u][v]:
dis[v] = dis[u] + w[u][v]
midpath[v] = u+1 # 上一跳更新
j = d-1 # j是序号
path.append(d) # 因为存储的是上一跳，所以先加入目的节点d，最后倒置在此循环中，只是s到d的最短路径，并不包括其他点之间。
对于后面那个reverse方法，从上面path添加d就可以知道，需要转置，要不然就是反的
while midpath[j] != -1:
path.append(midpath[j])
j = midpath[j]-1
path.append(s)
path.reverse() # 倒置列表
print('path:',path)
print(dis)至此，算法也就完成了，接下来，调用这个函数就行，试验用A到G的最短路，即1到7.
Dijkstra(network,1,7)
结果表示，从A到G的最短距离为6，路径为A—B—D—G。整个算法想要完整理解还是稍微有点困难（大佬避开嘿嘿），大家可以反复观看以下，以下给出完整得代码，便于观察。
import numpy as np
def Dijkstra(network,s,d): # 迪杰斯特拉算法算s到t的最短路径，并返回该路径和代价
print("Start Dijstra Path……")
path = [] # 储存s到t的最短路径
n = len(network) # 节点个数
fmax = np.inf
w = [[0 for i in range(n)] for j in range(n)]
book = [0 for i in range(n)] # 是否已经是最小的标记列表
dis = [fmax for i in range(n)] # s到其他节点的最小距离
book[s-1] = 1 # 节点编号从1开始，列表序号从0开始
midpath = [-1 for i in range(n)] # 上一跳列表
# 此步可以省略，只要输入矩阵规范就可
'''这个循环把原矩阵中的0标价为fmax，且认为直连就是最短（但事实并非如此）'''
for i in range(n):
for j in range(n):
if network[i][j] != 0:
w[i][j] = network[i][j] # 0→max
else:
w[i][j] = fmax
if i == s-1 and network[i][j] != 0: # 直连的节点最小距离就是network[i][j]
dis[j] = network[i][j]
# print('dis:',dis)
'''算法主体'''
for i in range(n-1): # n-1次遍历，除了s节点
min = fmax # min的值是一直变化的
for j in range(n):
if book[j] == 0 and dis[j] < min: # 如果未遍历且距离最小，反复比较得出最短距离
min = dis[j]
u = j
# print('book:',book)
book[u] = 1 # 标记已到达的节点
# print('u:',u)
# print('dis:',dis)
# u处于一个循环体内，从2到7遍历
for v in range(1,n): # u直连的节点遍历一遍
'''关键步骤，用于比较与此节点直连的节点的长度'''
if dis[v] > dis[u] + w[u][v]:
dis[v] = dis[u] + w[u][v]
midpath[v] = u+1 # 上一跳更新
j = d-1 # j是序号
path.append(d) # 因为存储的是上一跳，所以先加入目的节点d，最后倒置
while midpath[j] != -1:
path.append(midpath[j])
j = midpath[j]-1
path.append(s)
path.reverse() # 倒置列表
print('path:',path)
print(midpath)
print(dis)
network = np.array([[0,2,4,0,0,0,0],
[2,0,0,3,3,1,0],
[4,0,0,2,3,1,0],
[0,3,2,0,0,0,1],
[0,3,3,0,0,0,3],
[0,1,1,0,0,0,4],
[0,0,0,1,3,4,0]])
Dijkstra(network,1,7)
三、 第三方库解决方法
如果大家实在看不懂上面的代码，但又想用这个方法，这边给出了第三方库的解决方案，使用networkx库，由于对这个库了解不是很深，目前我只知道这个库可以画这类图，以及用Dijkstra算法求最短路，最大流问题。接下来就用代码，跟大家介绍以下这个方法
import networkx as nx
dis = [(0,1,2),(0,2,4),(1,3,3),(1,4,3),(1,5,1),(2,3,2),(2,4,3),(2,5,1),(3,6,1),
(4,6,3),(5,6,4)]
g = nx.Graph()
g.add_weighted_edges_from(dis)
a = nx.to_numpy_matrix(g,nodelist=range(7))
p = nx.dijkstra_path(g,source=0,target=6,weight='weight')
d = nx.dijkstra_path_length(g,0,6,weight='weight')
print('最短路径为p={},最短距离为d={}'.format(p,d))
同样是用上面的例子，但是对比之下，代码就少了很多。简单介绍一下。
第一个dis是一个列表，（0，1，2）表示从A到B的距离为2，，以此类推。
g为初始化一个图，Graph表示生成无向图。
接下来为图添加节点和路权，参数为dis
a对应生成的邻接矩阵。
p使用Dijkstra算法得到最短路径，d得到最短距离。
可以看出，和上面的代码算法得到结果一致，不过要看那个p列表，可以全部元素＋1，即和上面的代码运行结果一致。
四、 案例——设备更新问题
接下来用一道题实践一下，虽然跟直接说某点到某点之间的最短路径不同，但是本质是一样的。不过这题我也只是试了一下，不一定保证对，所以大家可以思考一下，希望能对大家有所启发。
某企业在今后5年内需使用一台机器，该种机器的每年购置费和维修费（与机器的役龄有关）如下表所示。试制定机器购置和更新计划，使5年内的成本最小。
| 年份 | 1 | 2 | 3 | 4 | 5 |
| 购置费 维修费 | 11 5 | 11 6 | 12 8 | 12 11 | 13 18 |
我的想法是这样的：
令表示第i年初买进用到第j-1年末中所包含的所有费用，此时wij即包含第i年买进时的购置费和j-i年的维修费用，故可知
用networkx库画出对应的图，如下所示：
最终用代码解得，第一年买进用到第三年，然后在第三年买入用到第五年末，可使费用最低，为53单位。下面为代码
import networkx as nx
import numpy as np
import pylab as plt
dis = [(1,5,41),(1,4,30),(1,3,22),(1,2,16),(1,6,59),(2,3,16),
(2,4,23),(2,5,30),(2,6,41),(3,4,17),(3,5,23),(3,6,31),
(4,5,17),(4,6,28),(5,6,18)]
g = nx.DiGraph()
g.add_nodes_from(range(1,7))
g.add_weighted_edges_from(dis)
pos = nx.shell_layout(g)
w = nx.get_edge_attributes(g,'weight')
nx.draw(g,pos,with_labels=True,font_weight='bold',font_size=12)
nx.draw_networkx_edge_labels(g,pos,edge_labels=w)
plt.show()
a = nx.to_numpy_matrix(g,nodelist=range(1,7))
p = nx.dijkstra_path(g,source=1,target=6,weight='weight')
d = nx.dijkstra_path_length(g,1,6,weight='weight')
print(p,d,sep='\n')g.add_nodes_from表示增加节点，g.add_weighted_edges_from表示增加路权，参数位dis，pos为作图的一个参数，代码从w开始到plt.show都是为作图环节（如不需要，可以忽略）。接下来和上面示例一致，用Dijkstra算法解决。
五、 总结
使用算法一步一步算还是比较困难的，所谓算法就是给人想的，程序是代码想的，关键就是如何让电脑理解你的想法，不过这个Dijkstra算法有现成的库还是比较方便的，当然也不要只是局限于求某点到某点的最短距离，可以引申一下，达到真正理解。
算法，还是需要多练。对于上面的代码和算法的解释，如果有错误的地方，欢迎各位大神批评指正。有不懂的地方，也可以评论区或者直接私信我。
创作不易，谢谢点赞——收藏——关注！！！
5252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
