arXiv subjects

Simon Spoorendonk

Publications and source records attributed to Simon Spoorendonk.

4 recordsLinked to original sources

arXiv2026

An open, reproducible branch-and-cut for the capacitated profitable tour problem: a component study

We present an open, reproducible branch-and-cut (B&C) algorithm for the capacitated profitable tour problem (CPTP) and its open s-t path variant, the capacity-constrained elementary shortest-path problem. The solver re-implements the formulation and cut families of Jepsen et al. (2014) on a fully open mixed-integer programming stack (HiGHS; Huangfu and Hall, 2018), and adds bound-based preprocessing, domain propagation, and reduced-cost variable fixing. We claim no new method; the contribution is twofold. First, an open, reproducible artifact: to our knowledge the first branch-and-cut for this problem class on a fully open stack, with the formulation, every separator, and all benchmark scripts released, so the results below can be rerun and the solver reused and extended as a baseline. Second, a component study on this common modern stack, benchmarked against a dynamic-programming/labelling reference, that decomposes which components pay off and where the running time goes. We find that the capacity-class cuts account for essentially the entire benefit (adding them to a connectivity-only baseline lifts the number of instances solved from 52 to 64 of 76 and shrinks the search tree more than tenfold), while comb and rounded generalized-large-multistar cuts, reduced-cost fixing, and bound-based propagation add nothing measurable. We also report a negative result: the shortest-path-incompatibility (SPI) cut, a variant of the node-precedence inequalities of Garc\'ia (2009), finds no violated inequality on any instance. The solver and all experiments are released as open, reproducible software (Spoorendonk, 2026).

math.OC↗

arXiv2026

$\texttt{bucket-graph-spprc}$: an extensible C++ library for the shortest path problem with resource constraints

We present $\texttt{bucket-graph-spprc}$ ($\texttt{bgspprc}$ for short), an open-source, header-only C++23 library for the shortest path problem with resource constraints (SPPRC), the pricing subproblem at the heart of branch-cut-and-price for vehicle routing and related problems. The library implements the bucket-graph labelling algorithm of Sadykov, Uchoa and Pessoa (2021), with bidirectional labelling, across-arc concatenation, bucket fixing and arc elimination, and a structure-of-arrays label store with SIMD-accelerated dominance. Its central design feature is a compile-time resource concept: a new SPPRC variant is added by implementing a fixed seven-function interface, and resources compose into a label state with no runtime dispatch, the state layout fixed at compile time. Five resources ship built in: time/capacity, ng-path elementarity relaxation, rank-1 cuts, cumulative cost, and pickup-and-delivery. In a reproducible, head-to-head comparison on shared public instances at an identical bound, $\texttt{bgspprc}$ outperforms PathWyse (Salani, Basso and Giuffrida, 2024), the main open-source comparator, by $1.3\times$--$2.35\times$ in shifted geometric mean (and by $1.3\times$--$2.3\times$ even when itself run single-threaded), and runs within $1.9\times$--$2.4\times$ of parallel pull labelling (Petersen and Spoorendonk, 2025), a different labelling technique for the same problem. The library, benchmark scripts, and pinned instances are publicly available.

math.OC↗

arXiv2025

A parallel pull labelling algorithm for the resource constrained shortest path problem

The Resource Constrained Shortest Path Problem (RCSPP) is a fundamental combinatorial optimisation problem in which the goal is to find a least-cost path in a directed graph subject to one or more resource constraints. Pull labelling, where a vertex gathers labels from its predecessors rather than pushing them to its successors, is a classical idea; we turn it into a parallel algorithm whose immutable, contention-free bucket storage is designed to scale on modern multi-core hardware. Its central component is an acyclic dependency bucket graph that orders the creation of labels so that buckets can be processed concurrently, without conflicting accesses, and stored as immutable objects. On top of this we introduce i) a highly parallelisable approach at the label-bucket level, ii) an extension to bi-directional search with a dynamic midpoint that emerges from the bucket processing order, and iii) a vectorised dominance criterion that uses vector instructions to speed-up the label comparison with another level of parallelisation. Compared to a baseline version of the algorithm the optimisations result in a speed-up of about 18 times on a set of hard instances and up to 274 times on the instance with the largest speed-up. Against an open implementation of the state-of-the-art bucket graph labelling algorithm, run on the same hardware and instances with each solver in its best parallel configuration, the pull algorithm is 1.9 to 2.4 times faster. The proposed algorithm demonstrates significant computational improvements that may enhance the efficiency of column generation frameworks incorporating resource constrained shortest path sub-problems, potentially enabling the efficient solution of larger-scale instances in routing, scheduling, supply chain and transportation network optimisation applications.

math.OC↗

arXiv2025

Tree-based formulation for the multi-commodity flow problem

We revisit the tree-based formulation of the minimum-cost multi-commodity flow problem, due to Jones et al. (1993), who found that path-based decomposition converges in fewer master iterations and reported lower CPU times for it. The formulation represents the flow out of each source as a convex combination of shortest-path trees, so the master problem has one demand constraint per source $|S|$ rather than per commodity $|K|$. We re-examine it on 44 instances with up to 3.3 million commodities, three orders of magnitude beyond the scale available to Jones et al. (1993), under five linear programming backends spanning four barrier codes, open source and commercial, CPU and GPU. Their convergence result is confirmed: the tree-based formulation still requires two to three times as many iterations. Their wall-clock conclusion, however, is reversed under every backend in the regime $|S| \ll |K|$: tree-based column generation is 1.4 to 1.9 times faster on the shifted geometric mean, reaches a factor of 99 on the instance with the most commodities, and solves 43 or 44 of the 44 instances under every backend, where the path-based formulation solves 38 to 42, its failures concentrated on the largest transportation instances. Both decompositions are 15 to 28 times faster than solving the compact model directly (5 to 25 on the instances that model solves). The measurements identify the mechanism: the master problem accounts for 87% to 99% of the runtime, and the tree-based master is up to 32 times smaller at termination. The advantage disappears when $|S|$ approaches $|V|$, where a tree column has non-zeros in a large fraction of the master's rows, as on the planar2500 instance. An open-source C++ implementation accompanies the paper.

math.OC↗