【路径分割】序列分隔和路径提取的案例

panbaoran913

已于 2024-02-21 11:40:54 修改

阅读量1k

点赞数 1

分类专栏：车辆路径规划问题文章标签： VRP 分隔路径

于 2023-02-15 17:15:43 首次发布

本文链接：https://blog.csdn.net/panbaoran913/article/details/128973708

版权

车辆路径规划问题专栏收录该内容

21 篇文章 15 订阅

订阅专栏

本文详细介绍了路径分隔算法，该算法基于C-W节约法的思想，用于解决车辆路径问题。通过对基因序列的处理，计算各节点间的成本，并更新节点成本字典V和前驱节点字典Pred。在满足车辆载重和时间窗约束的条件下，寻找最优路径。同时，文章讨论了算法的局限性和可能的优化策略，如结合遗传算法和模拟退火算法，以提高解的质量和效率。

摘要由CSDN通过智能技术生成

本文的路径分隔算法应该是基于C-W节约法的思想的。

C-W节约法的基本步骤如下：

初始化：从配送中心开始，为每个客户创建一条独立的配送路线。此时，每条路线只包含一个客户。
计算节约量：对于每对客户（i, j），计算如果将它们合并到同一条路线中，可以节约的行驶距离。节约量的计算公式通常为：节约量 = d(0,i) + d(0,j) -d(i,j)，其中d(0,i)表示从配送中心到客户i的距离，d(0,j)表示从配送中心到客户j的距离，d(i,j)表示从客户i到客户j的距离。
排序：根据计算出的节约量，对所有客户对进行降序排序。
合并路线：从节约量最大的客户对开始，尝试将它们合并到同一条路线中。如果合并后的路线满足所有约束条件（如车辆载重限制、客户时间窗等），则进行合并，并更新相关路线信息。然后，继续考虑下一个节约量最大的客户对。
迭代优化：重复步骤3和4，直到无法再合并任何客户对或达到预设的迭代次数。

C-W节约法的优点在于简单易实现，且能够在较短的时间内得到一个较好的解。然而，它也存在一些局限性，如容易陷入局部最优解，无法保证找到全局最优解。因此，在实际应用中，通常会将C-W节约法与其他优化方法（如遗传算法、模拟退火算法等）相结合，以提高求解质量和效率。

壹：路径分隔算法


def splitRoutes(node_no_seq,model):
    depot=model.depot
    V={id:float('inf') for id in model.demand_id_list}
    V[depot.id]=0
    Pred={id:depot.id for id in model.demand_id_list}
    for i in range(len(node_no_seq)):
        n_1=node_no_seq[i]
        demand=0
        departure=0
        j=i
        cost=0
        while True:
            n_2 = node_no_seq[j]
            demand = demand + model.demand_dict[n_2].demand
            if n_1 == n_2:
                arrival= max(model.demand_dict[n_2].start_time,depot.start_time+model.time_matrix[depot.id,n_2])
                departure=arrival+model.demand_dict[n_2].service_time
                cost = model.distance_matrix[depot.id, n_2] * 2
            else:
                n_3=node_no_seq[j-1]
                arrival= max(departure+model.time_matrix[n_3,n_2],model.demand_dict[n_2].start_time)
                departure=arrival+model.demand_dict[n_2].service_time
                cost = cost - model.distance_matrix[n_3, depot.id] + model.distance_matrix[n_3, n_2] + \
                       model.distance_matrix[n_2, depot.id]
            if demand<=model.depot.v_cap and departure<= model.demand_dict[n_2].end_time:
                if departure+model.time_matrix[n_2,depot.id]  <= depot.end_time:
                    n_4=node_no_seq[i-1] if i-1>=0 else depot.id
                    if V[n_4]+cost <= V[n_2]:
                        V[n_2]=V[n_4]+cost
                        Pred[n_2]=i-1
                    j=j+1
            else:
                break
            if j==len(node_no_seq):
                break
    route_list= extractRoutes(node_no_seq,Pred,model)
    return route_list

代码函数举例：

一、基础值

基因序列	3	4	2	0	5	6	1
Demand	-35	24	-13	15	-2	-18	15

