- Rating
- 1
- Confidence
- 3
- Informativeness
- 1
- Presentation
- 1
- Soundness
- 1
Read review
Paper summary
This paper proposes a method for solving large-scale vehicle routing problems (VRPs). The proposed approach is to transform the problem into a compact space, optimize in that compact space, transform back, and then refine the result. This results in an orders of magnitude improvement in solve time in variety of VRPs.
Critical strengths
- The numerical benchmark results are amazing.
- The selection of baselines is solid, and the benchmark instances and metrics are standard.
Critical weaknesses
- There are almost no details about the proposed method, for example: how is the compact representation obtained? Is it learned? If so, there are no training details given in the main paper or appendix. If it isn't learned, then what is the relevance to ICLR?
- Same for the solving in the compact space, recovery from the compact space, and micro refinement.
Questions for authors
- Address the weaknesses
5 comments
Thank you for providing the pointers to the source code. If there is no training and no machine learning components, can the authors explain the suitability of the work to ICLR?
Official Comment by Authors
Thank you for raising this concern. We acknowledge that Just Initialize does not introduce a trainable model or a new learning procedure. However, we believe its relevance to ICLR lies in its contribution to scalable learning-based combinatorial optimization.
Existing neural combinatorial optimization (NCO) methods primarily focus on learning how to construct or improve solutions. Our work investigates a complementary but important question: how can we identify optimization-friendly initializations that enable downstream solvers, including learning-based ones, to achieve better solutions under a fixed computational budget?
To this end, we formulate initialization quality in terms of expected downstream optimization performance, rather than immediate solution quality, and develop a geometry-guided compression, search, and recovery framework to identify such initializations. Importantly, Just Initialize is training-free and solver-agnostic, making it complementary to existing learning-based and classical optimization methods rather than another competing solver.
We believe this perspective provides a useful algorithmic contribution to the broader study of scalable combinatorial optimization, particularly NCO, by shifting attention from learning increasingly sophisticated search policies to improving where optimization begins. We will further clarify this connection and the intended positioning of our work in the revised manuscript.
Official Comment by Authors
Thank you for pointing out these limitations. We have further clarified the implementation details of each stage in the revised manuscript, with all modifications highlighted in blue. We provide the corresponding explanations and implementation references below.
Q1. How is the compact representation obtained? Is it learned?
JI is entirely training-free. The compact representation is constructed directly from the input instance using geometry-guided compression. For TSP, we construct candidate neighborhoods for each node, grow path fragments with a target size of 32 by examining eight candidate neighbors at each extension, and retain 16 portal neighbors for each fragment. For other routing problems, we use problem-specific compression procedures that preserve the corresponding constraints, such as aggregated demand for CVRP and prize and penalty information for PCTSP.
These procedures are described in Section 4.2, Algorithm 1, Appendix B.1, Appendix B.3, and Appendix D. Their concrete implementations are provided in
src/JI_solver.py:tsp_c_compress(Lines 78–249),cvrp_compress(Lines 901–1120),pctsp_compress(Lines 1268–1354), andvrptw_compress(Lines 2251–2606), respectively.Q2. How is optimization performed in the compact space?
The compact solution is first constructed by selecting feasible compact units and their orientations according to their connection costs. We then improve the resulting plan through compact-level local search, including exchange, relocation, and reversal operations. The feasibility checks and objective evaluation account for the constraints of each routing problem. For CVRP, an additional route-merging procedure is used to improve the compact plan.
The overall optimization procedure is described in Section 4.3, Algorithm 2, and Appendix B.1. In the source code, the corresponding implementations are
Oracle(Lines 3128–3320),_construct_plan(Lines 3335–3388),_merge_plan(Lines 3390–3438), and_improve_plan(Lines 3440–3498), withsolvecoordinating these procedures (Lines 3320–3333).Q3. How is the solution recovered from the compact space?
Recovery uses the original node sequences retained during compression. Given the optimized compact ordering, each fragment is expanded according to its selected orientation, and the resulting sequences are concatenated to construct the original-space solution. The paper further defines a structural consistency criterion based on geometric and intra-fragment sequence consistency to describe the compatibility between the recovered solution and the compact structure.
The recovery formulation is described in Section 4.4 and Appendix B.2, particularly Eqs. (43)–(48). The actual sequence reconstruction in the released source code is implemented by
restoreinsrc/JI_solver.py(Lines 3500–3505).Q4. How is micro-refinement performed?
After recovery, the solution is further optimized in the original solution space. We apply problem-specific local-search operators and accept improving solutions according to the original objective and feasibility constraints. For TSP, this includes 2-opt, 3-opt, Or-opt, and iterated local search with Lin–Kernighan improvement.
This stage is described in Section 4.5 and Appendix D. Its implementation is dispatched through
optimizeinsrc/JI_solver.py(Lines 3536–3590), with the TSP implementation intsp_ils_ils_optimize(Lines 812–845), CVRP implementation incvrp_optimize_exchange(Lines 1179–1205), PCTSP implementation inpctsp_optimize(Lines 1578–1623), and VRPTW implementation invrptw_optimize(Lines 2860–3000).Verification and reproducibility.
We also provide the complete source code, instance-generation scripts, experimental configurations, and evaluation procedures. In particular,
test/evaluate.pyindependently checks solution feasibility and recomputes objective values from the original instances (Lines 221–380). The evaluation protocol and commands for reproducing the experiments are documented inREADME.md(Lines 31–82). These resources allow the implementation and reported experimental results to be independently examined and reproduced.We hope these additional references clarify where the methodological details are presented in the paper and how the corresponding procedures can be located and verified in the released implementation.