routing_decision_builders.h

Go to the documentation of this file.

// Copyright 2010-2024 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.
 
#ifndef OR_TOOLS_CONSTRAINT_SOLVER_ROUTING_DECISION_BUILDERS_H_
#define OR_TOOLS_CONSTRAINT_SOLVER_ROUTING_DECISION_BUILDERS_H_
 
#include <cstdint>
#include <utility>
#include <vector>
 
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "ortools/constraint_solver/constraint_solver.h"
#include "ortools/constraint_solver/routing.h"
#include "ortools/constraint_solver/routing_lp_scheduling.h"
 
namespace operations_research {
 
DecisionBuilder* MakeSetValuesFromTargets(Solver* solver,
                                          std::vector<IntVar*> variables,
                                          std::vector<int64_t> targets);
 
 
DecisionBuilder* MakeSetCumulsFromLocalDimensionCosts(
    Solver* solver, LocalDimensionCumulOptimizer* lp_optimizer,
    LocalDimensionCumulOptimizer* mp_optimizer, bool optimize_and_pack = false,
    std::vector<RoutingModel::RouteDimensionTravelInfo>
        dimension_travel_info_per_route = {});
 
DecisionBuilder* MakeSetCumulsFromGlobalDimensionCosts(
    Solver* solver, GlobalDimensionCumulOptimizer* global_optimizer,
    GlobalDimensionCumulOptimizer* global_mp_optimizer, SearchMonitor* monitor,
    bool optimize_and_pack = false,
    std::vector<RoutingModel::RouteDimensionTravelInfo>
        dimension_travel_info_per_route = {});
 
DecisionBuilder* MakeRestoreDimensionValuesForUnchangedRoutes(
    RoutingModel* model);
 
class FinalizerVariables {
 public:
  explicit FinalizerVariables(Solver* solver) : solver_(solver) {}
  void AddVariableToMinimize(IntVar* var);
  void AddVariableToMaximize(IntVar* var);
  void AddWeightedVariableToMinimize(IntVar* var, int64_t cost);
  void AddWeightedVariableToMaximize(IntVar* var, int64_t cost);
  void AddVariableTarget(IntVar* var, int64_t target);
  void AddWeightedVariableTarget(IntVar* var, int64_t target, int64_t cost);
  DecisionBuilder* CreateFinalizer();
 
 private:
  Solver* const solver_;
#ifndef SWIG
  struct VarTarget {
    IntVar* var;
    int64_t target;
  };
  std::vector<std::pair<VarTarget, int64_t>>
      weighted_finalizer_variable_targets_;
  std::vector<VarTarget> finalizer_variable_targets_;
  absl::flat_hash_map<IntVar*, int> weighted_finalizer_variable_index_;
  absl::flat_hash_set<IntVar*> finalizer_variable_target_set_;
#endif
};
 
}  // namespace operations_research
#endif  // OR_TOOLS_CONSTRAINT_SOLVER_ROUTING_DECISION_BUILDERS_H_