One problem, four traditions

Along a route, service starts satisfy $$t_j = \max\bigl(a_j,\; t_i + s_i + d_{ij}\bigr) \le b_j.$$ Waiting is free, so this start-time recurrence is the entire time-window model.

Solomon (1987) series	customers	windows
C1, C2	clustered	series 1: short horizon, tight windows, short routes series 2: long horizon, wide windows, long routes
R1, R2	uniform random
RC1, RC2	mixed

56 instances of 100 customers, and the literature's 25- and 50-customer versions: the first $n$ customers of each file. uv run co data downloads them from SINTEF's mirror.

The arc MIP: $x_{ij} \in \{0,1\}$ for arcs that some route could use, and start times $t_i \in [a_i, b_i]$:

$$\begin{aligned} \min\ & \textstyle\sum d_{ij} x_{ij} \\ & x(\delta^+(i)) = x(\delta^-(i)) = 1 \quad i \ne 0 \\ & t_j \ge t_i + s_i + d_{ij} - M_{ij}(1 - x_{ij}) \end{aligned}$$

with $M_{ij} = \max(0,\ b_i + s_i + d_{ij} - a_j)$, the smallest $M$ that's valid.

The time constraints already rule out subtours: around a cycle, each start would exceed the previous one by $s_i + d_{ij} > 0$. They don't limit load.

Separation by connected components of the support graph. On an integer point the components are the routes, so an overloaded route always yields a violated cut. That makes the handler exact as a lazy constraint. On a fractional point it's a heuristic: exact separation is NP-hard (CVRPSEP is the standard code).

colib.vrptw.lazy_cut_handler supplies SCIP's plumbing; you supply separate(values).

$$\min \sum_{r \in \Omega} c_r \lambda_r \quad \text{s.t.} \sum_{r \ni i} \lambda_r = 1\ \ \forall i,\quad \lambda \ge 0$$

Set partitioning over routes: $\Omega$ is every feasible route, too many to write down. Unit 10's loop: solve over a few, read duals $\pi$, and find a route with $c_r - \sum_{i \in r} \pi_i < 0$.

• Feillet et al. (2004): count customers you can't reach any more as visited. Dominance then fires between labels whose routes differ.
• Branch on arc flows $\sum_r [ij \in r] \lambda_r$. Forbidding an arc keeps pricing the same problem on a smaller graph; forcing $ij$ forbids its alternatives.
• Integral arc flows mean integral $\lambda$: each customer has one arc in and one out with flow 1, so every column in the support follows them.
• Bound $\lceil LP \rceil$ because distances are integers. A restricted master IP at the root gives the first incumbent.

m.add_multiple_circuit([(i, j, x[i, j]) for i, j in arcs])
for (i, j), b in x.items():
    if i and j:
        m.add(t[j] >= t[i] + s[i] + d[i][j]).only_enforce_if(b)
        m.add(u[j] >= u[i] + q[j]).only_enforce_if(b)
m.minimize(sum(d[i][j] * b for (i, j), b in x.items()))

The multiple-circuit constraint: vertex 0 may carry many circuits; every other vertex is on exactly one. That replaces the degree constraints and subtour elimination at once. No big-M: the enforced implication is propagated directly, and lazy clause generation (unit 21) learns from its failures.

The brief asks for a strategy chosen deliberately. Deliberate includes measuring whether it helps and dropping it if it doesn't.

Keep, per route, the forward starts $t_k$ and the latest starts $\ell_k$:

$$\begin{aligned} \ell_k &= \min\bigl(b_k,\; \ell_{k+1} - s_k - d_{k,k+1}\bigr), \\ \ell_{\text{depot}} &= b_0. \end{aligned}$$

Inserting $c$ between $p$ and $q$ is feasible iff $$\begin{aligned} t_c &= \max(a_c,\ t_p + s_p + d_{pc}) \le b_c, \\ &\max(a_q,\ t_c + s_c + d_{cq}) \le \ell_q, \end{aligned}$$ plus the load. Waiting absorbs any push up to $\ell_q$, so nothing after $q$ needs rechecking: a constant-time feasible insertion.

• Shaw removal: take out customers related in space, time and demand, so repair has room to rearrange them.
• Regret-k repair: insert first the customer with most to lose, $\sum_{h=2}^{k} (\text{cost}_h - \text{cost}_1)$, over its best position per route.
• A new route is always an option. Without it, repair can never increase the number of routes, and minimising distance sometimes needs more of them. The first prototype lacked it and got stuck 13 % above optimal on R201.25.
• Annealing acceptance, and three destroy × three repair operators with adaptive weights (unit 26).

Route $0 \to 1 \to 2 \to 3 \to 0$ from the four-customer example. Insert customer 4 (window $[0, 300]$).

held fixed	how
budget	60 s wall clock per run; the method gets the limit, the harness 5 s of grace
threads	one each: SCIP, HiGHS, CP-SAT with num_workers=1, Python
instances	all 56 Solomon instances at 25, 50 and 100 customers
trust	every solution re-checked, every cost recomputed
runaways	killed 30 s past the limit or beyond 2.5 GB, and recorded

The referee also runs a violation checker on every answer. Six runs side by side on eight cores, so absolute seconds include some contention. Every method pays it.

Paired over instances, Wilcoxon signed-rank, Holm over all pairs at once.

Proven optimal of 56 (mean primal gap at 60 s against the best found):

n	(a) B&C	(b) B&P	(c) CP-SAT	(d) ALNS	any
25	33 (1.6%)	49 (9.2%)	36 (0.08%)	– (0.43%)	51
50	16 (11.2%)	16 (53.9%)	14 (6.2%)	– (0.20%)	21
100	11 (28.9%)	0 (96.5%)	6 (18.9%)	– (0.15%)	11

Integrity: no invalid solution, no crash, no "optimal" refuted (no refuted claim), no two different proven optima.

• B&P is all or nothing. Its gaps are runs with no solution: 3, 26 and 49 of 56. Ten runs overran the limit inside one uninterruptible pricing call.
• ALNS's gaps flatter it, because the "best found" is often its own value. Against proven optima: 47 of 51 at n = 25, 20 of 21 at 50, 9 of 11 at 100. The worst miss is 7.7%, on C205.100.
• Proven at n = 100: C101 827.3, C201 589.1, R101 1637.7. As far as can be checked from memory, these match the exact literature.

limitation	why it matters	the extra experiment
one seed per run	SCIP and CP-SAT times move a lot with the seed (unit 27)	five seeds, averaged per instance
six jobs on eight cores	C104.25: B&P proved it in 39.5 s in a lighter prototype run, and found nothing in 60 s here	one job at a time
Python against C++	B&P's and ALNS's results are partly implementation findings	state it; or ng-routes and bidirectional labelling
one thread for CP-SAT	a portfolio solver, run against its design	8 workers, reported beside the 1-worker result
gap at one time limit	ignores when each method got there	log incumbents; primal integral

Reading

Solomon, Oper. Res. 35 (1987).
Kallehauge et al., in Column Generation (2005).
Feillet et al., Networks 44 (2004).
Baldacci, Mingozzi & Roberti, Oper. Res. 59 (2011).
Savelsbergh, ORSA J. Comput. 4 (1992).
Ropke & Pisinger, Transp. Sci. 40 (2006).
Berthold, Oper. Res. Lett. 41 (2013).

After the course

VRPSolver (Pessoa et al. 2020) for exact routing, HGS (Vidal 2022) for heuristics, and Gehring–Homberger's 200–1000 customers to see where each one stops.