字典 V：, 设V[depot]=0,V[x]表示从depot到达节点x的成本
字典Pred:表示当前节点的。。。
这里没有departure值，由于departure的影响同demand的影响。因此这里默认为所有的departure是满足需求的，设vehicle的容量为60.当vehicle的在0~60内为满足需求，否则为不满足。

二。循环开始

i=0

初始设置为：
n1=3, demand=0,cost=0

j=0

n2=3,demand=0-35<0,因为需求不满足，需要跳出循环。可以判断出该节点必为红包节点。所以成本为0.V[3]=b3

i=1

初始设置为：
n1=4, demand=0,cost=0

j=1,i=1

n2=4 , demand=0+24=24 cost=D(d,4)+D(4,d)
demand is ok–>update :n4=3
Dudge: V[3]+cost<=V[4]

V[3]=b3,
left=b3+D(d,4)+D(4,d)
righte=infinity
ok

V[4]=b3+D(d,4)+D(4,d)
Pred[4]=i-1=0

j+=1

j=2,i=1

n2=2 , n3=4, demand=24+35=59<60, cost=D(d,4)+D(4,2)+D(2,d)
demand is ok–>update: n4=3
Dudge: V[3]+cost<=V[2]

left=b3+ D(d,4)+D(4,2)+D(2,d)
right=infinity

V[2]=b3+D(d,4)+D(4,2)+D(2,d)
Pred[2]=0

j+=1

j=3,i=1

n2=0, n3=2,demand=59-13=46<60,cost=D(d,4)+D(4,2)+D(2,0)+D(0,d)
damand is ok–> update:n4=3
Dudge: V[3]+cost<=V[0]

left=b3+D(d,4)+D(4,2)+D(2,0)+D(0,d)
right=infinity

V[0]=b3+D(d,4)+D(4,2)+D(2,0)+D(0,d)
Pred[0]=0

j=4, i=1

n2=5, n3=0, demand=46+15=61>60
demand is wrong, break

i=2

已有的值

V[3]=b3,
V[4]=b3+D(d,4)+D(4,d)
V[2]=b3+D(d,4)+D(4,2)+D(2,d)
V[0]=b3+D(d,4)+D(4,2)+D(2,0)+D(0,d)
Pred[4]=0
Pred[2]=0
Pred[0]=0

初始化的值
n1=2, demand=0,cost=0

j=2,i=2

n2=2, demand=0+35<60,cost=D(d,2)+D(2,d)
demand is ok–>update:n4=4
Dudge:V[4]+cost<=V[2]

left=b3+D(d,4)+D(4,d) +D(d,2)+D(2,d)
right=b3+D(d,4)+D(4,2)+D(2,d)
实际比较的是D(4,d)+D(d,2)与D(4,2)之间的大小。

如果所有的值都是正(因为这里的成本设置为距离，即为非负值).
case1:如果3个节点4,d,2不同直线(即存在三角形)，则根据三角形性质定理，任意两边之和大于第三边。则有D(4,d)+D(d,2)>D(4,2)
case2: 如果3个节点为同一直线，则有D(4,d)+D(d,2)=D(4,2)

假设这里为case2. ok.更新V[2],更新Pred[2]

V[2]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,d)
Pred[2]=1

j+=1

j=3,i=2

默认关系case2：D(4,d)+D(d,2)=D(4,2)

n2=0, n3=2, demand =35-13=22<60, cost=D(d,2)+D(2,0)+D(0,d)
demand is ok–>update:n4=4
Dudge:V[4]+cost<=V[0]

left=b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d)
right=b3+D(d,4)+D(4,2)+D(2,0)+D(0,d)
在默认关系case2的情况下，更新

V[0]=b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d)
Pred[0]=1

j+=1

j=4, i=2

n2=5, n3=0,demand=22+15=37<60,cost=D(d,2)+D(2,0)+D(0,5)+D(5,d)
demand is ok–>update:n4=4
Dudge:V[4]+cost<=V[5]

left=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)
right=inifty
ok ,update

V[5]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)
Pred[5]=1

j+=1

j=5,i =2

n2=6, n3=5,demand=37-2=35,cost=D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,d)
demand is ok–>update:n4=4
Dudge:V[4]+cost<=V[6]

left =b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,d)
right=inifty
ok ,update

V[6]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,6)+D(6,d)
Pred[6]=1

j+=1

j=6, i=2

