基于python语言,采用经典量子离散粒子群算法(QDPSO)对 带硬时间窗的需求拆分车辆路径规划问题(SDVRPTW) 进行求解。
往期优质资源
经过一年多的创作,目前已经成熟的代码列举如下,如有需求可私信联系,表明需要的 **问题与算法**,原创不宜,有偿获取。
VRP问题 | GA | ACO | ALNS | DE | DPSO | QDPSO | TS | SA |
---|---|---|---|---|---|---|---|---|
CVRP | √ | √ | √ | √ | √ | √ | √ | √ |
VRPTW | √ | √ | √ | √ | √ | √ | √ | √ |
MDVRP | √ | √ | √ | √ | √ | √ | √ | √ |
MDHVRP | √ | √ | √ | √ | √ | √ | √ | √ |
MDHVRPTW | √ | √ | √ | √ | √ | √ | √ | √ |
SDVRP | √ | √ | √ | √ | √ | √ | √ | √ |
SDVRPTW | √ | √ | √ | √ | √ | √ |
1. 适用场景
- 求解SDVRPTW
- 车辆类型单一
- 车辆容量小于部分需求节点需求
- 单一车辆基地
- 带硬时间窗
2. 代码调整
2.1 需求拆分
与SDVRP问题相比,SDVRPTW问题不仅允许客户需求大于车辆载重,而且考虑了客户节点的时间窗约束。为了使得每个客户的需求得到满足,必须派遣一辆或多辆车辆在规定时间窗内对客户进行服务。对于需求节点的拆分,这里依然采取先验拆分策略,本文采用文献[1]提出的先验分割策略,表述如下:
(1)20/10/5/1拆分规则
- m20 =max{ m ∈ Z + ∪ { 0 } ∣ 0.20 Q m < = D i m\in Z^+ \cup \{0\} | 0.20Qm <= D_i m∈Z+∪{0}∣0.20Qm<=Di }
- m10 =max{ m ∈ Z + ∪ { 0 } ∣ 0.10 Q m < = D i − 0.20 Q m 20 m\in Z^+ \cup \{0\} | 0.10Qm <= D_i-0.20Qm_{20}~ m∈Z+∪{0}∣0.10Qm<=Di−0.20Qm20 }
- m5 =max{ m ∈ Z + ∪ { 0 } ∣ 0.05 Q m < = D i − 0.20 Q m 20 − 0.10 Q m 10 m\in Z^+ \cup \{0\} | 0.05Qm <= D_i-0.20Qm_{20}-0.10Qm_{10} m∈Z+∪{0}∣0.05Qm<=Di−0.20Qm20−0.10Qm10 }
- m1 =max{ m ∈ Z + ∪ { 0 } ∣ 0.01 Q m < = D i − 0.20 Q m 20 − 0.10 Q m 10 − 0.05 Q m 5 m\in Z^+ \cup \{0\} | 0.01Qm <= D_i-0.20Qm_{20}-0.10Qm_{10}-0.05Qm_{5} m∈Z+∪{0}∣0.01Qm<=Di−0.20Qm20−0.10Qm10−0.05Qm5 }
(2)25/10/5/1拆分规则
- m25 =max{ m ∈ Z + ∪ { 0 } ∣ 0.25 Q m < = D i m\in Z^+ \cup \{0\} | 0.25Qm <= D_i m∈Z+∪{0}∣0.25Qm<=Di }
- m10 =max{ m ∈ Z + ∪ { 0 } ∣ 0.10 Q m < = D i − 0.25 Q m 25 m\in Z^+ \cup \{0\} | 0.10Qm <= D_i-0.25Qm_{25}~ m∈Z+∪{0}∣0.10Qm<=Di−0.25Qm25 }
- m5 =max{ m ∈ Z + ∪ { 0 } ∣ 0.05 Q m < = D i − 0.25 Q m 25 − 0.10 Q m 10 m\in Z^+ \cup \{0\} | 0.05Qm <= D_i-0.25Qm_{25}-0.10Qm_{10} m∈Z+∪{0}∣0.05Qm<=Di−0.25Qm25−0.10Qm10 }
- m1 =max{ m ∈ Z + ∪ { 0 } ∣ 0.01 Q m < = D i − 0.25 Q m 25 − 0.10 Q m 10 − 0.05 Q m 5 m\in Z^+ \cup \{0\} | 0.01Qm <= D_i-0.25Qm_{25}-0.10Qm_{10}-0.05Qm_{5} m∈Z+∪{0}∣0.01Qm<=Di−0.25Qm25−0.10Qm10−0.05Qm5 }
在实现过程中,对于需求超过车辆容量的客户必须进行需求拆分,而对于未超过车辆容量的客户可以拆分也可以不拆分,这里设置了参数比例进行限制。
2.2 需求拆分后的服务时长取值问题
节点的服务时长会影响车辆的行进时间,进而会影响与节点时间窗的匹配问题。一般来说,节点的服务时长与需求量成正比关系,在进行节点需求拆分后,新节点的需求量降低,其服务时长理应也降低。但从标准数据集来看,各需求节点的服务时长均采用同一数值。因此本文在代码实现过程中也采用固定值,不考虑新节点服务时长的变化。当然,如有需要,也可以设置单位货物的服务时长,根据拆分后节点的具体需求量设置相应的服务时长。
3. 求解结果
(1)收敛曲线
(2)车辆路径
(3)输出内容
4. 代码片段
(1)数据结构
import time
import csv
import math
import random
import numpy as np
import copy
import xlsxwriter
import matplotlib.pyplot as plt
# 数据结构:解
class Sol():
def __init__(self):
self.obj=None # 目标函数值
self.node_no_seq=[] # 解的编码
self.route_list=[] # 解的解码
self.timetable_list=[] # 车辆访问各点的时间
self.route_distance_list = None
# 数据结构:需求节点
class Node():
def __init__(self):
self.id=0 # 节点id
self.x_coord=0 # 节点平面横坐标
self.y_coord=0 # 节点平面纵坐标
self.demand=0 # 节点需求
self.start_time=0 # 节点开始服务时间
self.end_time=1440 # 节点结束服务时间
self.service_time=0 # 单次服务时长
self.vehicle_speed = 0 # 行驶速度
# 数据结构:车场节点
class Depot():
def __init__(self):
self.id=0 # 节点id
self.x_coord=0 # 节点平面横坐标
self.y_coord=0 # 节点平面纵坐标
self.start_time=0 # 节点开始服务时间
self.end_time=1440 # 节点结束服务时间
self.v_speed = 0 # 行驶速度
self.v_cap = 80 # 车辆容量
# 数据结构:全局参数
class Model():
def __init__(self):
self.best_sol=None # 全局最优解
self.sol_list=[] # 解的集合
self.demand_dict = {} # 需求节点集合
self.depot = None # 车场节点集合
self.demand_id_list = [] # 需求节点id集合
self.distance_matrix = {} # 距离矩阵
self.time_matrix = {} # 时间矩阵
self.number_of_demands = 0 # 需求点数量
self.demand_id_list_ = [] # 经先验需求分割后的节点集合
self.demand_dict_ = {} # 需求分割后的节点需求集合
self.distance_matrix_ = {} # 原始节点id间的距离矩阵
self.time_matrix_ = {} # 原始节点id间的时间矩阵
self.mapping = {} # 需求分割前后的节点对应关系
self.split_rate = 0.5 # 控制需求分割的比例(需求超出车辆容量的除外)
self.popsize = 100 # 种群规模
self.pl=[] # 个体历史最优解
self.pg=None # 种群历史最优解
self.mg=None # 群体平均位置
self.alpha=1.0 # 创新参数
(2)距离矩阵
# 初始化参数:计算距离矩阵时间矩阵
def calDistanceTimeMatrix(model):
for i in range(len(model.demand_id_list)):
from_node_id = model.demand_id_list[i]
for j in range(len(model.demand_id_list)):
to_node_id = model.demand_id_list[j]
dist = math.sqrt((model.demand_dict[from_node_id].x_coord - model.demand_dict[to_node_id].x_coord) ** 2
+ (model.demand_dict[from_node_id].y_coord - model.demand_dict[to_node_id].y_coord) ** 2)
model.distance_matrix[from_node_id, to_node_id] = dist
model.time_matrix[from_node_id,to_node_id] = math.ceil(dist/model.depot.v_speed)
dist = math.sqrt((model.demand_dict[from_node_id].x_coord - model.depot.x_coord) ** 2 +
(model.demand_dict[from_node_id].y_coord - model.depot.y_coord) ** 2)
model.distance_matrix[from_node_id, model.depot.id] = dist
model.distance_matrix[model.depot.id, from_node_id] = dist
model.time_matrix[from_node_id,model.depot.id] = math.ceil(dist/model.depot.v_speed)
model.time_matrix[model.depot.id,from_node_id] = math.ceil(dist/model.depot.v_speed)
(3)邻域搜索
# 调整不可行解
def adjustRoutes(node_no_seq,model):
all_node_id_list=copy.deepcopy(model.demand_id_list_)
repeat_node=[]
for id,node_no in enumerate(node_no_seq):
if node_no in all_node_id_list:
all_node_id_list.remove(node_no)
else:
repeat_node.append(id)
for i in range(len(repeat_node)):
node_no_seq[repeat_node[i]]=all_node_id_list[i]
return node_no_seq
# 更新位置
def updatePosition(model):
alpha=model.alpha
pg=model.pg
mg=model.mg
#更新历史平均最优位置
mg_=[0]*model.number_of_demands
for id, sol in enumerate(model.sol_list):
x=sol.node_no_seq
pl = model.pl[id].node_no_seq
pi=[]
for k in range(model.number_of_demands):
phi = random.random()
pi.append(phi*pl[k]+(1-phi)*pg[k])
if random.random()<=0.5:
X=[min(int(pi[k]+alpha*abs(mg[k]-x[k])*math.log(1/random.random())),model.number_of_demands-1)
for k in range(model.number_of_demands)]
else:
X=[min(int(pi[k]-alpha*abs(mg[k]-x[k])*math.log(1/random.random())),model.number_of_demands-1)
for k in range(model.number_of_demands)]
#调整可行性
X= adjustRoutes(X, model)
timetable_list, obj, route_distance,route_list = calObj(X,model)
if obj < model.pl[id].obj:
model.pl[id].node_no_seq = copy.deepcopy(X)
model.pl[id].obj = obj
model.pl[id].route_list = route_list
model.pl[id].route_distance = route_distance
model.pl[id].timetable_list = timetable_list
if obj < model.best_sol.obj:
model.best_sol.obj = copy.deepcopy(obj)
model.best_sol.node_no_seq = copy.deepcopy(X)
model.best_sol.route_list = copy.deepcopy(route_list)
model.best_sol.route_distance = copy.deepcopy(route_distance)
model.best_sol.timetable_list = copy.deepcopy(timetable_list)
model.pg = copy.deepcopy(X)
mg_ = [mg_[k] + model.pl[id].node_no_seq[k] / model.popsize for k in range(model.number_of_demands)]
model.sol_list[id].node_no_seq = copy.deepcopy(X)
model.sol_list[id].obj = copy.deepcopy(obj)
model.sol_list[id].route_list = copy.deepcopy(route_list)
model.sol_list[id].route_distance = copy.deepcopy(route_distance)
model.sol_list[id].timetable_list = copy.deepcopy(timetable_list)
model.mg=copy.deepcopy(mg_)
参考
【1】 A novel approach to solve the split delivery vehicle routing problem