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

Abstract: 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ía (2009), finds no violated inequality on any instance. The solver and all experiments are released as open, reproducible software (Spoorendonk, 2026).

• The paper demonstrates that capacity-class cuts drastically reduce runtime and search tree size in solving CPTP instances.
• The study showcases a reproducible open-source C++23/HiGHS implementation with extensive ablation on 76 benchmark instances.
• The research highlights negative results for several cut strategies, guiding future algorithm enhancements in resource-constrained tour problems.

Open, Reproducible Branch-and-Cut for the Capacitated Profitable Tour Problem: A Component Study

Introduction and Problem Setting

The paper "An open, reproducible branch-and-cut for the capacitated profitable tour problem: a component study" (2607.04497) presents a detailed empirical investigation of branch-and-cut approaches for the capacitated profitable tour problem (CPTP) and its open $s$--$t$ path variant. The CPTP involves determining a minimum-cost simple cycle through a depot and a subset of customer nodes, maximizing collected node profits while adhering to overall capacity constraints. This model naturally arises as the pricing subproblem in vehicle routing column generation, particularly when negative reduced costs induce partial customer selection.

The research advances reproducibility and openness by re-implementing the core formulation and cut families of Jepsen et al. (2014) on a fully open-source mixed-integer programming (MIP) stack (HiGHS). The methodology incorporates previously established cut classes alongside bound-based preprocessing, domain propagation, and reduced-cost variable fixing; the novelty lies not in new algorithmic techniques but in comprehensive openness, a modular implementation, and an in-depth component-wise ablation.

Methodological Contributions

The principal technical achievements of this work center on:

• Reproducibility: All code, benchmarks, and scripts are made fully open, enabling straightforward reproduction and extension. This includes a C++23 implementation atop HiGHS, with Python bindings and all experimental data archived.
• Systematic Component Study: Each constituent of the branch-and-cut pipeline (types of cuts, propagation, reduced-cost fixing, etc.) is isolated and evaluated via an extensive ablation ladder over 76 benchmark CPTP instances. The performance is compared against state-of-the-art dynamic programming (labeling) methods.
• Negative Results: The empirical investigation includes rigorous reporting of cut families or propagation strategies that provide negligible or null improvement, including a failed shortest-path-incompatibility (SPI) separator, which is a significant finding for researchers considering extensions in this space.

Branch-and-Cut Algorithm Structure

The integer programming model is conventional for CPTP: customer selection is encoded via $y_i$ variables; edge use via $x_e$; and the formulation is constrained with degree equations, subtour elimination, and a knapsack constraint. The algorithm proceeds as follows:

• Cut Separation: GSEC (connectivity), various capacity-driven classes (RCI, multistar, GLM, RGLM), comb inequalities, and SPI cuts are dynamically separated using advanced techniques (e.g., min-cut trees, residual-demand strengthening, heuristically grown comb handles).
• Variable Reduction/Preprocessing: Preprocessing applies shortest-path resource-bounded labeling for quick bound propagation and root node reductions, fixing variables upfront wherever possible.
• Domain Propagation and Reduced-Cost Fixing: These techniques exploit incumbents and LP/dual information to incrementally restrict variable domains during branch-and-bound.
• Heuristics and Branching: Primal heuristics warm-start the search, and branching is by default standard pseudocost-based but can employ specialized hyperplane branching as needed.

Empirical Findings

Comparative Evaluation with Dynamic Programming

On a set of 76 instances culled from SPPRCLIB and Roberti Set 3, the open-source branch-and-cut solver is pitted against PathWyse, a labeling/dynamic programming reference method. The main findings are:

• Runtime Superiority of Labeling on Easy Instances: DP labeling is consistently faster in instances with weaker elementarity or less tight resource binding.
• Branch-and-Cut Solves Hard DP Instances: Several instances not solvable within a 1-hour limit by DP are solved rapidly by branch-and-cut, and vice versa, with neither dominating across all instances.

This complementarity substantiates prior observations that cutting-plane and label-setting algorithms target distinct bottlenecks in the combinatorial landscape.

Figure 2: Performance profile (Dolan--Moré) of runtime; the $\rho(\tau)$ curve shows branch-and-cut and DP each closing hard instances unsolved by the other.

Figure 1: Cactus plot showing the number of instances solved as a function of time budget (log scale), further indicating the complementary nature of both approaches.

Component Study and Ablation

A detailed gating ablation investigates the marginal contribution of every solver component:

• Capacity-Class Cuts Are Decisive: Adding RCI and multistar cuts to a GSEC-only baseline increases the solved count from 52/76 to 64/76 while reducing search tree size by >10x and runtime by >2x. These classes extract almost the entire performance gain.
• Other Families and Fixing Strategies Are Inert: Comb inequalities, rounded GLM, reduced-cost fixing, and bound-propagation confer no measurable improvement and, in the case of comb/RGLM, rarely even find violated cuts.
• Shortest-Path-Incompatibility (SPI) Cuts Are Ineffective: The SPI separator, even when supported by tight Held-Karp bounds, failed to trigger on any benchmark instance—a notable negative result.

Numerical Highlights

• Shifted Geometric Mean (SGM) Runtime: With only GSEC, SGM is 54.7s; with capacity-class cuts, it drops to 22.8s; with all other additions, SGM fluctuates negligibly.
• Mean Cuts Added: GSEC alone: ~25,700 per instance; with capacity-class cuts, GSEC drops to ~1,300, replaced one-to-one by capacity-class cuts.

Theoretical and Practical Implications

Practically, this work provides a reliable, reproducible baseline for CPTP studies, with clear guidance on which cuts and mechanisms are valuable on standard resource-constrained, profit-oriented tour instances. The open-source stack makes extension to directed/arc-resource models (which would cover broader RCSP benchmarks) feasible.

Theoretically, the results underscore that, at least in single-resource, node-capacitated settings, capacity-class cuts dominate cut-based relaxation strength for branch-and-cut. Negative results about other cut families will help steer future work away from unproductive directions—especially important as the field contemplates increasing model complexity (multi-resource, time window, arc-based).

It is plausible that as the instance size and/or tightness of the resource increases further, the strength of capacity-class cuts will remain primary, but further empirical work will be needed for strongly arc-resource or multi-resource generalizations.

Future Directions

The infrastructural contribution—code, algorithms, and benchmarks—is set up for rapid adaptation to:

• Arc-resource and directed graphs, extending the utility to canonical RCSP benchmarks (e.g., Beasley & Christofides).
• Larger and more complex instances (multi-resource, time-windowed, etc.).
• Serving as a baseline for new valid inequality classes, separation approaches, or hybrid label-setting/cut hybridizations.

Conclusion

This study establishes a reproducible, modular, and open-source branch-and-cut framework for the capacitated profitable tour problem. Empirical disaggregation identifies capacity-class cuts as the sole decisive relaxation strengthener among a broad inventory of inequalities and propagation techniques, while highlighting negative results for several widely considered separator classes. The artifact and findings will serve both as an extensible baseline and as a filter for future research into both CPTP-specific and broader resource-constrained tour problems.