问题描述
我正在尝试解决具有多种货物类型和容量的 CVRP。假设我有四辆车和两种货物（橙子和苹果）。每个 Vehicle 对苹果和橙子的容量不同，每个节点都有不同的需求。两辆车只能运输苹果，两辆车只能运输橙子。所以我定义了以下数据：
data['demands_oranges'] = [0,1,2,4,8,8]
data['demands_apples'] = [0,8]
data['vehicle_capacities_oranges'] = [0,40,40]
data['vehicle_capacities_apples'] = [40,0]
另外，我为每个容量定义了两个维度：
# Add Capacity constraint.
def demand_callback_apples(from_index):
"""Returns the demand of the node."""
# Convert from routing variable Index to demands NodeIndex.
from_node = manager.IndexToNode(from_index)
return data['demands_apples'][from_node]
demand_callback_index_apples = routing.RegisterUnaryTransitCallback(
demand_callback_apples)
routing.AddDimensionWithVehicleCapacity(
demand_callback_index_apples,# null capacity slack
data['vehicle_capacities_apples'],# vehicle maximum capacities
True,# start cumul to zero
'Capacity_apples')
def demand_callback_oranges(from_index):
"""Returns the demand of the node."""
# Convert from routing variable Index to demands NodeIndex.
from_node = manager.IndexToNode(from_index)
return data['demands_oranges'][from_node]
demand_callback_index_oranges = routing.RegisterUnaryTransitCallback(
demand_callback_oranges)
routing.AddDimensionWithVehicleCapacity(
demand_callback_index_oranges,# null capacity slack
data['vehicle_capacities_oranges'],# start cumul to zero
'Capacity_oranges')
问题是，此输入数据没有返回任何解决方案。尽管事实上车辆容量甚至没有接近被超过。 当我使用时，模型出于某种原因工作：
data['vehicle_capacities_oranges'] = [0,40]
data['vehicle_capacities_apples'] = [0,40]
但这不是我需要的。这是什么原因？
代码：
"""Capacited Vehicles Routing Problem (CVRP)."""
from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp
def create_data_model():
"""Stores the data for the problem."""
data = {}
data['distance_matrix'] = [
[
0,548,776,696,582,274,502,194,308,536,388,354,468,662
],[
548,684,730,742,1084,594,480,674,1016,868,1210
],[
776,992,878,810,400,1278,1164,1130,788,1552,754
],[
696,114,650,844,890,1232,514,628,822,560,1358
],[
582,764,1118,708,1050,1244
],[
274,228,240,662,708
],[
502,1004,856,480
],[
194,342,320,856
],[
308,514
],422,468
],[
536,1152,354
],844
],[
388,730
],[
354,536
],[
468,194
],798
],[
662,1210,754,1358,1244,798,0
],]
data['demands_oranges'] = [0,8]
data['vehicle_capacities_oranges'] = [0,40]
data['vehicle_capacities_apples'] = [0,40]
data['price_per_km'] = [1,1]
data["price_per_stop"] = [1,1]
data['num_vehicles'] = 4
data['depot'] = 0
return data
def print_solution(data,manager,routing,solution):
"""Prints solution on console."""
for capacity_ID in ['demands_oranges','demands_apples']:
print("____Capacity_{}_____".format(capacity_ID))
total_distance = 0
total_load = 0
for vehicle_id in range(data['num_vehicles']):
index = routing.Start(vehicle_id)
plan_output = 'Route for vehicle {}:\n'.format(vehicle_id)
route_distance = 0
route_load = 0
while not routing.IsEnd(index):
node_index = manager.IndexToNode(index)
route_load += data[str(capacity_ID)][node_index]
plan_output += ' {0} Load({1}) -> '.format(node_index,route_load)
prevIoUs_index = index
index = solution.Value(routing.Nextvar(index))
route_distance += routing.GetArcCostForVehicle(
prevIoUs_index,index,vehicle_id)
plan_output += ' {0} Load({1})\n'.format(manager.IndexToNode(index),route_load)
plan_output += 'distance of the route: {}m\n'.format(route_distance)
plan_output += 'Load of the route: {}\n'.format(route_load)
print(plan_output)
total_distance += route_distance
total_load += route_load
print('Total distance of all routes: {}m'.format(total_distance))
print('Total load of all routes: {}'.format(total_load))
def main():
"""Solve the CVRP problem."""
# Instantiate the data problem.
data = create_data_model()
# Create the routing index manager.
manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),data['num_vehicles'],data['depot'])
# Create Routing Model.
routing = pywrapcp.RoutingModel(manager)
### Kosten festlegen ###
def create_cost_callback(dist_matrix,km_costs,stop_costs):
# Create a callback to calculate distances between cities.
def distance_callback(from_index,to_index):
from_node = manager.IndexToNode(from_index)
to_node = manager.IndexToNode(to_index)
return int(dist_matrix[from_node][to_node]) * (km_costs) + (stop_costs)
return distance_callback
for i in range(data['num_vehicles']):
cost_callback = create_cost_callback(data['distance_matrix'],data["price_per_km"][i],data["price_per_stop"][i]) # Callbackfunktion erstellen
cost_callback_index = routing.RegisterTransitCallback(cost_callback) # registrieren
routing.SetArcCostEvaluatorOfVehicle(cost_callback_index,i) # Vehicle zuordnen
# Add Capacity constraint.
def demand_callback_apples(from_index):
"""Returns the demand of the node."""
# Convert from routing variable Index to demands NodeIndex.
from_node = manager.IndexToNode(from_index)
return data['demands_apples'][from_node]
demand_callback_index_apples = routing.RegisterUnaryTransitCallback(
demand_callback_apples)
routing.AddDimensionWithVehicleCapacity(
demand_callback_index_apples,# start cumul to zero
'Capacity_oranges')
# Setting first solution heuristic.
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEApest_ARC)
search_parameters.local_search_Metaheuristic = (
routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
search_parameters.time_limit.FromSeconds(10)
# Solve the problem.
solution = routing.solveWithParameters(search_parameters)
# Print solution on console.
if solution:
print_solution(data,solution)
print(solution)
if __name__ == '__main__':
main()
解决方法
所有位置只能访问一次
因此，如果您有 apples 和 oranges，您应该复制该位置，这样一辆车会访问一个位置，另一辆车会访问一个...
注意：当你改变你的容量使车辆可以携带两种类型时，它就可以工作了