239 lines
8.4 KiB
C++
239 lines
8.4 KiB
C++
// Copyright 2010-2017 Google
|
|
// 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 "examples/cpp/cvrptw_lib.h"
|
|
|
|
#include <set>
|
|
|
|
#include "ortools/base/logging.h"
|
|
#include "ortools/base/random.h"
|
|
#include "ortools/base/stringprintf.h"
|
|
#include "ortools/constraint_solver/routing.h"
|
|
|
|
namespace operations_research {
|
|
|
|
int32 GetSeed(bool deterministic) {
|
|
if (deterministic) {
|
|
return ACMRandom::DeterministicSeed();
|
|
} else {
|
|
return ACMRandom::HostnamePidTimeSeed();
|
|
}
|
|
}
|
|
|
|
LocationContainer::LocationContainer(int64 speed, bool use_deterministic_seed)
|
|
: randomizer_(GetSeed(use_deterministic_seed)), speed_(speed) {
|
|
CHECK_LT(0, speed_);
|
|
}
|
|
|
|
void LocationContainer::AddRandomLocation(int64 x_max, int64 y_max) {
|
|
AddRandomLocation(x_max, y_max, 1);
|
|
}
|
|
|
|
void LocationContainer::AddRandomLocation(int64 x_max, int64 y_max,
|
|
int duplicates) {
|
|
const int64 x = randomizer_.Uniform(x_max + 1);
|
|
const int64 y = randomizer_.Uniform(y_max + 1);
|
|
for (int i = 0; i < duplicates; ++i) {
|
|
AddLocation(x, y);
|
|
}
|
|
}
|
|
|
|
int64 LocationContainer::ManhattanDistance(RoutingModel::NodeIndex from,
|
|
RoutingModel::NodeIndex to) const {
|
|
return locations_[from].DistanceTo(locations_[to]);
|
|
}
|
|
|
|
int64 LocationContainer::NegManhattanDistance(
|
|
RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) const {
|
|
return -ManhattanDistance(from, to);
|
|
}
|
|
|
|
int64 LocationContainer::ManhattanTime(RoutingModel::NodeIndex from,
|
|
RoutingModel::NodeIndex to) const {
|
|
return ManhattanDistance(from, to) / speed_;
|
|
}
|
|
|
|
bool LocationContainer::SameLocation(RoutingModel::NodeIndex node1,
|
|
RoutingModel::NodeIndex node2) const {
|
|
if (node1 < locations_.size() && node2 < locations_.size()) {
|
|
return locations_[node1].IsAtSameLocation(locations_[node2]);
|
|
}
|
|
return false;
|
|
}
|
|
int64 LocationContainer::SameLocationFromIndex(int64 node1, int64 node2) const {
|
|
// The direct conversion from constraint model indices to routing model
|
|
// nodes is correct because the depot is node 0.
|
|
// TODO(user): Fetch proper indices from routing model.
|
|
return SameLocation(RoutingModel::NodeIndex(node1),
|
|
RoutingModel::NodeIndex(node2));
|
|
}
|
|
|
|
LocationContainer::Location::Location() : x_(0), y_(0) {}
|
|
|
|
LocationContainer::Location::Location(int64 x, int64 y) : x_(x), y_(y) {}
|
|
|
|
int64 LocationContainer::Location::DistanceTo(const Location& location) const {
|
|
return Abs(x_ - location.x_) + Abs(y_ - location.y_);
|
|
}
|
|
|
|
bool LocationContainer::Location::IsAtSameLocation(
|
|
const Location& location) const {
|
|
return x_ == location.x_ && y_ == location.y_;
|
|
}
|
|
|
|
int64 LocationContainer::Location::Abs(int64 value) {
|
|
return std::max(value, -value);
|
|
}
|
|
|
|
RandomDemand::RandomDemand(int size, RoutingModel::NodeIndex depot,
|
|
bool use_deterministic_seed)
|
|
: size_(size),
|
|
depot_(depot),
|
|
use_deterministic_seed_(use_deterministic_seed) {
|
|
CHECK_LT(0, size_);
|
|
}
|
|
|
|
void RandomDemand::Initialize() {
|
|
const int64 kDemandMax = 5;
|
|
const int64 kDemandMin = 1;
|
|
demand_.reset(new int64[size_]);
|
|
MTRandom randomizer(GetSeed(use_deterministic_seed_));
|
|
for (int order = 0; order < size_; ++order) {
|
|
if (order == depot_) {
|
|
demand_[order] = 0;
|
|
} else {
|
|
demand_[order] =
|
|
kDemandMin + randomizer.Uniform(kDemandMax - kDemandMin + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64 RandomDemand::Demand(RoutingModel::NodeIndex from,
|
|
RoutingModel::NodeIndex /*to*/) const {
|
|
return demand_[from.value()];
|
|
}
|
|
|
|
ServiceTimePlusTransition::ServiceTimePlusTransition(
|
|
int64 time_per_demand_unit, RoutingModel::NodeEvaluator2* demand,
|
|
RoutingModel::NodeEvaluator2* transition_time)
|
|
: time_per_demand_unit_(time_per_demand_unit),
|
|
demand_(demand),
|
|
transition_time_(transition_time) {}
|
|
|
|
int64 ServiceTimePlusTransition::Compute(RoutingModel::NodeIndex from,
|
|
RoutingModel::NodeIndex to) const {
|
|
return time_per_demand_unit_ * demand_->Run(from, to) +
|
|
transition_time_->Run(from, to);
|
|
}
|
|
|
|
StopServiceTimePlusTransition::StopServiceTimePlusTransition(
|
|
int64 stop_time, const LocationContainer& location_container,
|
|
RoutingModel::NodeEvaluator2* transition_time)
|
|
: stop_time_(stop_time),
|
|
location_container_(location_container),
|
|
transition_time_(transition_time) {}
|
|
|
|
int64 StopServiceTimePlusTransition::Compute(RoutingModel::NodeIndex from,
|
|
RoutingModel::NodeIndex to) const {
|
|
return location_container_.SameLocation(from, to)
|
|
? 0
|
|
: stop_time_ + transition_time_->Run(from, to);
|
|
}
|
|
|
|
void DisplayPlan(
|
|
const RoutingModel& routing, const operations_research::Assignment& plan,
|
|
bool use_same_vehicle_costs, int64 max_nodes_per_group,
|
|
int64 same_vehicle_cost,
|
|
const operations_research::RoutingDimension& capacity_dimension,
|
|
const operations_research::RoutingDimension& time_dimension) {
|
|
// Display plan cost.
|
|
std::string plan_output = StringPrintf("Cost %lld\n", plan.ObjectiveValue());
|
|
|
|
// Display dropped orders.
|
|
std::string dropped;
|
|
for (int64 order = 0; order < routing.Size(); ++order) {
|
|
if (routing.IsStart(order) || routing.IsEnd(order)) continue;
|
|
if (plan.Value(routing.NextVar(order)) == order) {
|
|
if (dropped.empty()) {
|
|
StringAppendF(&dropped, " %d", routing.IndexToNode(order).value());
|
|
} else {
|
|
StringAppendF(&dropped, ", %d", routing.IndexToNode(order).value());
|
|
}
|
|
}
|
|
}
|
|
if (!dropped.empty()) {
|
|
plan_output += "Dropped orders:" + dropped + "\n";
|
|
}
|
|
|
|
if (use_same_vehicle_costs) {
|
|
int group_size = 0;
|
|
int64 group_same_vehicle_cost = 0;
|
|
std::set<int> visited;
|
|
for (int64 order = 0; order < routing.Size(); ++order) {
|
|
if (routing.IsStart(order) || routing.IsEnd(order)) continue;
|
|
++group_size;
|
|
visited.insert(
|
|
plan.Value(routing.VehicleVar(order)));
|
|
if (group_size == max_nodes_per_group) {
|
|
if (visited.size() > 1) {
|
|
group_same_vehicle_cost += (visited.size() - 1) * same_vehicle_cost;
|
|
}
|
|
group_size = 0;
|
|
visited.clear();
|
|
}
|
|
}
|
|
if (visited.size() > 1) {
|
|
group_same_vehicle_cost += (visited.size() - 1) * same_vehicle_cost;
|
|
}
|
|
LOG(INFO) << "Same vehicle costs: " << group_same_vehicle_cost;
|
|
}
|
|
|
|
// Display actual output for each vehicle.
|
|
for (int route_number = 0; route_number < routing.vehicles();
|
|
++route_number) {
|
|
int64 order = routing.Start(route_number);
|
|
StringAppendF(&plan_output, "Route %d: ", route_number);
|
|
if (routing.IsEnd(plan.Value(routing.NextVar(order)))) {
|
|
plan_output += "Empty\n";
|
|
} else {
|
|
while (true) {
|
|
operations_research::IntVar* const load_var =
|
|
capacity_dimension.CumulVar(order);
|
|
operations_research::IntVar* const time_var =
|
|
time_dimension.CumulVar(order);
|
|
operations_research::IntVar* const slack_var =
|
|
routing.IsEnd(order) ? nullptr : time_dimension.SlackVar(order);
|
|
if (slack_var != nullptr && plan.Contains(slack_var)) {
|
|
StringAppendF(
|
|
&plan_output,
|
|
"%lld Load(%lld) Time(%lld, %lld) Slack(%lld, %lld)",
|
|
routing.IndexToNode(order).value(),
|
|
plan.Value(load_var), plan.Min(time_var), plan.Max(time_var),
|
|
plan.Min(slack_var), plan.Max(slack_var));
|
|
} else {
|
|
StringAppendF(&plan_output, "%lld Load(%lld) Time(%lld, %lld)",
|
|
routing.IndexToNode(order).value(),
|
|
plan.Value(load_var), plan.Min(time_var),
|
|
plan.Max(time_var));
|
|
}
|
|
if (routing.IsEnd(order)) break;
|
|
plan_output += " -> ";
|
|
order = plan.Value(routing.NextVar(order));
|
|
}
|
|
plan_output += "\n";
|
|
}
|
|
}
|
|
LOG(INFO) << plan_output;
|
|
}
|
|
} // namespace operations_research
|