From 84e20b6ddd9066d541765b814f1a9d15edf27e56 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Fri, 30 Oct 2026 09:57:28 +0100
Subject: [PATCH] Use a table for TSPTW travel times

The matrix element posted one index over all n*n customer pairs per
position, and its propagator rebuilds its support lists in every clone.
A* and CABS clone and propagate every child near the root, so this
dominated their runtime. Use one shared TupleSet over (x[i-1], x[i],
c[i]) instead, and note the per-node cost and unkeyed dominance in the
heuristic guidance documentation.
---
 examples/tsptw.cpp | 9 ++++++++-
 gecode/search.hh   | 8 +++++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/examples/tsptw.cpp b/examples/tsptw.cpp
index 88391c3154..1692ab28ec 100644
--- a/examples/tsptw.cpp
+++ b/examples/tsptw.cpp
@@ -178,8 +178,15 @@ class TSPTW : public IntMinimizeScript {
           rel(*this, pos[j-1] < pos[k-1]);
     element(*this, from, x[0], c[0]);
     rel(*this, t[0] == max(element(ready,x[0]), c[0]));
+    // Travel time between consecutive customers
+    TupleSet legs(3);
+    for (int j=1; j<n; j++)
+      for (int k=1; k<n; k++)
+        if (j != k)
+          legs.add({j, k, d[j*n+k]});
+    legs.finalize();
     for (int i=1; i<n-1; i++) {
-      element(*this, d, x[i], n, x[i-1], n, c[i]);
+      extensional(*this, IntVarArgs({x[i-1], x[i], c[i]}), legs);
       rel(*this, t[i] == max(element(ready,x[i]), t[i-1]+c[i]));
     }
     for (int i=0; i<n-1; i++)
diff --git a/gecode/search.hh b/gecode/search.hh
index 05b2b9ccec..d4455e9f09 100755
--- a/gecode/search.hh
+++ b/gecode/search.hh
@@ -1187,7 +1187,13 @@ namespace Gecode { namespace Search {
    * the second space is matched by a completion of the first that is not
    * worse. It must be transitive. CABS uses it to prune nodes in the same
    * layer. If a dominance key is given, only nodes with equal keys are
-   * compared.
+   * compared. Without a key, every node offered to the beam is compared
+   * with every node already in it.
+   *
+   * A* and CABS clone and propagate every child of every node they
+   * expand, also close to the root where domains are large. The cost of a
+   * node is thus a clone plus propagation at shallow depth, so models
+   * should use propagators that stay cheap there.
    *
    * Callbacks must only read the space passed to them. With several threads
    * they can run concurrently.