From 4e45ef0c33cca990fd0a1415dff41931a6b5bd2d Mon Sep 17 00:00:00 2001 From: Corentin Le Molgat Date: Thu, 10 Jan 2019 16:01:24 +0100 Subject: [PATCH] Add vrp_pickup_delivery.cc --- makefiles/Makefile.cpp.mk | 1 + .../samples/vrp_pickup_delivery.cc | 202 ++++++++++++++++++ 2 files changed, 203 insertions(+) create mode 100644 ortools/constraint_solver/samples/vrp_pickup_delivery.cc diff --git a/makefiles/Makefile.cpp.mk b/makefiles/Makefile.cpp.mk index 65a2c01c5c..4062528aed 100755 --- a/makefiles/Makefile.cpp.mk +++ b/makefiles/Makefile.cpp.mk @@ -375,6 +375,7 @@ test_cc_constraint_solver_samples: \ rcc_vrp_capacity \ rcc_vrp_drop_nodes \ rcc_vrp_global_span \ + rcc_vrp_pickup_delivery \ rcc_vrp_starts_ends \ rcc_vrp_time_windows \ diff --git a/ortools/constraint_solver/samples/vrp_pickup_delivery.cc b/ortools/constraint_solver/samples/vrp_pickup_delivery.cc new file mode 100644 index 0000000000..224ef1fa6d --- /dev/null +++ b/ortools/constraint_solver/samples/vrp_pickup_delivery.cc @@ -0,0 +1,202 @@ +// Copyright 2010-2018 Google LLC +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// [START program] +// [START import] +#include +#include "ortools/constraint_solver/routing.h" +#include "ortools/constraint_solver/routing_enums.pb.h" +#include "ortools/constraint_solver/routing_index_manager.h" +#include "ortools/constraint_solver/routing_parameters.h" +// [END import] + +namespace operations_research { +// [START data_model] +struct DataModel { + DataModel() + : distance_matrix({ + {0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, + 468, 776, 662}, + {548, 0, 684, 308, 194, 502, 730, 354, 696, 742, 1084, 594, 480, + 674, 1016, 868, 1210}, + {776, 684, 0, 992, 878, 502, 274, 810, 468, 742, 400, 1278, 1164, + 1130, 788, 1552, 754}, + {696, 308, 992, 0, 114, 650, 878, 502, 844, 890, 1232, 514, 628, + 822, 1164, 560, 1358}, + {582, 194, 878, 114, 0, 536, 764, 388, 730, 776, 1118, 400, 514, + 708, 1050, 674, 1244}, + {274, 502, 502, 650, 536, 0, 228, 308, 194, 240, 582, 776, 662, 628, + 514, 1050, 708}, + {502, 730, 274, 878, 764, 228, 0, 536, 194, 468, 354, 1004, 890, + 856, 514, 1278, 480}, + {194, 354, 810, 502, 388, 308, 536, 0, 342, 388, 730, 468, 354, 320, + 662, 742, 856}, + {308, 696, 468, 844, 730, 194, 194, 342, 0, 274, 388, 810, 696, 662, + 320, 1084, 514}, + {194, 742, 742, 890, 776, 240, 468, 388, 274, 0, 342, 536, 422, 388, + 274, 810, 468}, + {536, 1084, 400, 1232, 1118, 582, 354, 730, 388, 342, 0, 878, 764, + 730, 388, 1152, 354}, + {502, 594, 1278, 514, 400, 776, 1004, 468, 810, 536, 878, 0, 114, + 308, 650, 274, 844}, + {388, 480, 1164, 628, 514, 662, 890, 354, 696, 422, 764, 114, 0, + 194, 536, 388, 730}, + {354, 674, 1130, 822, 708, 628, 856, 320, 662, 388, 730, 308, 194, + 0, 342, 422, 536}, + {468, 1016, 788, 1164, 1050, 514, 514, 662, 320, 274, 388, 650, 536, + 342, 0, 764, 194}, + {776, 868, 1552, 560, 674, 1050, 1278, 742, 1084, 810, 1152, 274, + 388, 422, 764, 0, 798}, + {662, 1210, 754, 1358, 1244, 708, 480, 856, 514, 468, 354, 844, 730, + 536, 194, 798, 0}, + }), + pickup_deliveries({ + {RoutingIndexManager::NodeIndex{7}, + RoutingIndexManager::NodeIndex{1}}, + {RoutingIndexManager::NodeIndex{3}, + RoutingIndexManager::NodeIndex{4}}, + {RoutingIndexManager::NodeIndex{5}, + RoutingIndexManager::NodeIndex{8}}, + {RoutingIndexManager::NodeIndex{6}, + RoutingIndexManager::NodeIndex{2}}, + {RoutingIndexManager::NodeIndex{11}, + RoutingIndexManager::NodeIndex{12}}, + {RoutingIndexManager::NodeIndex{13}, + RoutingIndexManager::NodeIndex{15}}, + {RoutingIndexManager::NodeIndex{10}, + RoutingIndexManager::NodeIndex{9}}, + {RoutingIndexManager::NodeIndex{16}, + RoutingIndexManager::NodeIndex{14}}, + }), + num_vehicles(4), + depot(0) {} + const std::vector> distance_matrix; + const std::vector> + pickup_deliveries; + const int num_vehicles; + const RoutingIndexManager::NodeIndex depot; +}; // namespace operations_research +// [END data_model] + +// [START solution_printer] +//! @brief Print the solution. +//! @param[in] data Data of the problem. +//! @param[in] manager Index manager used. +//! @param[in] routing Routing solver used. +//! @param[in] solution Solution found by the solver. +void PrintSolution(const DataModel& data, const RoutingIndexManager& manager, + const RoutingModel& routing, const Assignment& solution) { + LOG(INFO) << "Objective: " << solution.ObjectiveValue(); + int64 total_distance{0}; + for (int vehicle_id = 0; vehicle_id < data.num_vehicles; ++vehicle_id) { + int64 index = routing.Start(vehicle_id); + LOG(INFO) << "Route for Vehicle " << vehicle_id << ":"; + int64 route_distance{0}; + std::stringstream route; + while (routing.IsEnd(index) == false) { + route << manager.IndexToNode(index).value() << " -> "; + int64 previous_index = index; + index = solution.Value(routing.NextVar(index)); + route_distance += const_cast(routing).GetArcCostForVehicle( + previous_index, index, int64{vehicle_id}); + } + LOG(INFO) << route.str() << manager.IndexToNode(index).value(); + LOG(INFO) << "Distance of the route: " << route_distance << "m"; + total_distance += route_distance; + } + LOG(INFO) << "Total distance of all routes: " << total_distance << "m"; + LOG(INFO) << ""; + LOG(INFO) << "Advanced usage:"; + LOG(INFO) << "Problem solved in " << routing.solver()->wall_time() << "ms"; +} +// [END solution_printer] + +void VrpGlobalSpan() { + // Instantiate the data problem. + // [START data] + DataModel data; + // [END data] + + // Create Routing Index Manager + // [START index_manager] + RoutingIndexManager manager(data.distance_matrix.size(), data.num_vehicles, + data.depot); + // [END index_manager] + + // Create Routing Model. + // [START routing_model] + RoutingModel routing(manager); + // [END routing_model] + + // Define cost of each arc. + // [START arc_cost] + const int transit_cost_id = routing.RegisterTransitCallback( + [&data, &manager](int64 from_index, int64 to_index) -> int64 { + return data.distance_matrix[manager.IndexToNode(from_index).value()] + [manager.IndexToNode(to_index).value()]; + }); + routing.SetArcCostEvaluatorOfAllVehicles(transit_cost_id); + // [END arc_cost] + + // Add Distance constraint. + // [START distance_constraint] + routing.AddDimension(transit_cost_id, // transit callback + 0, // no slack + 3000, // vehicle maximum travel distance + true, // start cumul to zero + "Distance"); + const RoutingDimension& distance_dimension = + routing.GetDimensionOrDie("Distance"); + const_cast(distance_dimension) + .SetGlobalSpanCostCoefficient(100); + // [END distance_constraint] + + // Define Transportation Requests. + // [START pickup_delivery] + Solver* const solver = routing.solver(); + for (auto& request : data.pickup_deliveries) { + int64 pickup_index = manager.NodeToIndex(request[0]); + int64 delivery_index = manager.NodeToIndex(request[1]); + routing.AddPickupAndDelivery(pickup_index, delivery_index); + solver->AddConstraint(solver->MakeEquality( + routing.VehicleVar(pickup_index), routing.VehicleVar(delivery_index))); + solver->AddConstraint( + solver->MakeLessOrEqual(distance_dimension.CumulVar(pickup_index), + distance_dimension.CumulVar(delivery_index))); + } + // [END pickup_delivery] + + // Setting first solution heuristic. + // [START parameters] + RoutingSearchParameters searchParameters = DefaultRoutingSearchParameters(); + searchParameters.set_first_solution_strategy( + FirstSolutionStrategy::PARALLEL_CHEAPEST_INSERTION); + // [END parameters] + + // Solve the problem. + // [START solve] + const Assignment* solution = routing.SolveWithParameters(searchParameters); + // [END solve] + + // Print solution on console. + // [START print_solution] + PrintSolution(data, manager, routing, *solution); + // [END print_solution] +} +} // namespace operations_research + +int main(int argc, char** argv) { + operations_research::VrpGlobalSpan(); + return EXIT_SUCCESS; +} +// [END program]