n2=1, n3=6, demand=35-18=17<60. cost=D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,1)+D(1,d)
demand is ok–>update:n4=4
Dudge:V[4]+cost<=V[1]

left =b3+ D(d,4)+D(4,d)+D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,1)+D(1,d)
right=inifty
ok, update

V[1]=b3+D(d,4)+D(4,d)+D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,1)+D(1,d)
Pred[1]=0

j+=1
j=7==len(node_no_seq) :跳出循环

i=3

已有的值：

V[3]=b3,
V[4]=b3+D(d,4)+D(4,d)
V[2]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,d)
V[0]=b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d)
V[5]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)
V[6]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,6)+D(6,d)
V[1]=b3+D(d,4)+D(4,d)+D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,1)+D(1,d)
Pred[4]=0
Pred[2]=1
Pred[0]=1
Pred[5]=1
Pred[6]=1
Pred[1]=1

默认关系：case2：D(4,d)+D(d,2)=D(4,2)
初始化的值：
n1=0, demand=0,cost=0,

j=3,i=3

n2=0, n3=2, demand=0-13<0
demand is wrong, break

i=4

同 i=3
初始化的值：
n1=5, demand=0,cost=0,

j=4, i=4

n2=5, n3=0, deamd=0+15=15<60,cost=D(d,5)+D(5,d)
demand is ok–>update : n4=0
Dudge:V[0]+cost<=V[5]

left = b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d) +D(d,5)+D(5,d)
right=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)
实际比较的是D(0,d)+D(d,5)与D(0,5)之间的大小。

如果所有的值都是正(因为这里的成本设置为距离，即为非负值).
case1:如果3个节点0,d,5不同直线(即存在三角形)，则根据三角形性质定理，任意两边之和大于第三边。则有D(0,d)+D(d,5)>D(0,5)
case2: 如果3个节点为同一直线，则有D(0,d)+D(d,5)=D(0,5)

假设这里为case1. 不更新V[5],不更新Pred[5]

j+=1

j=5,i=4

默认关系case2：D(4,d)+D(d,2)=D(4,2)
默认关系case1：D(0,d)+D(d,5)>D(0,5)

n2=6, n3=5, damand=15-2=13<60,cost=D(d,5)+D(5,6)+D(6,d)
demand is ok–>update : n4=0
Dudge: V[0]+cost <V[6]

left = b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d) + D(d,5)+D(5,6)+D(6,d)
right=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,d)

不更新 V[6], 不更新Pred[6]

j+=1

j=6, i=4

默认关系case2：D(4,d)+D(d,2)=D(4,2)
默认关系case1：D(0,d)+D(d,5)>D(0,5)

n2=1, n3=6, demand=13-18<0,
demand is wrong, break

i =5

同 i=3
初始化的值：
n1=6, demand=0,cost=0,

j=5, i=5

n2=6,demand=0-2<0,
demand is wrong,break

i=6

同 i=3
初始化的值：
n1=1, demand=0,cost=0,

j=6, i=6

n2=1, demand=0-18<0
demand is wrong, break

结束循环!!!

三、循环后的结果

V[3]=b3,
V[4]=b3+D(d,4)+D(4,d)
V[2]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,d)
V[0]=b3+D(d,4)+D(4,d) + D(d,2)+D(2,0)+D(0,d)
V[5]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,d)
V[6]=b3+D(d,4)+D(4,d) +D(d,2)+D(2,0)+D(0,5)+D(5,6)+D(6,d)
V[1]=b3+D(d,4)+D(4,d)+D(d,2)+D(2,0)+D(0,5)+D(5,d)+D(6,1)+D(1,d)
Pred[4]=0
Pred[2]=1
Pred[0]=1
Pred[5]=1
Pred[6]=1
Pred[1]=1

贰：路径提取

def extractRoutes(node_no_seq,Pred,model):
    route_list = []
    route = [model.depot.id]
    label = Pred[node_no_seq[0]]
    for node_id in node_no_seq:
        if Pred[node_id] == label:
            route.append(node_id)
        else:
            route.append(model.depot.id)
            route_list.append(route)
            route = [model.depot.id,node_id]
            label = Pred[node_id]
    route.append(model.depot.id)
    route_list.append(route)
    return route_list

一、基础值

