[CP-SAT] more spans; one more case of preserving hints during presolve; new packing LNS; propagate objective in LNS

Author: lperron

ortools/sat/2d_rectangle_presolve_test.cc

@@ -702,7 +702,7 @@ ShapePath TraceBoundary(
 
 std::string RenderShapes(std::optional<Rectangle> bb,
                          absl::Span<const Rectangle> rectangles,
-                         const std::vector<SingleShape>& shapes) {
+                         absl::Span<const SingleShape> shapes) {
   const std::vector<std::string> colors = {"black", "white",  "orange",
                                            "cyan",  "yellow", "purple"};
   std::stringstream ss;

ortools/sat/BUILD.bazel

@@ -949,6 +949,7 @@ cc_library(
         "//ortools/util:logging",
         "//ortools/util:sorted_interval_list",
         "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/types:span",
     ],
 )
 
@@ -1442,6 +1443,7 @@ cc_library(
         ":cp_model_cc_proto",
         ":cp_model_utils",
         ":integer",
+        ":integer_base",
         ":presolve_context",
         ":presolve_util",
         ":util",
@@ -1469,7 +1471,7 @@ cc_test(
     srcs = ["var_domination_test.cc"],
     deps = [
         ":cp_model_cc_proto",
-        ":integer",
+        ":integer_base",
         ":model",
         ":presolve_context",
         ":var_domination",
@@ -3207,6 +3209,7 @@ cc_library(
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/meta:type_traits",
+        "@com_google_absl//absl/types:span",
     ],
 )
 

ortools/sat/all_different.cc

@@ -36,8 +36,9 @@ namespace operations_research {
 namespace sat {
 
 std::function<void(Model*)> AllDifferentBinary(
-    const std::vector<IntegerVariable>& vars) {
-  return [=](Model* model) {
+    absl::Span<const IntegerVariable> vars) {
+  return [=, vars = std::vector<IntegerVariable>(vars.begin(), vars.end())](
+             Model* model) {
     // Fully encode all the given variables and construct a mapping value ->
     // List of literal each indicating that a given variable takes this value.
     //
@@ -97,8 +98,9 @@ std::function<void(Model*)> AllDifferentOnBounds(
 }
 
 std::function<void(Model*)> AllDifferentAC(
-    const std::vector<IntegerVariable>& variables) {
-  return [=](Model* model) {
+    absl::Span<const IntegerVariable> variables) {
+  return [=, variables = std::vector<IntegerVariable>(
+                 variables.begin(), variables.end())](Model* model) {
     if (variables.size() < 3) return;
 
     AllDifferentConstraint* constraint = new AllDifferentConstraint(

ortools/sat/all_different.h

@@ -36,7 +36,7 @@ namespace sat {
 // encodes all the variables and simply enforces a <= 1 constraint on each
 // possible values.
 std::function<void(Model*)> AllDifferentBinary(
-    const std::vector<IntegerVariable>& vars);
+    absl::Span<const IntegerVariable> vars);
 
 // Enforces that the given tuple of variables takes different values.
 // Same as AllDifferentBinary() but use a different propagator that only enforce
@@ -62,7 +62,7 @@ std::function<void(Model*)> AllDifferentOnBounds(
 //
 // This will fully encode variables.
 std::function<void(Model*)> AllDifferentAC(
-    const std::vector<IntegerVariable>& variables);
+    absl::Span<const IntegerVariable> variables);
 
 // Implementation of AllDifferentAC().
 class AllDifferentConstraint : PropagatorInterface {

ortools/sat/circuit.cc

@@ -21,6 +21,7 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
+#include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/graph/strongly_connected_components.h"
 #include "ortools/sat/integer.h"
@@ -33,9 +34,9 @@ namespace operations_research {
 namespace sat {
 
 CircuitPropagator::CircuitPropagator(const int num_nodes,
-                                     const std::vector<int>& tails,
-                                     const std::vector<int>& heads,
-                                     const std::vector<Literal>& literals,
+                                     absl::Span<const int> tails,
+                                     absl::Span<const int> heads,
+                                     absl::Span<const Literal> literals,
                                      Options options, Model* model)
     : num_nodes_(num_nodes),
       options_(options),
@@ -483,7 +484,7 @@ bool NoCyclePropagator::Propagate() {
 
 CircuitCoveringPropagator::CircuitCoveringPropagator(
     std::vector<std::vector<Literal>> graph,
-    const std::vector<int>& distinguished_nodes, Model* model)
+    absl::Span<const int> distinguished_nodes, Model* model)
     : graph_(std::move(graph)),
       num_nodes_(graph_.size()),
       trail_(model->GetOrCreate<Trail>()) {
@@ -626,8 +627,9 @@ bool CircuitCoveringPropagator::Propagate() {
 }
 
 std::function<void(Model*)> ExactlyOnePerRowAndPerColumn(
-    const std::vector<std::vector<Literal>>& graph) {
-  return [=](Model* model) {
+    absl::Span<const std::vector<Literal>> graph) {
+  return [=, graph = std::vector<std::vector<Literal>>(
+                 graph.begin(), graph.end())](Model* model) {
     const int n = graph.size();
     std::vector<Literal> exactly_one_constraint;
     exactly_one_constraint.reserve(n);
@@ -695,9 +697,10 @@ void LoadSubcircuitConstraint(int num_nodes, const std::vector<int>& tails,
 }
 
 std::function<void(Model*)> CircuitCovering(
-    const std::vector<std::vector<Literal>>& graph,
+    absl::Span<const std::vector<Literal>> graph,
     const std::vector<int>& distinguished_nodes) {
-  return [=](Model* model) {
+  return [=, graph = std::vector<std::vector<Literal>>(
+                 graph.begin(), graph.end())](Model* model) {
     CircuitCoveringPropagator* constraint =
         new CircuitCoveringPropagator(graph, distinguished_nodes, model);
     constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());

ortools/sat/circuit.h

@@ -21,6 +21,7 @@
 
 #include "absl/container/btree_set.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/base/types.h"
 #include "ortools/graph/strongly_connected_components.h"
@@ -53,9 +54,9 @@ class CircuitPropagator : PropagatorInterface, ReversibleInterface {
 
   // The constraints take a sparse representation of a graph on [0, n). Each arc
   // being present when the given literal is true.
-  CircuitPropagator(int num_nodes, const std::vector<int>& tails,
-                    const std::vector<int>& heads,
-                    const std::vector<Literal>& literals, Options options,
+  CircuitPropagator(int num_nodes, absl::Span<const int> tails,
+                    absl::Span<const int> heads,
+                    absl::Span<const Literal> literals, Options options,
                     Model* model);
 
   // This type is neither copyable nor movable.
@@ -173,7 +174,7 @@ class NoCyclePropagator : PropagatorInterface, ReversibleInterface {
 class CircuitCoveringPropagator : PropagatorInterface, ReversibleInterface {
  public:
   CircuitCoveringPropagator(std::vector<std::vector<Literal>> graph,
-                            const std::vector<int>& distinguished_nodes,
+                            absl::Span<const int> distinguished_nodes,
                             Model* model);
 
   void SetLevel(int level) final;
@@ -254,9 +255,9 @@ void LoadSubcircuitConstraint(int num_nodes, const std::vector<int>& tails,
 
 // TODO(user): Change to a sparse API like for the function above.
 std::function<void(Model*)> ExactlyOnePerRowAndPerColumn(
-    const std::vector<std::vector<Literal>>& graph);
+    absl::Span<const std::vector<Literal>> graph);
 std::function<void(Model*)> CircuitCovering(
-    const std::vector<std::vector<Literal>>& graph,
+    absl::Span<const std::vector<Literal>> graph,
     const std::vector<int>& distinguished_nodes);
 
 }  // namespace sat

ortools/sat/cp_constraints.h

@@ -161,10 +161,13 @@ inline std::function<void(Model*)> GreaterThanAtLeastOneOf(
 // Note(user): If there is just one or two candidates, this doesn't add
 // anything.
 inline std::function<void(Model*)> PartialIsOneOfVar(
-    IntegerVariable target_var, const std::vector<IntegerVariable>& vars,
-    const std::vector<Literal>& selectors) {
+    IntegerVariable target_var, absl::Span<const IntegerVariable> vars,
+    absl::Span<const Literal> selectors) {
   CHECK_EQ(vars.size(), selectors.size());
-  return [=](Model* model) {
+  return [=,
+          selectors = std::vector<Literal>(selectors.begin(), selectors.end()),
+          vars = std::vector<IntegerVariable>(vars.begin(), vars.end())](
+             Model* model) {
     const std::vector<IntegerValue> offsets(vars.size(), IntegerValue(0));
     if (vars.size() > 2) {
       // Propagate the min.

ortools/sat/cp_model_expand.cc

@@ -1351,8 +1351,8 @@ void ExpandNegativeTable(ConstraintProto* ct, PresolveContext* context) {
 // We list for each tuple the possible values the variable can take.
 // If the list is empty, then this encode "any value".
 void ProcessOneCompressedColumn(
-    int variable, const std::vector<int>& tuple_literals,
-    const std::vector<absl::InlinedVector<int64_t, 2>>& values,
+    int variable, absl::Span<const int> tuple_literals,
+    absl::Span<const absl::InlinedVector<int64_t, 2>> values,
     std::optional<int> table_is_active_literal, PresolveContext* context) {
   DCHECK_EQ(tuple_literals.size(), values.size());
 
@@ -1656,7 +1656,7 @@ bool ReduceTableInPresenceOfUniqueVariableWithCosts(
 // is called. Some checks will fail otherwise.
 void CompressAndExpandPositiveTable(ConstraintProto* ct,
                                     bool last_column_is_cost,
-                                    const std::vector<int>& vars,
+                                    absl::Span<const int> vars,
                                     std::vector<std::vector<int64_t>>* tuples,
                                     PresolveContext* context) {
   const int num_tuples_before_compression = tuples->size();

ortools/sat/cp_model_lns.cc

@@ -825,7 +825,7 @@ struct IndexedRectangle {
 };
 
 void InsertRectanglePredecences(
-    const std::vector<IndexedRectangle>& rectangles,
+    absl::Span<const IndexedRectangle> rectangles,
     absl::flat_hash_set<std::pair<int, int>>* precedences) {
   // TODO(user): Refine set of interesting points.
   std::vector<IntegerValue> interesting_points;
@@ -1148,7 +1148,7 @@ void NeighborhoodGeneratorHelper::AddSolutionHinting(
 
 Neighborhood NeighborhoodGeneratorHelper::RelaxGivenVariables(
     const CpSolverResponse& initial_solution,
-    const std::vector<int>& relaxed_variables) const {
+    absl::Span<const int> relaxed_variables) const {
   std::vector<bool> relaxed_variables_set(model_proto_.variables_size(), false);
   for (const int var : relaxed_variables) relaxed_variables_set[var] = true;
   absl::flat_hash_set<int> fixed_variables;
@@ -1737,8 +1737,8 @@ namespace {
 
 // Create a constraint sum (X - LB) + sum (UB - X) <= rhs.
 ConstraintProto DistanceToBoundsSmallerThanConstraint(
-    const std::vector<std::pair<int, int64_t>>& dist_to_lower_bound,
-    const std::vector<std::pair<int, int64_t>>& dist_to_upper_bound,
+    absl::Span<const std::pair<int, int64_t>> dist_to_lower_bound,
+    absl::Span<const std::pair<int, int64_t>> dist_to_upper_bound,
     const int64_t rhs) {
   DCHECK_GE(rhs, 0);
   ConstraintProto new_constraint;
@@ -2290,6 +2290,84 @@ Neighborhood RandomRectanglesPackingNeighborhoodGenerator::Generate(
   return helper_.FixGivenVariables(initial_solution, variables_to_freeze);
 }
 
+Neighborhood RectanglesPackingRelaxOneNeighborhoodGenerator::Generate(
+    const CpSolverResponse& initial_solution, SolveData& data,
+    absl::BitGenRef random) {
+  // First pick one rectangle.
+  const std::vector<ActiveRectangle> all_active_rectangles =
+      helper_.GetActiveRectangles(initial_solution);
+  if (all_active_rectangles.size() <= 1) return helper_.FullNeighborhood();
+
+  const ActiveRectangle& base_rectangle =
+      all_active_rectangles[absl::Uniform<int>(random, 0,
+                                               all_active_rectangles.size())];
+
+  const auto get_rectangle = [&initial_solution, helper = &helper_](
+                                 const ActiveRectangle& rectangle) {
+    const int x_interval_idx = rectangle.x_interval;
+    const int y_interval_idx = rectangle.y_interval;
+    const ConstraintProto& x_interval_ct =
+        helper->ModelProto().constraints(x_interval_idx);
+    const ConstraintProto& y_interval_ct =
+        helper->ModelProto().constraints(y_interval_idx);
+    return Rectangle{.x_min = GetLinearExpressionValue(
+                         x_interval_ct.interval().start(), initial_solution),
+                     .x_max = GetLinearExpressionValue(
+                         x_interval_ct.interval().end(), initial_solution),
+                     .y_min = GetLinearExpressionValue(
+                         y_interval_ct.interval().start(), initial_solution),
+                     .y_max = GetLinearExpressionValue(
+                         y_interval_ct.interval().end(), initial_solution)};
+  };
+
+  const Rectangle center_rect = get_rectangle(base_rectangle);
+
+  // Now compute a neighborhood around that rectangle. In this neighborhood
+  // we prefer a "Square" region around the initial rectangle center rather than
+  // a circle.
+  //
+  // Note that we only consider two rectangles as potential neighbors if they
+  // are part of the same no_overlap_2d constraint.
+  absl::flat_hash_set<int> variables_to_freeze;
+  std::vector<std::pair<int, double>> distances;
+  distances.reserve(all_active_rectangles.size());
+  for (int i = 0; i < all_active_rectangles.size(); ++i) {
+    const ActiveRectangle& rectangle = all_active_rectangles[i];
+    InsertVariablesFromConstraint(helper_.ModelProto(), rectangle.x_interval,
+                                  variables_to_freeze);
+    InsertVariablesFromConstraint(helper_.ModelProto(), rectangle.y_interval,
+                                  variables_to_freeze);
+
+    const Rectangle rect = get_rectangle(rectangle);
+    const bool same_no_overlap_as_center_rect = absl::c_any_of(
+        base_rectangle.no_overlap_2d_constraints, [&rectangle](const int c) {
+          return rectangle.no_overlap_2d_constraints.contains(c);
+        });
+    if (same_no_overlap_as_center_rect) {
+      distances.push_back(
+          {i, CenterToCenterLInfinityDistance(center_rect, rect)});
+    }
+  }
+  std::sort(distances.begin(), distances.end(),
+            [](const auto& a, const auto& b) { return a.second < b.second; });
+
+  const int num_to_sample = data.difficulty * all_active_rectangles.size();
+  absl::flat_hash_set<int> variables_to_relax;
+  const int num_to_relax = std::min<int>(distances.size(), num_to_sample);
+  for (int i = 0; i < num_to_relax; ++i) {
+    const int rectangle_idx = distances[i].first;
+    const ActiveRectangle& rectangle = all_active_rectangles[rectangle_idx];
+    InsertVariablesFromConstraint(helper_.ModelProto(), rectangle.x_interval,
+                                  variables_to_relax);
+    InsertVariablesFromConstraint(helper_.ModelProto(), rectangle.y_interval,
+                                  variables_to_relax);
+  }
+  for (const int v : variables_to_relax) {
+    variables_to_freeze.erase(v);
+  }
+  return helper_.FixGivenVariables(initial_solution, variables_to_freeze);
+}
+
 Neighborhood RectanglesPackingRelaxTwoNeighborhoodsGenerator::Generate(
     const CpSolverResponse& initial_solution, SolveData& data,
     absl::BitGenRef random) {
@@ -2327,22 +2405,16 @@ Neighborhood RectanglesPackingRelaxTwoNeighborhoodsGenerator::Generate(
                          y_interval_ct.interval().end(), initial_solution)};
   };
 
-  // TODO(user): This computes the distance between the center of the
-  // rectangles. We could use the real distance between the closest points, but
-  // not sure it is worth the extra complexity.
-  const auto compute_rectangle_distance = [](const Rectangle& rect1,
-                                             const Rectangle& rect2) {
-    return (static_cast<double>(rect1.x_min.value()) + rect1.x_max.value() -
-            rect2.x_min.value() - rect2.x_max.value()) *
-           (static_cast<double>(rect1.y_min.value()) + rect1.y_max.value() -
-            rect2.y_min.value() - rect2.y_max.value());
-  };
   const Rectangle rect1 = get_rectangle(chosen_rectangle_1);
   const Rectangle rect2 = get_rectangle(chosen_rectangle_2);
 
   // Now compute a neighborhood around each rectangle. Note that we only
   // consider two rectangles as potential neighbors if they are part of the same
   // no_overlap_2d constraint.
+  //
+  // TODO(user): This computes the distance between the center of the
+  // rectangles. We could use the real distance between the closest points, but
+  // not sure it is worth the extra complexity.
   absl::flat_hash_set<int> variables_to_freeze;
   std::vector<std::pair<int, double>> distances1;
   std::vector<std::pair<int, double>> distances2;
@@ -2367,10 +2439,10 @@ Neighborhood RectanglesPackingRelaxTwoNeighborhoodsGenerator::Generate(
                          return rectangle.no_overlap_2d_constraints.contains(c);
                        });
     if (same_no_overlap_as_rect1) {
-      distances1.push_back({i, compute_rectangle_distance(rect1, rect)});
+      distances1.push_back({i, CenterToCenterL2Distance(rect1, rect)});
     }
     if (same_no_overlap_as_rect2) {
-      distances2.push_back({i, compute_rectangle_distance(rect2, rect)});
+      distances2.push_back({i, CenterToCenterL2Distance(rect2, rect)});
     }
   }
   const int num_to_sample_each =