如何解释Google或Google工具返回的“车辆路径问题”解决方案？

时间：2020-07-29 20:16:07

标签： python python-3.x or-tools vehicle-routing

我有一个有效的“车辆路线问题”解决方案，该解决方案是使用Google的OR Tools python库实现的。我有一个9个位置的时间矩阵，以及每个位置的时间窗口。所有值均以秒为单位。

（例如，第一个时间窗是从28800到28800。28800秒相当于8:00 am。我希望在 depot 这个位置精确地在8点访问：00am）

我打算仅用一辆车解决这个问题（本质上是解决旅行销售员问题）。我相信我已经正确添加了尺寸，但是我肯定会犯一个错误-我的意图是允许车辆在任意位置等待尽可能长的时间，例如因为它可以解决车辆路径问题。我将上限最大值设置为86400，因为一天中有86400秒，并且我认为对于此数据，这将是一个足够高的数字。

来源 

from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2

Matrix = [
  [0,557,763,1156,813,618,822,700,112],       # Depot
  [523,0,598,1107,934,607,658,535,589],       # 1 - Location
  [631,480,0,968,960,570,451,135,582],        # 2 - Location
  [1343,1247,1367,0,1270,1289,809,1193,1253], # 3 - Location
  [746,1000,1135,1283,0,1003,1186,1071,776],  # 4 - Location
  [685,627,810,1227,990,0,712,709,550],       # 5 - Location
  [869,718,558,732,1105,650,0,384,821],       # 6 - Location
  [679,528,202,878,1008,618,412,0,630],       # 7 - Location
  [149,626,762,1124,696,532,821,698,0]        # 8 - Location
]

Windows = [
  [ 28800, 28800 ], # Depot
  [ 43200, 43200 ], # 1 - Location
  [ 50400, 50400 ], # 2 - Location
  [ 21600, 79200 ], # 3 - Location
  [ 21600, 79200 ], # 4 - Location
  [ 21600, 79200 ], # 5 - Location
  [ 21600, 79200 ], # 6 - Location
  [ 21600, 79200 ], # 7 - Location
  [ 21600, 79200 ]  # 8 - Location
]

# Create the routing index manager.
manager = pywrapcp.RoutingIndexManager(len(Matrix), 1, 0)

# Create Routing Model.
routing = pywrapcp.RoutingModel(manager)

# Create and register a transit callback.
def time_callback(from_index, to_index):
  # Returns the travel time between the two nodes.
  # Convert from routing variable Index to time matrix NodeIndex.
  from_node = manager.IndexToNode(from_index)
  to_node = manager.IndexToNode(to_index)
  return Matrix[from_node][to_node]

transit_callback_index = routing.RegisterTransitCallback(time_callback)

# Define cost of each arc.
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

# Add Time Windows constraint.
routing.AddDimension(
    transit_callback_index,
    86400,  # An upper bound for slack (the wait times at the locations).
    86400,  # An upper bound for the total time over each vehicle's route.
    False,  # Determine whether the cumulative variable is set to zero at the start of the vehicle's route.
    'Time')
time_dimension = routing.GetDimensionOrDie('Time')

# Add time window constraints for each location except depot.
for location_idx, time_window in enumerate(Windows):
  if location_idx == 0:
    continue
  index = manager.NodeToIndex(location_idx)
  time_dimension.CumulVar(index).SetRange(time_window[0], time_window[1])

# Add time window constraints for each vehicle start node.
index = routing.Start(0)
time_dimension.CumulVar(index).SetRange(Windows[0][0],Windows[0][1])

# Instantiate route start and end times to produce feasible times.
routing.AddVariableMinimizedByFinalizer(time_dimension.CumulVar(routing.Start(0)))
routing.AddVariableMinimizedByFinalizer(time_dimension.CumulVar(routing.End(0)))

# Setting first solution heuristic. 
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)

# Setting local search metaheuristics:
search_parameters.local_search_metaheuristic = (routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
search_parameters.time_limit.seconds = 5
search_parameters.log_search = False

# Solve the problem.
solution = routing.SolveWithParameters(search_parameters)

# Return the solution.
time = 0
index = routing.Start(0)
print("Locations:")
while not routing.IsEnd(index):
  time = time_dimension.CumulVar(index)
  print("{0} ({1}, {2})".format(manager.IndexToNode(index),solution.Min(time),solution.Max(time)))
  index = solution.Value(routing.NextVar(index))
print("{0} ({1}, {2})".format(manager.IndexToNode(index),solution.Min(time),solution.Max(time)))

输出 

Locations:
0 (28800, 28800)
8 (28912, 42041)
5 (29444, 42573)
1 (43200, 43200)
2 (50400, 50400)
7 (50535, 50535)
6 (50947, 50947)
3 (51679, 51679)
4 (52949, 52949)
0 (52949, 52949)

我的问题是关于解决方案为我计算的输出。我对解决方案中第二和第三位置的时间窗口感到困惑。我希望所有时间窗口看起来都像其余结果一样。在处理解决方案时，solution.Min()和solution.Max()值在此问题范围内意味着什么？我在使用OR工具时是否存在任何明显的错误？

2 个答案:

答案 0 :(得分：1)

我对这个元组的了解是，你拥有

(Min_time, Max_time)

Min_time是满足时间窗口应到达的最短时间。因为Max_time的逻辑是完全相同的。

当您到达满足约束条件的节点时，程序将输出一个范围。

答案 1 :(得分：1)

>>> dct =  {'x': [(['a'], ['b'], ['c'], ['d'], ['e'], ['f'])]}
>>> {k:[tuple([c for c in l]+[i+1] for i,l in enumerate(t)) for t in v ] for k,v in dct.items()}
{'x': [(['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5], ['f', 6])]}

查看我添加的评论。当到达时间是一个范围（例如节点8或5）时，基本上意味着到达时间需要落在该时间范围内。只要满足条件，该解决方案就仍然可行。

您可以按以下方式进行验证：

Locations:
0 (28800, 28800) // must arrive and leave no later than 28800
8 (28912, 42041) // must arrive at or after 28912 and leave no later than 42041
5 (29444, 42573) // must arrive at or after 29444and leave no later than 42573
1 (43200, 43200) // must arrive and leave no later than 43200
2 (50400, 50400) // must arrive and leave no later than 50400

在时间28800出发的仓库中，旅行时间为112，将使您在时间28912（解决方案中的最小值）到达位置8，而在时间为532时立即离开，则您将到达位置5。时间29444。

现在，Depot [28800, 28800] -> Travel (0, 8) 112-> Loc 8 [21600, 79200] -> Travel (8, 5) 532 -> Loc 5 [21600, 79200] -> Travel (5, 1) 685 -> Loc 1 [43200, 43200] 有一个可用的时隙，即loc 1。因此，如果车辆在时间43200离开，行驶时间为29444，它将在时间627到达loc 1，这不是有效的到达时间。但是，如果车辆要在30071离开，它将按时到达。因此，这意味着车辆需要闲置一段时间（松弛）才能行驶。由于43200-627= 42573和loc 8都具有范围，因此该解决方案指出，这些位置存在一定的余量。因此，只要到达和离开的范围内，最小值和最大值真正告诉您的是该解决方案是可行的。

相关问题
最新问题