基因序列	3	4	2	0	5	6	1
Demand	-35	24	-13	15	-2	-18	15
Pred	null	0	1	1	1	1	1

route_list：用于存放vehicle的路线
route=[d]
label:当前节点的标签

node_id=3

Dudge: Pred[3]==null

ok --> route=[d, 3]

node_id=4

Dudge:Pred[4]==null

wrong–
route=[d，3, d]
route_list=[[d,3, d], ]
重置route=[d, 4]
更新 label=0

node_id=2

Dudge: Pred[2]==0

wrong–
route=[d, 4, d]
route_list=[ [d,3,d], [d,4,d], ]
重置route=[d,2]
更新 label=1

out:
route_list=[
[d,3,d],
[d,4,d],
[d,2,0,5,6,1] ]

改进篇

1.路径提取

在这里插入图片描述
一个栗子

第二个栗子

node_no_seq	3	4	2	0	5	6	1
Pred=P	-1	-1	1	1	1	1	1

旧方法

route=[d]; label=-1
循环 node_id=3

route=[d, 3]

循环 node_id=4

route=[d, 3, 4]

循环 node_id=2

route=[d, 3, 4, d]
route_list=[ [d, 3, 4, d], ]
route=[d, 2]
label=1

循环 node_id =0

route =[d, 2, 0]

循环 node_id =5

route=[d, 2, 0, 5]

循环node_id =6

route=[d, 2, 0, 5, 6]

循环 node_id=1

route=[d, 2, 0, 5, 6]

route=[d, 2, 0, 5, 6, d]
rout_list=[
[d, 3, 4, d],
[d, 2, 0, 5, 6, d] ]

改进篇

j=len(node_no_seq)=7
第一次循环

i = 1(节点序列中的末尾节点的标签)
route=[d]
route.extend([2, 0, 5, 6,1])=[d, 2, 0, 5, 6, 1]
route=[d, 2, 0, 5, 6, 1, d]
j=i+1=2
if i== -1:否

第二次循环

i=-1(序列中从尾部去除后面一辆车后末尾节点的标签)
route=[d]
route,extend([3,4])=[d, 3,4]
route=[d, 3, 4, d]
j=0
if i==-1:是==》结束循环

2. 路径分隔

比较1：相同
在这里插入图片描述
比较2：位置的调整

比较3：

node_no_seq	3	4	2	0	5	1
demand	10	5	16	7	9	5

假设仓库容量的上限为20.获取Pred.
V={} 到达当前节点的成本,默认为正无穷；特设V[d]=0,
P={} 节点的车辆标签

i=0

n1=3, load=0, cost=0
while j=0, i=0

n2=n1=3
cost=D(d, 3)+D(3, d)
load=0+10=10<20满足
Dudge: load, Time is OK
n4=d (depot的id号)

Dudge: V[d]+cost<=V[3]
left=0+D(d, 3)+D(3, d)
right=infinity

V[3]=D(d, 3)+D(3, d)
P[3]=-1

while j=1, i=0

n2= 4, n3=3
cost=D(d, 3,)+D(3,4)+D(4,d)
load=10+1=15=15<20满足
Dudge:load,Time is OK
n4=d(depot的id号)

Dudge:V[d]+cost<=V[4]
left=D(d, 3,)+D(3,4)+D(4,d)
right=infinity

V[4]=D(d, 3,)+D(3,4)+D(4,d)
P[4]=-1
while j=2, i=0
n2=2, n3=4
cost=D(d, 3,)+D(3,4)+D(4,2)+D(2,d)
load=15+16=31>20 不满足，跳出while循环

i=1

已有：

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
P[3]=-1
P[4]=-1

初始条件：
n1=4, load=0, cost=0,
while j=1,i=1

n2=n1=4
cost=D(d, 4)+D(4,d)
load=0+16=16<20
Dudge: load,time is OK
n4=3

Dudge: V[3]+cost<=V[4]
left=D(d, 3)+D(3, d) + D(d, 4)+D(4,d)
right=D(d, 3,)+D(3,4)+D(4,d)
假设case1 : D(3, d) + D(d, 4) > D(3,d)
不成立，不更新

while j=2, i=1

n2=2, n3=4,
cost=D(d, 4)+D(4, 2)+D(2,d)
load=16+7=23>20
不满足，跳出while循环

i=2

