python算法--物流最优路径
2024-06-29 22:17:56
参考文章：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] = node0node_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转换成arrayopen_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最小的点的节点名给node0return 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] = node0node_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 # 对角线处的值为0mapping_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] = node0node_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转换成arrayopen_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最小的点的节点名给node0return 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] = node0node_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 # 对角线处的值为0mapping_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] = 12mapping_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] = node0node_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转换成arrayopen_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最小的点的节点名给node0return 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] = node0node_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 # 对角线处的值为0mapping_list[0][1] = 24
mapping_list[0][2] = 8
mapping_list[0][3] = 15
mapping_list[1][4] = 6
mapping_list[2][4] = 7mapping_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] = 7mapping_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] = 12mapping_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] = node0node_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转换成arrayopen_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最小的点的节点名给node0return 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] = node0node_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 syssys.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 syssys.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
python算法--物流最优路径相关推荐
- 算法 | A*算法实现最优路径规划
启发式探索是利用问题拥有的启发信息来引导搜索,达到减少探索范围.降低问题复杂度的目的.A*寻路算法是启发式探索的一个典型实践,在寻路搜索的过程中,给每个节点绑定了一个估计值(即启发式),在对节点的遍历 ...
- NLP-基础任务-中文分词算法(2)-基于词典：基于N-gram语言模型的分词算法【基于词典的分词方法】【利用维特比算法求解最优路径】【比机械分词精度高】【OOV：基于现有词典，不能进行新词发现处理】
例子:"经常有意见分歧" 词典:["经常","有","意见","意","见",& ...
- a*算法路径规划matlab_【优化求解】基于栅格地图——遗传算法的机器人最优路径规划...
采用栅格对机器人的工作空间进行划分,再利用优化算法对机器人路径优化,是采用智能算法求最优路径的一个经典问题.目前,采用蚁群算法在栅格地图上进行路径优化取得比较好的效果,而利用遗传算法在栅格地图上进行路 ...
- 『实践』Matlab实现Flyod求最短距离及存储最优路径
Matlab实现Flyod求最短距离及存储最优路径 一.实际数据 已知图中所有节点的X.Y坐标. 图中的节点编号:矩阵中的编号 J01-J62:1-62; F01-F60:63-122; Z01-Z0 ...
- 集货运输优化：数学建模步骤，Python实现蚁群算法（解决最短路径问题）， 蚁群算法解决旅行商问题（最优路径问题），节约里程算法
目录 数学建模步骤 Python实现蚁群算法(解决最短路径问题) 蚁群算法解决旅行商问题(最优路径问题) 节约里程算法
- Dijkstra最优路径的算法
Dijkstra最优路径的算法: 1 最短路径算法 在日常生活中,我们如果需要常常往返A地区和B地区之间,我们最希望知道的可能是从A地区到B地区间的众多路径中,那一条路径的路途最短.最短路径问题是图论 ...
- matlab求解关键,基于遗传算法的多辆洒水车最优路径求解(其中包含MATLAB的一些关键语句说明和Floyd,Dijkstra,Euler算法）.doc...
基于遗传算法的多辆洒水车最优路径求解(其中包含MATLAB的一些关键语句说明和Floyd,Dijkstra,Euler算法) 摘要 车辆路径问题可以分为以点为服务和以边为服务两种,洒水车问题是以边为服 ...
- 粒子群算法原理|python实现|参数调优
粒子群算法是比较有名的群体智能算法之一,其他群体智能算法还包括蚁群算法.鱼群算法.人工蜂群算法等.今天学习一下粒子群算法. 文章目录 算法原理(Inspiration) 优化过程 python实现 参 ...
- python实现连续变量最优分箱详解--CART算法
今天小编就为大家分享一篇python实现连续变量最优分箱详解–CART算法,具有很好的参考价值,希望对大家有所帮助.一起跟随小编过来看看吧 关于变量分箱主要分为两大类:有监督型和无监督型 对应的分箱方 ...
最新文章
- 图形化客户端Navicat介绍和使用
- 网易笔试——混合颜料
- Minify框架分析，主要功能类简介
- BugkuCTF-MISC题FileStoragedat
- 老话题：自己编写只截窗口客户区的截屏软件（VB2010）
- jmeter教程https://max.book118.com/html/2019/0108/6145005114002000.shtm
- Swift_学习笔记_调用ObjectiveC方法
- Unity StanderShader系列1---ForwardBase源码解析
- WebRTC音频处理流程简介
- 移动硬盘上安装WIN7 WIN10系统
- WordPress美女图集COS写真整站自适应源码带完整数据
- IOS中impactor报81错误解决方法
- 2019丘成桐中学科学奖计算机,2019年丘成桐中学科学奖总决赛获奖名单
- 微信小程序云开发 操作数据库-新增一条数据
- Windows Phone开发-- 多任务之墓碑机制
- wifi理论数据速率计算
- java 根据已有word模板进行数据下载导出
- 新手怎样选择适合的3D打印机
- 计算机适应性考试题目,计算机控制考试题目整理
- ISO 标准下载 网站