参考文章：https://blog.csdn.net/weixin_42875283/article/details/124341524
一．传统方式下物流最短路径
Dijkstra是一种贪心算法，所谓贪心算法即始终保持当前的迭代解为当前最优解。它也是用来做路径规划问题，是单源最短路径问题的求解方法。
单源最短路径是指给定一个网络，指定一个起点a，终点e，求两点之间的最短路径。
Dijkstra算法原理及实现步骤
算法的思路
起点为A点，终点为G点，B、C、D、E、F均为节点，每条线具备不同的代价值。每个节点除节点名之外，具备两个属性值：node_cost和parent。
node_cost记录当前节点到起点的已知节点的已知的最小总代价值，会随着规划路径不同而改变。
parent是指节点对应的父节点，例如E节点对应的父节点可以是B、C、F，由规划路径决定。
为了更好更清晰地分析此模型，用红色代表终点，天蓝色代表节点未完成遍历，橙色代表节点已经完成遍历，白色代表尚未纳入考虑范围。在算法开始之前，设定起点node_cost为0，其余节点node_cost设为无穷（inf），所有节点的parent设为空。
Dijkstra算法的核心是利用一次次的迭代过程找到一条node_cost最小的规划路径。从起点出发，计算其相邻的节点的node_cost，计算方式就是将起点的代价值与路径的代价相加，如果计算得到的node_cost值小于之前节点本身的node_cost值，就将其作为新的node_cost值，使其node_cost更小的节点成为其parent，并将节点表示为（节点名，node_cost值，parent），再将node_cost小的未遍历的节点作为新的起点，以此规律进行迭代。
程序设计
(1)设置地图
import numpy as np
#构建地图
mapping_list = [[np.inf for i in range(0, 7)] for i in range(0, 7)] # 构建全是无穷大的二维列表
for i in range(0, 7):
mapping_list[i][i] = 0 # 对角线处的值为0
mapping_list[0][1] = 24
mapping_list[0][2] = 8
mapping_list[0][3] = 15
mapping_list[1][4] = 6
mapping_list[2][4] = 7
mapping_list[2][5] = 3
mapping_list[3][5] = 5
mapping_list[3][6]= 4,
mapping_list[4][5] = 2
mapping_list[4][6] = 9
mapping_list[5][6] = 10
mapping_list[1][0] = 24
mapping_list[2][0] = 8
mapping_list[3][0] = 15
mapping_list[4][1] = 6
mapping_list[4][2] = 7
mapping_list[5][2] = 3
mapping_list[5][3] = 5
mapping_list[6][3]= 4,
mapping_list[5][4] = 2
mapping_list[6][4] = 9
mapping_list[6][5] = 10
mapping_list = np.array(mapping_list) # 将mapping_list转换成数组形式
print(mapping_list)
(2)初始化
# 初始化
node_cost = [[np.inf for i in range(0, 3)] for i in range(0, 7)] # 构建全是无穷大的二维列表
#arr这个数组用来表示每个节点的[节点名 node_cost 父节点]
for i in range(0, 7):
node_cost[i][0] = i
# 计算A点与它相邻的节点，更新其node_cost和父节点,并且将A点放入close_list里面
node0 = 0
close_list = []
for i in range(0, 7):
if mapping_list[int(node0)][i] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[int(node0)][i]
close_list.append(int(node0))
(3)构建函数以实现迭代
构建函数用来选择node_cost最小的节点，记作node0
# 构建函数用来选择node_cost最小的节点
# 选择node_cost值最小的节点->node 0
def choose_min(node_cost, close_list):
node_cost = np.array(node_cost) # 将node_cost从list转换成array
open_list = list(set(node_cost[:, 0].tolist()) - set(close_list)) # 建立一个open_list放入没有被遍历的点
final_list = []
for i in open_list:
final_list.append(node_cost[int(i)].tolist())
final_list = np.array(final_list) # final_list转换成array，才可以利用np.where找最小值
node0 = final_list[np.where(final_list[:, 1] == final_list[:, 1].min())][0][0] # 将node_cost最小的点的节点名给node0
return int(node0)
构建count_cost函数用来计算相邻节点的node_cost
# 构建count_cost函数用来计算相邻节点的node_cost
# 计算node0邻节点的node_cost，此时的node_cost值就是地图上的代价值加上父节点的代价值，如果已经比原来小则更新node_cost和父节点
# 并将node0放入close_list里面
def count_cost(mapping_list, node_cost, close_list):
for i in range(0, 7):
if mapping_list[node0][i] + node_cost[node0][1] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[node0][i] + node_cost[node0][1]
close_list.append(node0)
return [node_cost, close_list]
(4)开始迭代
#始迭代----->迭代中止的条件：终点在close_list里面
while 6 not in close_list:
node0 = choose_min(node_cost, close_list) # 找node_cost最小的节点
[node_cost, close_list] = count_cost(mapping_list, node_cost, close_list) # 计算邻节点
# print(close_list)
xn = 6
x0 = 0
destination_list = [xn]
print("最短的路径代价为:", node_cost[xn][1])
while x0 not in destination_list:
xn = node_cost[xn][2]
destination_list.append(xn)
print("最短路径为：", destination_list)
整体程序
import numpy as np
# 构建地图
mapping_list = [[np.inf for i in range(0, 7)] for i in range(0, 7)] # 构建全是无穷大的二维列表
for i in range(0, 7):
mapping_list[i][i] = 0 # 对角线处的值为0
mapping_list[0][1] = 24
mapping_list[0][2] = 8
mapping_list[0][3] = 15
mapping_list[1][4] = 6
mapping_list[2][4] = 7
mapping_list[2][5] = 3
mapping_list[3][5] = 5
mapping_list[3][6]= 4,
mapping_list[4][5] = 2
mapping_list[4][6] = 9
mapping_list[5][6] = 10
mapping_list[1][0] = 24
mapping_list[2][0] = 8
mapping_list[3][0] = 15
mapping_list[4][1] = 6
mapping_list[4][2] = 7
mapping_list[5][2] = 3
mapping_list[5][3] = 5
mapping_list[6][3]= 4,
mapping_list[5][4] = 2
mapping_list[6][4] = 9
mapping_list[6][5] = 10
mapping_list = np.array(mapping_list) # 将mapping_list转换成数组形式
# print(mapping_list)
# 初始化
node_cost = [[np.inf for i in range(0, 3)] for i in range(0, 7)] # 构建全是无穷大的二维列表
# arr这个数组用来表示每个节点的[节点名 node_cost 父节点]
for i in range(0, 7):
node_cost[i][0] = i
# 计算A点与它相邻的节点，更新其node_cost和父节点,并且将A点放入close_list里面
node0 = 0
close_list = []
for i in range(0, 7):
if mapping_list[int(node0)][i] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[int(node0)][i]
close_list.append(int(node0))
# 构建一系列函数以实现迭代功能
# 构建函数用来选择node_cost最小的节点
# 选择node_cost值最小的节点->node 0
def choose_min(node_cost, close_list):
node_cost = np.array(node_cost) # 将node_cost从list转换成array
open_list = list(set(node_cost[:, 0].tolist()) - set(close_list)) # 建立一个open_list放入没有被遍历的点
final_list = []
for i in open_list:
final_list.append(node_cost[int(i)].tolist())
final_list = np.array(final_list) # final_list转换成array，才可以利用np.where找最小值
node0 = final_list[np.where(final_list[:, 1] == final_list[:, 1].min())][0][0] # 将node_cost最小的点的节点名给node0
return int(node0)
# -------------------------------------------------------------------------------------------------------
# 构建count_cost函数用来计算相邻节点的node_cost
# 计算node0邻节点的node_cost，此时的node_cost值就是地图上的代价值加上父节点的代价值，如果已经比原来小则更新node_cost和父节点
# 并将node0放入close_list里面
def count_cost(mapping_list, node_cost, close_list):
for i in range(0, 7):
if mapping_list[node0][i] + node_cost[node0][1] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[node0][i] + node_cost[node0][1]
close_list.append(node0)
return [node_cost, close_list]
# 开始迭代----->迭代中止的条件：终点在close_list里面
while 6 not in close_list:
node0 = choose_min(node_cost, close_list) # 找node_cost最小的节点
[node_cost, close_list] = count_cost(mapping_list, node_cost, close_list) # 计算邻节点
# print(close_list)
#起始点
xn = 4
x0 = 0
destination_list = [xn]
print("最短的路径代价为:", node_cost[xn][1])
while x0 not in destination_list:
xn = node_cost[xn][2]
destination_list.append(xn)
print("最短路径为：", destination_list[::-1])
运行结果：
最短的路径代价为: 13.0
最短路径为： [0, 2, 5, 4]
即a-c-f-e，符合要求
拓展到n>=10的实例
添加：
import numpy as np
# 构建地图
mapping_list = [[np.inf for i in range(0, 10)] for i in range(0, 10)] # 构建全是无穷大的二维列表
for i in range(0, 10):
mapping_list[i][i] = 0 # 对角线处的值为0
mapping_list[0][1] = 24
mapping_list[0][2] = 8
mapping_list[0][3] = 15
mapping_list[1][4] = 6
mapping_list[2][4] = 7
mapping_list[2][5] = 3
mapping_list[3][5] = 5
mapping_list[3][6]= 4,
mapping_list[4][5] = 2
mapping_list[4][6] = 9
mapping_list[5][6] = 10
mapping_list[1][0] = 24
mapping_list[2][0] = 8
mapping_list[3][0] = 15
mapping_list[4][1] = 6
mapping_list[4][2] = 7
mapping_list[5][2] = 3
mapping_list[5][3] = 5
mapping_list[6][3]= 4,
mapping_list[5][4] = 2
mapping_list[6][4] = 9
mapping_list[6][5] = 10
mapping_list[0][9] = 15
mapping_list[1][7] = 23
mapping_list[1][9] = 13
mapping_list[6][8] = 19
mapping_list[7][8] = 12
mapping_list[9][0] = 15
mapping_list[7][1] = 23
mapping_list[9][1] = 13
mapping_list[8][6] = 19
mapping_list[8][7] = 12
mapping_list = np.array(mapping_list) # 将mapping_list转换成数组形式
# print(mapping_list)
# 初始化
node_cost = [[np.inf for i in range(0, 3)] for i in range(0, 10)] # 构建全是无穷大的二维列表
# arr这个数组用来表示每个节点的[节点名 node_cost 父节点]
for i in range(0, 10):
node_cost[i][0] = i
# 计算A点与它相邻的节点，更新其node_cost和父节点,并且将A点放入close_list里面
node0 = 0
close_list = []
for i in range(0, 10):
if mapping_list[int(node0)][i] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[int(node0)][i]
close_list.append(int(node0))
# 构建一系列函数以实现迭代功能
# 1、构建函数用来选择node_cost最小的节点
# 选择node_cost值最小的节点->node 0
def choose_min(node_cost, close_list):
node_cost = np.array(node_cost) # 将node_cost从list转换成array
open_list = list(set(node_cost[:, 0].tolist()) - set(close_list)) # 建立一个open_list放入没有被遍历的点
final_list = []
for i in open_list:
final_list.append(node_cost[int(i)].tolist())
final_list = np.array(final_list) # final_list转换成array，才可以利用np.where找最小值
node0 = final_list[np.where(final_list[:, 1] == final_list[:, 1].min())][0][0] # 将node_cost最小的点的节点名给node0
return int(node0)
# -------------------------------------------------------------------------------------------------------
# 构建count_cost函数用来计算相邻节点的node_cost
# 计算node0邻节点的node_cost，此时的node_cost值就是地图上的代价值加上父节点的代价值，如果已经比原来小则更新node_cost和父节点
# 并将node0放入close_list里面
def count_cost(mapping_list, node_cost, close_list):
for i in range(0, 10):
if mapping_list[node0][i] + node_cost[node0][1] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[node0][i] + node_cost[node0][1]
close_list.append(node0)
return [node_cost, close_list]
# 开始迭代----->迭代中止的条件：终点在close_list里面
while 6 not in close_list:
node0 = choose_min(node_cost, close_list) # 找node_cost最小的节点
[node_cost, close_list] = count_cost(mapping_list, node_cost, close_list) # 计算邻节点
# print(close_list)
#起始点
xn = 9
x0 = 0
destination_list = [xn]
print("最短的路径代价为:", node_cost[xn][1])
while x0 not in destination_list:
xn = node_cost[xn][2]
destination_list.append(xn)
print("最短路径为：", destination_list[::-1])
运行结果：
最短的路径代价为: 15.0
最短路径为： [0, 9]
符合要求
二．疫情管控下物流最短路径
算法主题与第一问近似，增加的只是城市管控的判断
import numpy as np
# 构建地图
mapping_list = [[np.inf for i in range(0, 10)] for i in range(0, 10)] # 构建全是无穷大的二维列表
for i in range(0, 10):
mapping_list[i][i] = 0 # 对角线处的值为0
mapping_list[0][1] = 24
mapping_list[0][2] = 8
mapping_list[0][3] = 15
mapping_list[1][4] = 6
mapping_list[2][4] = 7
mapping_list[3][5] = 5
mapping_list[3][6]= 4,
mapping_list[4][6] = 9
mapping_list[5][6] = 10
mapping_list[1][0] = 24
mapping_list[2][0] = 8
mapping_list[3][0] = 15
mapping_list[4][1] = 6
mapping_list[4][2] = 7
mapping_list[5][3] = 5
mapping_list[6][3]= 4,
mapping_list[6][4] = 9
mapping_list[6][5] = 10
mapping_list[0][9] = 15
mapping_list[1][7] = 23
mapping_list[1][9] = 13
mapping_list[6][8] = 19
mapping_list[7][8] = 12
mapping_list[9][0] = 15
mapping_list[7][1] = 23
mapping_list[9][1] = 13
mapping_list[8][6] = 19
mapping_list[8][7] = 12
mapping_list = np.array(mapping_list) # 将mapping_list转换成数组形式
# print(mapping_list)
# 初始化
node_cost = [[np.inf for i in range(0, 3)] for i in range(0, 10)] # 构建全是无穷大的二维列表
# arr这个数组用来表示每个节点的[节点名 node_cost 父节点]
for i in range(0, 10):
node_cost[i][0] = i
# 计算A点与它相邻的节点，更新其node_cost和父节点,并且将A点放入close_list里面
node0 = 0
close_list = []
for i in range(0, 10):
if mapping_list[int(node0)][i] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[int(node0)][i]
close_list.append(int(node0))
# 构建一系列函数以实现迭代功能
# 1、构建函数用来选择node_cost最小的节点
# 选择node_cost值最小的节点->node 0
def choose_min(node_cost, close_list):
node_cost = np.array(node_cost) # 将node_cost从list转换成array
open_list = list(set(node_cost[:, 0].tolist()) - set(close_list)) # 建立一个open_list放入没有被遍历的点
final_list = []
for i in open_list:
final_list.append(node_cost[int(i)].tolist())
final_list = np.array(final_list) # final_list转换成array，才可以利用np.where找最小值
node0 = final_list[np.where(final_list[:, 1] == final_list[:, 1].min())][0][0] # 将node_cost最小的点的节点名给node0
return int(node0)
# -------------------------------------------------------------------------------------------------------
# 构建count_cost函数用来计算相邻节点的node_cost
# 计算node0邻节点的node_cost，此时的node_cost值就是地图上的代价值加上父节点的代价值，如果已经比原来小则更新node_cost和父节点
# 并将node0放入close_list里面
def count_cost(mapping_list, node_cost, close_list):
for i in range(0, 10):
if mapping_list[node0][i] + node_cost[node0][1] < node_cost[i][1]:
node_cost[i][2] = node0
node_cost[i][1] = mapping_list[node0][i] + node_cost[node0][1]
close_list.append(node0)
return [node_cost, close_list]
# 开始迭代----->迭代中止的条件：终点在close_list里面
while 6 not in close_list:
node0 = choose_min(node_cost, close_list) # 找node_cost最小的节点
[node_cost, close_list] = count_cost(mapping_list, node_cost, close_list) # 计算邻节点
# print(close_list)
#起始点
xn = 4
x0 = 0
destination_list = [xn]
print("最短的路径代价为:", node_cost[xn][1])
while x0 not in destination_list:
xn = node_cost[xn][2]
destination_list.append(xn)
print("最短路径为：", destination_list[::-1])
运行结果：
最短的路径代价为: 15.0
最短路径为： [0, 2, 4]
即对应的a-c-e
符合要求
三．多仓发货方式下物流最短路径
算法的思路
在图论中，在寻路最短路径中除了Dijkstra算法以外，还有Floyd算法也是非常经典，然而两种算法还是有区别的，Floyd主要计算多源最短路径。
在单源正权值最短路径，我们会用Dijkstra算法来求最短路径，并且算法的思想很简单——贪心算法:每次确定最短路径的一个点然后维护(更新)这个点周围点的距离加入预选队列，等待下一次的抛出确定。但是虽然思想很简单，实现起来是非常复杂的，我们需要邻接矩阵(表)储存长度，需要优先队列(或者每次都比较)维护一个预选点的集合。还要用一个boolean数组标记是否已经确定。
总之，Dijkstra算法的思想上是很容易接受的，但是实现上其实是非常麻烦的。但是单源最短路径没有更好的办法。复杂度也为O(n2)
而在n节点多源最短路径中,如果从Dijkstra算法的角度上，只需要将Dijkstra封装，然后执行n次Dijkstra算法即可,复杂度为O(n3)。但是这样感觉很臃肿，代码量巨大，占用很多空间内存。易写但稍需要理解的Floyd算法是一个适合求多元最短路径算法。
程序设计
简单的来说，算法的主要思想是动态规划(dp)，而求最短路径需要不断松弛。而算法的具体思想为：
邻接矩阵dist储存路径，同时最终状态代表点点的最短路径。如果没有直接相连的两点那么默认为一个很大的值(不要溢出)！而自己的长度为0.
从第1个到第n个点依次加入图中。每个点加入进行试探是否有路径长度被更改。
而上述试探具体方法为遍历图中每一个点(i,j双重循环)，判断每一个点对距离是否因为加入的点而发生最小距离变化。如果发生改变，那么两点(i,j)距离就更改。
重复上述直到最后插点试探完成。
设置地图
整体程序
import sys
sys.setrecursionlimit(100000000)
# 弗洛伊德算法
def floyd():
n = len(graph)
for k in range(n):
for i in range(n):
for j in range(n):
if graph[i][k] + graph[k][j] < graph[i][j]:
graph[i][j] = graph[i][k] + graph[k][j]
parents[i][j] = parents[k][j] # 更新父结点
# 打印路径
def print_path(i, j):
if i != j:
print_path(i, parents[i][j])
print(j, end='-->')
# Data [u, v, cost]
datas = [
[0, 1, 24],
[0, 2, 8],
[0, 3, 15],
[1, 4, 6],
[2, 4, 7],
[2, 5, 3],
[3, 5, 5],
[3, 6, 4],
[4, 5, 2],
[4, 6, 9],
[5, 6, 10]
]
n = 7
# 无穷大
inf = 9999999999
# 构图
graph = [[(lambda x: 0 if x[0] == x[1] else inf)([i, j]) for j in range(n)] for i in range(n)]
parents = [[i] * n for i in range(7)] # 关键地方，i-->j 的父结点初始化都为i
for u, v, c in datas:
graph[u][v] = c
# 因为是有向图，边权只赋给graph[u][v]
#graph[v][u] = c # 如果是无向图，要加上这条。
graphs=[]
floyd()
print('Costs:')
for row in graph:
for e in row:
print('∞' if e == inf else e, end='\t')
print()
print('\nPath:')
#买家
j=4
#仓库
for i in [0,1,2,6]:
graphs.append(graph[i][j])
for i in [0, 1, 2, 6]:
if graph[i][j]==min(graphs):
print('Path({}-->{}): '.format(i, j), end='')
print_path(i, j)
print(' cost:', graph[i][j])
运行结果
Path:
Path(1–>4): 1–>4–> cost: 6
即b-e与要求相符
拓展到n>=10的实例
import sys
sys.setrecursionlimit(100000000)
# 弗洛伊德算法
def floyd():
n = len(graph)
for k in range(n):
for i in range(n):
for j in range(n):
if graph[i][k] + graph[k][j] < graph[i][j]:
graph[i][j] = graph[i][k] + graph[k][j]
parents[i][j] = parents[k][j] # 更新父结点
# 打印路径
def print_path(i, j):
if i != j:
print_path(i, parents[i][j])
print(j, end='-->')
# Data [u, v, cost]
datas = [
[0, 1, 24],
[0, 2, 8],
[0, 3, 15],
[1, 4, 6],
[2, 4, 7],
[2, 5, 3],
[3, 5, 5],
[3, 6, 4],
[4, 5, 2],
[4, 6, 9],
[5, 6, 10],
[0, 9, 15],
[1, 7, 23],
[1, 9, 13],
[6, 8, 19],
[7, 8, 12],
]
n = 10
# 无穷大
inf = 9999999999
# 构图
graph = [[(lambda x: 0 if x[0] == x[1] else inf)([i, j]) for j in range(n)] for i in range(n)]
parents = [[i] * n for i in range(10)] # 关键地方，i-->j 的父结点初始化都为i
for u, v, c in datas:
graph[u][v] = c
# 因为是有向图，边权只赋给graph[u][v]
#graph[v][u] = c # 如果是无向图，要加上这条。
graphs=[]
floyd()
print('Costs:')
for row in graph:
for e in row:
print('∞' if e == inf else e, end='\t')
print()
print('\nPath:')
#买家
j=4
#仓库
for i in [0,1,2,6]:
graphs.append(graph[i][j])
for i in [0, 1, 2, 6]:
if graph[i][j]==min(graphs):
print('Path({}-->{}): '.format(i, j), end='')
print_path(i, j)
print(' cost:', graph[i][j])
运行结果：
Path:
Path(1–>4): 1–>4–> cost: 6
与要求相符
拓展到n>=10且考虑疫情防控的实例
import sys
sys.setrecursionlimit(100000000)
# 弗洛伊德算法
def floyd():
n = len(graph)
for k in range(n):
for i in range(n):
for j in range(n):
if graph[i][k] + graph[k][j] < graph[i][j]:
graph[i][j] = graph[i][k] + graph[k][j]
parents[i][j] = parents[k][j] # 更新父结点
# 打印路径
def print_path(i, j):
if i != j:
print_path(i, parents[i][j])
print(j, end='-->')
# Data [u, v, cost]
datas = [
[2, 4, 7],
[3, 6, 4],
[4, 6, 9],
[0, 9, 15],
[1, 7, 23],
[1, 9, 13],
[6, 8, 19],
[7, 8, 12],
]
n = 10
# 无穷大
inf = 9999999999
# 构图
graph = [[(lambda x: 0 if x[0] == x[1] else inf)([i, j]) for j in range(n)] for i in range(n)]
parents = [[i] * n for i in range(10)] # 关键地方，i-->j 的父结点初始化都为i
for u, v, c in datas:
graph[u][v] = c
# 因为是有向图，边权只赋给graph[u][v]
#graph[v][u] = c # 如果是无向图，要加上这条。
graphs=[]
floyd()
print('Costs:')
for row in graph:
for e in row:
print('∞' if e == inf else e, end='\t')
print()
print('\nPath:')
#买家
j=9
#仓库
for i in [0,1,2,6]:
graphs.append(graph[i][j])
for i in [0, 1, 2, 6]:
if graph[i][j]==min(graphs):
print('Path({}-->{}): '.format(i, j), end='')
print_path(i, j)
print(' cost:', graph[i][j])
运行结果：
Path:
Path(1–>9): 1–>9–> cost: 13 与要求一致
参考文章：https://blog.csdn.net/weixin_42875283/article/details/124341524
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
