ortools-clone/examples/cpp/vrp.cc

// Copyright 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.


#include <vector>
#include <cmath>
#include "ortools/base/logging.h"
#include "ortools/constraint_solver/routing.h"

namespace operations_research {
  class DataProblem {
    private:
      std::vector<std::vector<int>> locations_;

    public:
      DataProblem() {
        locations_ = {
          {4, 4},
          {2, 0}, {8, 0},
          {0, 1}, {1, 1},
          {5, 2}, {7, 2},
          {3, 3}, {6, 3},
          {5, 5}, {8, 5},
          {1, 6}, {2, 6},
          {3, 7}, {6, 7},
          {0, 8}, {7, 8}
        };

        // Compute locations in meters using the block dimension defined as follow
        // Manhattan average block: 750ft x 264ft -> 228m x 80m
        // here we use: 114m x 80m city block
        // src: https://nyti.ms/2GDoRIe "NY Times: Know Your distance"
        std::array<int, 2> cityBlock = {228/2, 80};
        for (auto &i: locations_) {
          i[0] = i[0] * cityBlock[0];
          i[1] = i[1] * cityBlock[1];
        }
      }

      std::size_t GetVehicleNumber() const { return 4;}
      const std::vector<std::vector<int>>& GetLocations() const { return locations_;}
      RoutingModel::NodeIndex GetDepot() const { return RoutingModel::kFirstNode;}
  };

  /*! @brief Manhattan distance implemented as a callback.
   * @details It uses an array of positions and
   * computes the Manhattan distance between the two positions of two different indices.*/
  class ManhattanDistance: public RoutingModel::NodeEvaluator2 {
    private:
      std::vector<std::vector<int64>> distances_;
    public:
      ManhattanDistance(const DataProblem& data) {
      // Precompute distance between location to have distance callback in O(1)
      distances_ = std::vector<std::vector<int64>>(
          data.GetLocations().size(),
          std::vector<int64>(
            data.GetLocations().size(),
            0LL));
      for (std::size_t fromNode = 0; fromNode < data.GetLocations().size(); fromNode++) {
        for (std::size_t toNode = 0; toNode < data.GetLocations().size(); toNode++) {
          if (fromNode != toNode)
            distances_[fromNode][toNode] =
              std::abs(data.GetLocations()[toNode][0] - data.GetLocations()[fromNode][0]) +
              std::abs(data.GetLocations()[toNode][1] - data.GetLocations()[fromNode][1]);
        }
      }
    }

    bool IsRepeatable() const override {return true;}

    //! @brief Returns the manhattan distance between the two nodes.
    int64 Run(RoutingModel::NodeIndex FromNode, RoutingModel::NodeIndex ToNode) override {
      return distances_[FromNode.value()][ToNode.value()];
    }
  };

  //! @brief Add distance Dimension.
  //! @param[in] data Data of the problem.
  //! @param[in, out] routing Routing solver used.
  static void AddDistanceDimension(const DataProblem& data, RoutingModel* routing) {
    std::string distance("Distance");
    routing->AddDimension(
        new ManhattanDistance(data),
        0,  // null slack
        3000, // maximum distance per vehicle
        true, // start cumul to zero
        distance);
    RoutingDimension* distanceDimension = routing->GetMutableDimension(distance);
    // Try to minimize the max distance among vehicles.
    // /!\ It doesn't mean the standard deviation is minimized
    distanceDimension->SetGlobalSpanCostCoefficient(100);
  }

  //! @brief Print the solution
  //! @param[in] data Data of the problem.
  //! @param[in] routing Routing solver used.
  //! @param[in] solution Solution found by the solver.
  void PrintSolution(
      const DataProblem& data,
      const RoutingModel& routing,
      const Assignment& solution) {
    LOG(INFO) << "Objective: " << solution.ObjectiveValue();
    // Inspect solution.
    for (int i=0; i < data.GetVehicleNumber(); ++i) {
      int64 index = routing.Start(i);
      LOG(INFO) << "Route for Vehicle " << i << ":";
      int64 distance = 0LL;
      std::stringstream route;
      while (routing.IsEnd(index) == false) {
        route << routing.IndexToNode(index).value() << " -> ";
        int64 previous_index = index;
        index = solution.Value(routing.NextVar(index));
        distance += const_cast<RoutingModel&>(routing).GetArcCostForVehicle(previous_index, index, i);
      }
      LOG(INFO) << route.str() << routing.IndexToNode(index).value();
      LOG(INFO) << "Distance of the route: " << distance << "m";
    }
  }

  void Solve() {
    // Instantiate the data problem.
    DataProblem data;

    // Create Routing Model
    RoutingModel routing(
        data.GetLocations().size(),
        data.GetVehicleNumber(),
        data.GetDepot());

    // Define weight of each edge
    ManhattanDistance distance(data);
    routing.SetArcCostEvaluatorOfAllVehicles(
        NewPermanentCallback(&distance, &ManhattanDistance::Run));
    AddDistanceDimension(data, &routing);

    // Setting first solution heuristic (cheapest addition).
    auto searchParameters = RoutingModel::DefaultSearchParameters();
    searchParameters.set_first_solution_strategy(
        FirstSolutionStrategy::PATH_CHEAPEST_ARC);

    const Assignment* solution = routing.SolveWithParameters(searchParameters);
    PrintSolution(data, routing, *solution);
  }
}  // namespace operations_research

int main(int argc, char** argv) {
  google::InitGoogleLogging(argv[0]);
  FLAGS_logtostderr = 1;
  operations_research::Solve();
  return 0;
}