已有：

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
P[3]=-1
P[4]=-1

初始条件：
n1=2, load=0, cost=0,
while j=2,i=2

n2=n1=2,
cost=D(d, 2)+D(2,d)
load=0+16=16<20
*Dudge: load, Time is OK
n4=4

Dudge: V[4]+cost<=V[2]
left=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
right=infinity

V[2]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
P[2]=1

while j=3,i=2

n2=0, n3=2
cost=D(d, 2)+D(2,0)+D(0, d)
load=16+7=23>20 不满足，跳出while的循环

i=3

已有：

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
V[2]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
P[3]=-1
P[4]=-1
P[2]=1

初始条件：
n1=0, load=0, cost=0,

while j=3, i=3

n2=n1=0,
load=0+7=7 满足
cost=D(d,0)+D(0,d)
n4=2

Dudge: V[2]+cost <=V[0]
left=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)
right=infnity

V[0]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)
P[0]=2

while j=4,i=3

n2=5, n3=0
load=7+9=16<20 满足
cost=D(d, 0)+D(0,5)+D(5,d)
n4=2

Dudge:V[2]+cost<=V[5]
left=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
right=infnity

V[5]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
P[5]=2

while j=5, i=3

n2=1, n3=5
load =16+5=21>20不满足，跳出while的循环。

i=4

已有：

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
V[2]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
V[0]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)
V[5]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
P[3]=-1
P[4]=-1
P[2]=1
P[0]=2
P[5]=2

初始条件：
n5=5, load=0, cost=0,

while j=4, i=4

n2=n1=5,
load=0+9=9<20 满足
cost=D(d, 5)+D(5,d)
n4=0

Dudge: V[0]+cost<=V[5]
left=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,d)
right=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
假设case1: D(0,d)+D(d, 5> D(0,5)
不更新

while j=5, i=4

n2=1, n3=5,
load=9+5=14<20满足
cost=D(d, 5)+D(5,1)+D(1,d)
n4=0

Dudge: V[0]+cost<=V[1]
left=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,1）+D(1,d)
right=infnity

V[1]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)++D(5,1）+D(1,d)
P[1]=3
结束while的循环

i=5

已有：

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
V[2]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
V[0]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)
V[5]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
V[1]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,1）+D(1,d)+D(5,1）+D(1,d)
P[3]=-1
P[4]=-1
P[2]=1
P[0]=2
P[5]=2
P[1]=3

初始条件：
n5=1, load=0, cost=0,
while j=5,i=5

n2=n1=1
load=0+5=5<20 满足
cost=D(d, 1)+D(1,d)
n4=5

Dudge: V[5]+cost<=V[1]
left =D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)+D(d, 1)+D(1,d)
right=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,1）+D(1,d)
case1: D(0,5)+D(5,d)+D(d, 1) > D(0,d)+D(d, 5)+D(5,1）, 不更新
case2:D(0,5)+D(5,d)+D(d, 1) <= D(0,d)+D(d, 5)+D(5,1）, 更新

假设情况为case2:
V[1]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,1）+D(1,d)
P[1]= 4

总结

V[3]=D(d, 3)+D(3, d)
V[4]=D(d, 3,)+D(3,4)+D(4,d)
V[2]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)
V[0]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)
V[5]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d)+D(d, 0)+D(0,5)+D(5,d)
V[1]=V[1]=D(d, 3,)+D(3,4)+D(4,d) + D(d, 2)+D(2,d) +D(d,0)+D(0,d)+D(d, 5)+D(5,1）+D(1,d)
P[3]=-1
P[4]=-1
P[2]=1
P[0]=2
P[5]=2
P[1]=4

在节点A后判断节点B是否可以构成下一个节点的要求：

装载量： vehicle的下限<=当前vehicle的存储量+任务需求量<=vehilce的上限
时间窗口的限制

节点B的到达时间：max(节点B的开始时间，节点A的离开时间+从A到B的移动时间)
节点B的离开时间：节点B的到达时间+服务节点B的时间
节点B到达depot的时间：节点B的离开时间+从B到depot的移动时间
判断节点B可以是节点A的后续节点的时间限制为：

节点B的离开时间<节点B的服务结束时间(同时隐藏限制为：节点B的到达时间<节点B的结束时间)
节点B到达depot的时间<depot的结束时间