constraint_solver: Make Relocate and Exchange aware of path constraints.

Author: Mizux

ortools/constraint_solver/java/constraint_solver.swig

@@ -147,7 +147,6 @@ PROTECT_FROM_FAILURE(Solver::Fail(), arg1);
 
 #include <vector>
 
-#include "ortools/base/types.h"
 #include "ortools/constraint_solver/constraint_solver.h"
 
 class RAIIExceptionChecker {

ortools/constraint_solver/local_search.cc

@@ -556,8 +556,14 @@ bool Relocate<ignore_path_vars>::MakeNeighbor() {
   const int64_t destination = this->BaseNode(1);
   std::optional<int64_t> chain_end =
       this->GetChainEnd(before_chain, destination, chain_length_);
-  return chain_end.has_value() &&
-         this->MoveChain(before_chain, *chain_end, destination);
+  if (!chain_end.has_value()) return false;
+  const auto [has_change, is_feasible] = this->MoveChainWithCheck(
+      before_chain, *chain_end, destination, /*check_path_compatibility=*/true);
+  if (!is_feasible) {
+    this->SetNextBaseToIncrement(0);
+    return false;
+  }
+  return has_change;
 }
 
 template <bool ignore_path_vars>
@@ -594,7 +600,10 @@ bool RelocateWithNeighbors<ignore_path_vars>::MakeNeighbor() {
     std::optional<int64_t> chain_end =
         this->GetChainEnd(before_chain, destination, this->chain_length_);
     if (!chain_end.has_value()) return false;
-    return this->MoveChain(before_chain, *chain_end, destination);
+    const auto [has_change, is_feasible] =
+        this->MoveChainWithCheck(before_chain, *chain_end, destination,
+                                 /*check_path_compatibility=*/true);
+    return has_change && is_feasible;
   };
   const int64_t node0 = this->BaseNode(0);
   const auto [neighbor, outgoing] = this->GetNeighborForBaseNode(0);
@@ -663,14 +672,23 @@ bool Exchange<ignore_path_vars>::MakeNeighbor() {
     if (neighbor < 0 || this->IsInactive(neighbor)) return false;
     if (outgoing) {
       // Exchange node0's next with 'neighbor'.
-      return this->SwapNodes(this->Next(node0), neighbor);
+      const auto [has_change, is_feasible] =
+          this->SwapNodesWithCheck(this->Next(node0), neighbor,
+                                   /*check_path_compatibility=*/true);
+      return has_change && is_feasible;
     }
     DCHECK(!this->IsPathStart(node0))
         << "Path starts have no incoming neighbors.";
     // Exchange node0's prev with 'neighbor'.
-    return this->SwapNodes(this->Prev(node0), neighbor);
+    const auto [has_change, is_feasible] =
+        this->SwapNodesWithCheck(this->Prev(node0), neighbor,
+                                 /*check_path_compatibility=*/true);
+    return has_change && is_feasible;
   }
-  return this->SwapNodes(this->Next(node0), this->Next(this->BaseNode(1)));
+  const auto [has_change, is_feasible] =
+      this->SwapNodesWithCheck(this->Next(node0), this->Next(this->BaseNode(1)),
+                               /*check_path_compatibility=*/true);
+  return has_change && is_feasible;
 }
 
 LocalSearchOperator* MakeExchange(
@@ -741,6 +759,7 @@ bool Cross<ignore_path_vars>::MakeNeighbor() {
   if (start1 == start0 || node1 == start1) return false;
 
   bool moved = false;
+  bool feasible = true;
   if (cross_path_starts) {
     // Cross path starts.
     // If two paths are equivalent don't exchange the full paths.
@@ -751,10 +770,18 @@ bool Cross<ignore_path_vars>::MakeNeighbor() {
       return false;
     }
     const int first1 = this->Next(start1);
-    if (!this->IsPathEnd(node0))
-      moved |= this->MoveChain(start0, node0, start1);
-    if (!this->IsPathEnd(node1))
-      moved |= this->MoveChain(this->Prev(first1), node1, start0);
+    if (!this->IsPathEnd(node0)) {
+      const auto [has_change, is_feasible] =
+          this->MoveChainWithCheck(start0, node0, start1, true);
+      moved |= has_change;
+      feasible &= is_feasible;
+    }
+    if (!this->IsPathEnd(node1)) {
+      const auto [has_change, is_feasible] =
+          this->MoveChainWithCheck(this->Prev(first1), node1, start0, true);
+      moved |= has_change;
+      feasible &= is_feasible;
+    }
   } else {
     // Cross path ends.
     // If paths are equivalent, every end crossing has a corresponding start
@@ -773,15 +800,21 @@ bool Cross<ignore_path_vars>::MakeNeighbor() {
 
     const int prev_end_node1 = this->Prev(this->CurrentNodePathEnd(node1));
     if (!this->IsPathEnd(node0)) {
-      moved |= this->MoveChain(this->Prev(node0), this->Prev(this->EndNode(0)),
-                               prev_end_node1);
+      const auto [has_change, is_feasible] = this->MoveChainWithCheck(
+          this->Prev(node0), this->Prev(this->EndNode(0)), prev_end_node1,
+          true);
+      moved |= has_change;
+      feasible &= is_feasible;
     }
     if (!this->IsPathEnd(node1)) {
-      moved |= this->MoveChain(this->Prev(node1), prev_end_node1,
-                               this->Prev(this->EndNode(0)));
+      const auto [has_change, is_feasible] =
+          this->MoveChainWithCheck(this->Prev(node1), prev_end_node1,
+                                   this->Prev(this->EndNode(0)), true);
+      moved |= has_change;
+      feasible &= is_feasible;
     }
   }
-  return moved;
+  return moved && feasible;
 }
 
 LocalSearchOperator* MakeCross(

ortools/constraint_solver/local_search.h

@@ -718,7 +718,7 @@ class PathOperator : public IntVarLocalSearchOperator {
   /// Only returns a valid value if path variables are taken into account.
   int64_t Path(int64_t node) const {
     if constexpr (ignore_path_vars) return 0LL;
-    return Value(node + number_of_nexts_);
+    return Value(PathIndex(node));
   }
 
   /// Number of next variables.
@@ -802,6 +802,20 @@ class PathOperator : public IntVarLocalSearchOperator {
   virtual void SetNextBaseToIncrement(int64_t base_index) {
     next_base_to_increment_ = base_index;
   }
+  /// Returns true if the node can be moved to the given path.
+  /// If paths are ignored, always returns true.
+  bool IsCompatibleWithPath(int64_t node, int64_t path) const {
+    if constexpr (ignore_path_vars) return true;
+    return this->Var(PathIndex(node))->Contains(path);
+  }
+  bool CheckPathCompatibility(absl::Span<const int64_t> path,
+                              int path_id) const {
+    for (int64_t node : path) {
+      if (!IsCompatibleWithPath(node, path_id)) return false;
+    }
+    return true;
+  }
+
   /// Indicates if alternatives should be considered when iterating over base
   /// nodes.
   virtual bool ConsiderAlternatives(int64_t) const { return false; }
@@ -823,7 +837,7 @@ class PathOperator : public IntVarLocalSearchOperator {
 
   int64_t OldPath(int64_t node) const {
     if constexpr (ignore_path_vars) return 0LL;
-    return OldValue(node + number_of_nexts_);
+    return OldValue(PathIndex(node));
   }
 
   int CurrentNodePathStart(int64_t node) const {
@@ -834,26 +848,47 @@ class PathOperator : public IntVarLocalSearchOperator {
 
   /// Moves the chain starting after the node before_chain and ending at the
   /// node chain_end after the node destination
-  bool MoveChain(int64_t before_chain, int64_t chain_end, int64_t destination) {
-    if (destination == before_chain || destination == chain_end) return false;
+  struct ChangeResult {
+    bool has_change;
+    bool is_feasible;
+  };
+  ChangeResult MoveChainWithCheck(int64_t before_chain, int64_t chain_end,
+                                  int64_t destination,
+                                  bool check_path_compatibility) {
+    if (destination == before_chain || destination == chain_end) {
+      return {.has_change = false, .is_feasible = true};
+    }
     DCHECK(CheckChainValidity(before_chain, chain_end, destination) &&
            !IsPathEnd(chain_end) && !IsPathEnd(destination));
     const int64_t destination_path = Path(destination);
     const int64_t after_chain = Next(chain_end);
     SetNext(chain_end, Next(destination), destination_path);
+    bool is_path_compatible =
+        !check_path_compatibility ||
+        this->IsCompatibleWithPath(chain_end, destination_path);
     if constexpr (!ignore_path_vars) {
       int current = destination;
       int next = Next(before_chain);
       while (current != chain_end) {
         SetNext(current, next, destination_path);
+        if (check_path_compatibility && is_path_compatible &&
+            !this->IsCompatibleWithPath(next, destination_path)) {
+          is_path_compatible = false;
+          // TODO(user): Investigate if we could break here (making sure the
+          // path inconsistencies don't break the operator).
+        }
         current = next;
         next = Next(next);
       }
     } else {
       SetNext(destination, Next(before_chain), destination_path);
     }
     SetNext(before_chain, after_chain, Path(before_chain));
-    return true;
+    return {.has_change = true, .is_feasible = is_path_compatible};
+  }
+  bool MoveChain(int64_t before_chain, int64_t chain_end, int64_t destination) {
+    return MoveChainWithCheck(before_chain, chain_end, destination, false)
+        .has_change;
   }
 
   /// Reverses the chain starting after before_chain and ending before
@@ -896,15 +931,28 @@ class PathOperator : public IntVarLocalSearchOperator {
   }
 
   /// Swaps the nodes node1 and node2.
-  bool SwapNodes(int64_t node1, int64_t node2) {
+  ChangeResult SwapNodesWithCheck(int64_t node1, int64_t node2,
+                                  bool check_path_compatibility) {
     if (IsPathEnd(node1) || IsPathEnd(node2) || IsPathStart(node1) ||
         IsPathStart(node2)) {
-      return false;
+      return {.has_change = false, .is_feasible = true};
     }
-    if (node1 == node2) return false;
+    if (node1 == node2) return {.has_change = false, .is_feasible = true};
     const int64_t prev_node1 = Prev(node1);
-    const bool ok = MoveChain(prev_node1, node1, Prev(node2));
-    return MoveChain(Prev(node2), node2, prev_node1) || ok;
+    if constexpr (!ignore_path_vars) {
+      const auto [has_change1, is_feasible1] = MoveChainWithCheck(
+          prev_node1, node1, Prev(node2), check_path_compatibility);
+      const auto [has_change2, is_feasible2] = MoveChainWithCheck(
+          Prev(node2), node2, prev_node1, check_path_compatibility);
+      return {.has_change = has_change1 || has_change2,
+              .is_feasible = is_feasible1 && is_feasible2};
+    }
+    bool ok = MoveChain(prev_node1, node1, Prev(node2));
+    ok = MoveChain(Prev(node2), node2, prev_node1) || ok;
+    return {.has_change = ok, .is_feasible = true};
+  }
+  bool SwapNodes(int64_t node1, int64_t node2) {
+    return SwapNodesWithCheck(node1, node2, false).has_change;
   }
 
   /// Insert the inactive node after destination.
@@ -1085,6 +1133,8 @@ class PathOperator : public IntVarLocalSearchOperator {
     return node >= 0 ? node : default_value;
   }
 
+  int64_t PathIndex(int64_t node) const { return node + number_of_nexts_; }
+
   void OnStart() override {
     optimal_paths_enabled_ = false;
     if (!iterators_initialized_) {