HRC: A Hybrid Reconstruction Framework for Neural Combinatorial Optimization Solvers

Abstract

Recent studies have proposed post-processing strategies that iteratively reconstruct a partial segment of current solutions using Neural Combinatorial Optimization (NCO) solvers, thereby improving their performance on large-scale Vehicle Routing Problem (VRP) instances. However, the reconstruction subproblem is essentially a Shortest Hamiltonian Path Problem (SHPP) instance, which differs fundamentally from the original VRP variant on which the solver is trained. Consequently, the NCO solver may suffer from performance degradation during reconstruction due to limited generalization across problem variants. Moreover, relying solely on the solver may be insufficient to effectively identify and correct complex intersections or suboptimal topological structures. To address these limitations, we propose a post-processing strategy termed Hybrid Reconstruction Framework (HRC). Specifically, HRC first fine-tunes the NCO solver on SHPP instances and then exploits the enhanced solver to perform large-neighborhood random reconstruction. Subsequently, HRC conducts small-neighborhood reconstruction using 2-opt and kNN-DGR. The experimental results on both synthetic and real-world Traveling Salesman Problem and Capacitated Vehicle Routing Problem instances demonstrate that HRC substantially improves the performance of two representative NCO solvers on large-scale instances and achieves better overall performance than the state-of-the-art reconstruction strategy. Finally, ablation studies further validate the effectiveness of all proposed designs.

1. Introduction

The Vehicle Routing Problem is a classic Combinatorial Optimization Problem (COP) that aims to determine cost-minimizing routes for serving customers under specific constraints. Its scientific importance and broad practical impact have been widely demonstrated across various domains [1,2,3,4], e.g., transportation and manufacturing.

Recently, a large number of Neural Combinatorial Optimization (NCO) solvers have been proposed to solve VRPs [5,6,7,8]. These solvers are built upon deep neural networks, enabling them to learn from extensive historical instances and efficiently search for (near-)optimal solutions. Compared with conventional heuristic algorithms, NCO solvers offer two key advantages: (1) they reduce reliance on manual design by learning directly from data rather than through trial-and-error tuning, and (2) they enable efficient GPU-accelerated computation for solving large-scale problems [9,10].

Despite the significant progress made, these NCO solvers are still insufficient when dealing with large-scale VRP instances [11,12,13]. To improve the performance of NCO solvers on large-scale instances, Luo et al. [14] proposed a post-processing strategy termed random reconstruction (RRC), which aims to iteratively reconstruct the initial solution generated by the solver. Specifically, RRC randomly samples a partial segment from the current solution, removes all connections within this segment, and reformulates it as a Shortest Hamiltonian Path Problem (SHPP) instance while keeping the endpoints fixed. Subsequently, RRC reconstructs a sub-solution for the selected segment using the NCO solver. If the reconstructed sub-solution yields a better objective value than the original one, it is used to replace the corresponding segment in the complete solution. However, RRC has two limitations that constrain its effectiveness. First, to obtain high-quality initial solutions, solvers are typically trained on instances of their corresponding variants, such as the Traveling Salesman Problem (TSP) or Capacitated Vehicle Routing Problem (CVRP), which are inherently inconsistent with SHPP (see Figure 1). As a result, the mismatch between the training problem and SHPP may result in suboptimal performance of the solver due to its limited generalization across problem variants [15,16]. Second, RRC employs the solver to perform reconstruction, which can be viewed as a form of large neighborhood reconstruction [10]. When the initial solution contains complex intersections or suboptimal topologies whose scale exceeds the range of the sampled segment, RRC may fail to effectively capture and correct these structures.

Figure 1. Illustration of TSP and SHPP instances.

To better address these limitations, we propose the Hybrid Reconstruction (HRC) method. First, we investigate the following research question: Can a solver trained on the original problem be adapted to SHPP through fine-tuning to achieve improved performance? To answer this question, HRC proposes a fine-tuning method that adapts the base solver to SHPP, resulting in a specialized solver. Moreover, HRC further adopts a two-stage reconstruction strategy. Specifically, at each iteration, HRC first employs the specialized solver to perform large-neighborhood random reconstruction on the selected segment. Subsequently, the 2-opt and kNN-DGR operators are applied to conduct secondary reconstruction within a small neighborhood based on the solution obtained by the specialized solver. By integrating large-neighborhood and small-neighborhood operators, HRC effectively balances global exploration and local exploitation. This design mitigates the optimization blind spots of large-neighborhood operators and reduces the risk of small-neighborhood operators becoming trapped in local optima, thereby enabling a more effective exploration of the solution space.

The key contributions of this work are as follows:

• We identify an important limitation and propose a straightforward yet effective method that fine-tunes the base solver on SHPP instances to enhance its performance, thereby alleviating this limitation.
• We propose a two-stage reconstruction strategy, which first performs a large-neighborhood reconstruction operation, followed by two small-neighborhood reconstruction operations, enabling a more thorough exploration of the solution space.
• To assess the performance of HRC, we conduct extensive experiments on both synthetic and real-world TSP and CVRP instances. Specifically, we adopt DGL [4] and LEHD [14] as the base solvers and fine-tune them on SHPP instances to obtain their SHPP-specialized variants, termed DGL-S and LEHD-S, respectively. Experimental results demonstrate that HRC significantly improves the performance of both DGL and LEHD on large-scale TSP and CVRP instances while achieving superior competitiveness compared with state-of-the-art reconstruction strategies. Ablation studies further verify the effectiveness of the proposed fine-tuning method and two-stage reconstruction strategy.

The remainder of this paper is organized as follows: Section 2 reviews the related work in the field of NCO. Section 3 describes the proposed fine-tuning method and two-stage reconstruction strategy. Section 4 discusses the experimental results. Section 5 discusses the limitations and assumptions. Section 6 concludes the paper.

2. Related Work

Recently, NCO solvers have shown promising results in solving VRPs [17,18,19,20]. However, prior studies are limited to small-scale VRPs and often perform poorly when handling large-scale instances [4]. One major reason is that direct training on large-scale instances incurs substantial computational overhead. A seemingly feasible alternative is to train solvers on small-scale instances; however, such solvers generally exhibit limited generalization ability when applied to large-scale problems.

To better address this problem, several studies have adopted reconstruction-based methods. Specifically, these methods first construct an initial solution, then iteratively destroy a portion of the solution and repair it, aiming to obtain a higher-quality one. Chen et al. [21] designed an end-to-end reinforcement learning framework, whose core components include a region-picking policy and a rule-picking policy. These two policies are used to identify the most promising local region for repair and to select the most suitable repair rule from a predefined rule set, respectively. In subsequent studies, Sui et al. [22] and Ma et al. [23] further adopted 3-opt and k-opt as repair operators, respectively.

Different from these end-to-end solvers, Luo et al. [14] proposed a post-training method termed RRC to enhance the constructive solver LEHD. Specifically, during the post-processing stage, RRC randomly selects a consecutive segment from the initial solution generated by LEHD, and then employs LEHD to reconstruct the selected segment. If the reconstructed segment yields better performance, it replaces the original one, thereby achieving iterative improvement. However, after the destruction process, the reconstruction subproblem can essentially be formulated as an SHPP. In contrast, LEHD is originally trained on problems such as TSP or CVRP, which are inherently different from SHPP. Therefore, the mismatch between the reconstruction subproblem and the original training problem makes it challenging for the original LEHD model to consistently generate high-quality reconstructed segments. In addition, RRC can be viewed as a form of large-neighborhood reconstruction [10]. When the solution contains complex intersections or suboptimal topologies whose scale exceeds the range of the sampled segment, RRC may fail to effectively capture and correct these structures. To better address these two limitations, we propose HRC (see Section 3 for more details).

3. Hybrid Reconstruction (HRC)

In Section 3.1, we first introduce the proposed fine-tuning method. Specifically, we first fine-tune the base solver on SHPP instances to obtain a SHPP-specialized solver, which is used for random reconstruction. Then, in Section 3.2, we present the proposed two-stage reconstruction strategy. The source code is available online (https://github.com/neo-lab111/HRC, accessed on 2 August 2026).

3.1. Fine-Tuning Method

In VRPs, global solution construction and local segment reconstruction follow different optimization objectives. Taking TSP as an example, global construction requires generating a closed tour that visits all nodes and returns to the starting node. In contrast, local reconstruction optimizes a path between two fixed boundary nodes after removing a segment from an existing solution, which can be formulated as the SHPP. Consequently, the two tasks impose different structural constraints and may favor different actions under similar decision states [12].

Formally, let ${\mathcal{L}}_{\mathrm{TSP}}\left(\theta \right)$ and ${\mathcal{L}}_{\mathrm{SHPP}}\left(\theta \right)$ denote the corresponding training objectives, where $\theta$ represents the shared model parameters. A gradient conflict occurs when

$${\nabla }_{\theta }{\mathcal{L}}_{\mathrm{TSP}}{\left(\theta \right)}^{\top }{\nabla }_{\theta }{\mathcal{L}}_{\mathrm{SHPP}}\left(\theta \right)<0.$$

(1)

Consider an SHPP-oriented gradient update:

$${\theta }^{\prime }=\theta -\eta {\nabla }_{\theta }{\mathcal{L}}_{\mathrm{SHPP}}\left(\theta \right),$$

(2)

where $\eta >0$ denotes the learning rate. Applying a first-order Taylor expansion to the TSP objective gives

$$\begin{array}{cc}\hfill {\mathcal{L}}_{\mathrm{TSP}}\left({\theta }^{\prime }\right)& \approx {\mathcal{L}}_{\mathrm{TSP}}\left(\theta \right)+{\nabla }_{\theta }{\mathcal{L}}_{\mathrm{TSP}}{\left(\theta \right)}^{\top }({\theta }^{\prime }-\theta )\hfill \\ \hfill & ={\mathcal{L}}_{\mathrm{TSP}}\left(\theta \right)-\eta {\nabla }_{\theta }{\mathcal{L}}_{\mathrm{TSP}}{\left(\theta \right)}^{\top }{\nabla }_{\theta }{\mathcal{L}}_{\mathrm{SHPP}}\left(\theta \right)\hfill \\ \hfill & >{\mathcal{L}}_{\mathrm{TSP}}\left(\theta \right).\hfill \end{array}$$

(3)

Thus, when the two gradients are negatively aligned, an SHPP-oriented update locally increases the TSP loss. This cross-task interference explains why a solver trained solely for global TSP construction may be poorly adapted to SHPP-based local reconstruction.

To better address this limitation, we propose a straightforward yet effective fine-tuning method, whose overall procedure is illustrated in Figure 2. This method provides a general adaptation paradigm for improving the reconstruction capability of base solvers on SHPP instances. The overall training process mainly consists of three steps: constructing initial solutions for the original VRP variants, randomly sampling SHPP instances, and constructing sub-solutions for the resulting SHPP instances. The pseudocode of the fine-tuning method is presented in Algorithm 1.

Figure 2. Illustration of the fine-tuning process.

During the initial solution construction stage, problem instances of different scales are first generated from a uniform distribution. A base model with frozen parameters is then employed to construct the corresponding initial solutions for the original VRP variants. To improve training efficiency and facilitate reuse in subsequent training, we pre-compute and store the initial solutions for a large number of problem instances, thereby forming a large-scale initial solution pool $\mathcal{P}$. Moreover, in the subsequent process, if the sub-solution generated by SHPP-specialized solver is better than the original sub-solution, the corresponding sub-solution in the original solution is replaced accordingly, thereby progressively improving the solution quality of the original problem.

Algorithm 1: Two-stage self-improvement random reconstruction training procedure

    Subsequently, in each epoch, original problem instances are randomly sampled according to a predefined ratio $\alpha$. Each sampled instance is then decomposed into multiple SHPP subgraphs of scale $S_{\mathrm{sub}}$ based on its current solution, and these SHPP subgraphs are used to train the SHPP-specialized solver via imitation learning. Specifically, given an initial solution, an SHPP subproblem is sampled by randomly selecting a node as the starting point and taking the subsequent $S_{sub}$-1 nodes visited in the solution sequence. For CVRP, capacity constraints are handled according to the procedure introduced in prior work [14]. Figure 3 illustrates examples of constructing SHPP subproblems for TSP and CVRP. In this way, reconstructed segments may span multiple routes while still satisfying all capacity constraints. By continuously generating SHPP subgraphs from different original problems, this design effectively mitigates the risk of overfitting and improves the generalization ability of the SHPP-specialized solver.

Figure 3. Examples of SHPP subproblems generation for TSP and CVRP. For the TSP instance, the optimal solution is [1, 2, 3, 4, 5, 6, 7, 8, 9], from which SHPP subgraph [2, 3, 4, 5, 6] is randomly sampled. For the CVRP instance, the optimal solution is [0, 1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0], and the SHPP subgraph [2, 3, 0, 4, 5, 6, 0] is randomly sampled. Notably, for CVRP, we additionally require each sampled partial solution to terminate at the depot.

To obtain the SHPP-specialized solver, we perform full-parameter fine-tuning on the base model. Specifically, given the current model parameters $\theta$, the SHPP-specialized solver generates augmented solutions for SHPP instances using the POMO strategy [18] and beam search. Subsequently, we construct a unified experience replay pool $\mathcal{D}$ to store high-quality sub-solutions. Specifically, whenever the SHPP-specialized solver constructs a new sub-solution that is strictly better than the original one, this high-quality sub-solution is stored as an independent experience sample in $\mathcal{D}$ and subsequently used as a pseudo-label to fine-tune the base model. Notably, the global solution also needs to be updated with this high-quality sub-solution. The experience pool $\mathcal{D}$ is implemented as a First-In, First-Out queue with a fixed maximum capacity $C_{max}$. Once the storage capacity is reached, the oldest samples are automatically overwritten. This design enables the model to consistently leverage recent generated high-quality sub-solutions for imitation learning while gradually discarding suboptimal samples generated during early exploration. As a result, this design improves sample efficiency and mitigates catastrophic forgetting during the continuously evolving reconstruction training process, thereby promoting stable and robust convergence of the SHPP-specialized solver. For training triggering and sample utilization, the experience pool adopts a threshold-based delayed update strategy, where a centralized neural network parameter update is performed only after the pool has collected at least B newly improved sub-solutions.

Finally, once B new high-quality sub-solutions, i.e., pseudo-labels, have been collected, the SHPP-specialized solver is optimized via imitation learning. The current policy network parameterized by $\theta$ is trained to mimic these pseudo-labels by maximizing the likelihood of selecting the corresponding next node. Specifically, we adopt the cross-entropy loss:

$$\mathcal{L}\left(\theta \right)=-\sum ylog{p}_{\theta }.$$

(4)

This objective encourages the model to maximize the likelihood of selecting the pseudo-labeled node at each decoding step.

3.2. Two-Stage Reconstruction Strategy

In Figure 4, we illustrate two representative cases with $2N$ nodes to compare large-neighborhood and small-neighborhood reconstruction strategies. The blue solid edges denote the current solution, while the red dashed edges indicate the optimal solution. As shown in Figure 4a, there exists an edge crossing between the segment from the first node to the $N-1$th node and the segment from the second node to the Nth node. Due to GPU memory limitations and computational costs, solver-based reconstruction usually covers only a partial subgraph. If the selected subgraph size does not exceed $O\left(N\right)$, the solver cannot reconstruct the crossing segment shown in the figure, and thus cannot further shorten the path length. In this case, small neighborhood strategies, e.g., the 2-opt operator, can easily repair the solution. Despite its effectiveness in this case, small-neighborhood methods are prone to becoming trapped in local optima. Figure 4b shows a typical example where 2-opt falls into a local optimum. Since there are no crossing edges in the current route, 2-opt cannot further reduce the path length and therefore becomes stuck. In this case, random reconstruction with a range smaller than $O\left(N\right)$ is also insufficient to fully resolve the local-optimum structure.

Figure 4. Illustration of large neighborhood and small neighborhood strategies.

Based on the analysis of the two representative failure cases discussed above, we propose a two-stage reconstruction strategy. Specifically, the first stage employs the SHPP-specialized solver to perform large-neighborhood random reconstruction on the current solution. In the second stage, the resulting solution is further refined through small-neighborhood reconstruction, which consists of two complementary components: 2-opt and kNN-DGR. The 2-opt operator first eliminates locally suboptimal edge connections, after which kNN-DGR further repairs the remaining complex local structures through neighborhood destruction and greedy reconstruction. The pseudocode of the two-stage reconstruction is presented in Algorithm 2. Here, $L(·)$ denotes the evaluation function, which is used to calculate the total length or cost of a given path or subpath. ${\mathcal{N}}_k\left(v\right)$ represents the set of the k nearest neighboring nodes of node v in terms of spatial distance. ${\mathrm{Solver}}_{\theta }(·)$ denotes the SHPP-specialized solver parameterized by $\theta$, which is used for random reconstruction. The operator $\oplus (S_{\mathrm{old}}\to S_{\mathrm{new}})$ denotes the sub-solution replacement operation, where the old sub-solution is removed from the global solution and replaced with the newly reconstructed sub-solution. $2-\mathrm{opt}(X_b,e_i,e_j)$ denotes the new sub-solution obtained by applying a 2-opt operator to edges $e_i$ and $e_j$ in subgraph $X_b$. $\mathrm{Destroy}(·)$ is the destruction operator used to remove part of the sub-solution from the subgraph, while $\mathrm{GreedyRepair}(·)$ denotes the repair operator that reconstructs the destroyed subgraph using greedy insertion.

Notably, during reconstruction, for CVRP, if the remaining vehicle capacity is insufficient to serve any unvisited customer, the vehicle is forced to return to the depot, after which its capacity is reset.

Algorithm 2: Two-stage reconstruction strategy

4. Experimental Results

To assess the performance of HRC, we fine-tune two representative NCO solvers, namely DGL (IJCAI’25) [4] and LEHD (NeurIPS’23) [14], to obtain their SHPP-specialized variants, termed DGL-S and LEHD-S, respectively. Subsequently, we conduct extensive experiments on both synthetic and real-world instances to evaluate the effectiveness of the proposed HRC. Then, we perform ablation studies to verify the contributions of the proposed fine-tuning method and two-stage reconstruction strategy. Finally, we conduct sensitivity analyses to investigate the impact of key parameters.

4.1. Experimental Setups

Baselines: This paper selects eight representative NCO solvers as baselines for comparison, including: (1) divide-and-conquer-based solvers: UDC (NeurIPS’24) [24]; (2) generalization-based solvers: Omni-TSP (ICML’23) [7], BQ (NeurIPS’23) [25], ELG (IJCAI’24) [26], INViT-3V (ICML’24) [27], DGL (IJCAI’25) [4], and ICAM (TITS’26) [6]; and (3) iterative-improvement-based solvers: LEHD (NeurIPS’23) [14] and L2C-Insert (NeurIPS’25) [28]. All baseline models use their publicly available pre-trained parameters and default settings and are evaluated under the same hardware and experimental environment as HRC to ensure a fair inference runtime comparison. In particular, when applying the RRC process to LEHD, Luo et al. [28] pointed out that increasing the reconstructed subgraph size beyond 1000 yields only marginal performance improvements while significantly increasing computational cost. Therefore, this paper limits the maximum subgraph size to 1000.

Hyper-parameters: To accelerate model training, we perform full-parameter fine-tuning on the DGL and LEHD to obtain DGL-S and LEHD-S, with the model parameters kept consistent with those of the original DGL and LEHD. DGL-S and LEHD-S is trained for $E=50$ epochs, with each epoch consisting of $K=100$ steps. For TSP and CVRP, the initial large graphs are randomly sampled from uniform distributions with 100–10,000 nodes and 50–5000 nodes, respectively. The training-trigger threshold B is set to 256, and the maximum capacity of the experience replay pool $C_{max}$ is set to 2048. For TSP and CVRP, four and three large graphs are replaced in each epoch, corresponding to $\alpha =0.015$ and $\alpha =0.012$, respectively. The subgraph size $S_{\mathrm{sub}}$ is set to 99 for TSP and 49 for CVRP, respectively. In the hybrid-neighborhood iterative improvement algorithm, when the 2-opt and kNN-DGR operators are invoked for reconstruction, the algorithm continuously performs reconstruction until convergence to a local optimum. For the 2-opt operator, the termination condition is that no pair of edges can be exchanged to shorten the original route. For the kNN-DGR operator, the termination condition is that the route length does not decrease after 10 consecutive rounds of k-nearest-neighbor destruction and greedy insertion. In each operation, kNN-DGR destroys the route segments associated with five nearest-neighbor nodes.

Datasets: To assess the performance of HRC, following the prior study [4], we use the MSVDRP dataset proposed in [27] for synthetic experiments. Specifically, the synthetic TSP instances are generated from a uniform distribution at four scales, namely, 100, 1000, 5000, and 10,000 nodes, while the synthetic CVRP instances are generated from a uniform distribution at three scales, namely 50, 500, and 5000 nodes. For real-world evaluation, we adopt the widely recognized TSPLIB [29] and CVRPLIB Set-X [30] benchmark datasets. TSPLIB contains 77 instances with problem sizes ranging from 51 to 18,512 nodes. In addition, the CVRPLIB Set-X benchmark contains 100 instances with problem sizes ranging from 100 to 1000 nodes. Compared to synthetic instances, real-world instances typically exhibit more complex data distributions and are more difficult to characterize.

Metrics: For all baseline methods and our HRC, we uniformly report the average gap to the (near-)optimal solution and the total inference runtime. Formally, the gap is computed as follows:

$$gap={\displaystyle \frac{D\left(S^{\mathrm{solver}}\right)-D\left(S^{\mathrm{opt}}\right)}{D\left(S^{\mathrm{opt}}\right)}}\times 100\%,$$

(5)

where $D\left(S^{\mathrm{solver}}\right)$ denotes the objective value (i.e., solution length) obtained by the evaluated neural solver, and $D\left(S^{\mathrm{opt}}\right)$ denotes the objective value of the corresponding (near-)optimal solution. Following the prior study [27], for the synthetic datasets, the (near-)optimal solutions for TSP-100 instances are obtained using Gurobi, whereas those for larger TSP instances are generated using LKH. The (near-)optimal solutions for synthetic CVRP instances are obtained using HGS. Following the prior study [27], for real-world datasets, the currently best-known solutions are adopted as the (near-)optimal solutions.

Hardware: All experiments were conducted on an Intel(R) Xeon(R) Platinum 8352V CPU and an NVIDIA RTX 4090 GPU (24GB).

4.2. Performance Comparison

In Table 1 and Table 2, we present the performance of different solvers on synthetic TSP and CVRP instances, respectively. Furthermore, for iterative improvement-based solvers, we report their performance under two iteration settings, i.e., $t=50$ and $t=100$. As can be observed, iterative improvement-based solvers consistently achieve better solution quality at the cost of additional computational time. Nevertheless, even with only $t=50$ iterations, HRC still outperforms LEHD and L2C-Insert with $t=100$ iterations on several large-scale instances, such as TSP-5000, TSP-10000, and CVRP-5000. This superior performance is mainly attributed to the proposed two-stage reconstruction strategy. The results demonstrate that introducing local neighborhood reconstruction operators can effectively overcome the performance bottleneck caused by the optimization blind spots of large-neighborhood operators. Moreover, fine-tuning DGL on SHPP instances also contributes to the performance improvement of HRC (see Section 4.3 for more details). Among all the compared baselines, HRC is the only solver capable of maintaining the deviation from the (near-)optimal solutions within 1% for large-scale TSP instances and within 0.5% for large-scale CVRP instances, specifically on TSP-10000 and CVRP-5000. We conduct the Wilcoxon signed-rank test, which confirms that DGL + HRC significantly outperforms DGL across all evaluated problem sizes, with p-values below 0.05. Given that fine-tuning DGL-S requires only approximately 150 min, this additional cost is justified by the resulting improvement in solution quality. The trade-off between solution quality and the inference runtime is shown in Figure 5.

Table 1. Performance comparison of different solvers on uniformly distributed synthetic TSP instances.

Method	TSP-100		TSP-1000		TSP-5000		TSP-10000
	Gap (%)↓	Time↓	Gap (%)↓	Time↓	Gap (%)↓	Time↓	Gap (%)↓	Time↓
(Near-)Optimality	0.00	23.8 m	0.00	16.3 h	0.00	2.1 h	0.00	33.6 h
UDC	0.40	1.4 m	2.06	1.9 m	6.99	2.0 m	8.73	3.7 m
Omni-TSP	1.28	8.4 s	19.56	1.3 m	49.43	16.1 m	61.39	2.0 h
BQ	5.14	13.5 s	3.82	9.6 m	12.68	1.9 h	18.74	13.5 h
ELG	0.24	23.5 s	12.22	13.4 s	18.84	39.7 s	18.32	5.6 m
INViT-3V	2.08	46.8 s	5.13	2.6 m	6.49	6.6 m	4.82	20.2 m
DGL + BS(4)	0.27	1.64 m	1.60	1.73 m	2.90	2.0 m	1.83	8.3 m
LEHD + RRC (t = 50)	0.04	59.65 s	1.10	28.90 m	11.35	4.96 h	16.62	35.61 h
LEHD+RRC (t = 100)	0.02	1.87 m	0.90	50.58 m	10.65	9.21 h	15.68	70.01 h
L2C-Insert + RRC (t = 50)	0.01	4.83 m	1.45	3.90 m	5.24	50.08 s	4.63	1.20 m
L2C-Insert + RRC (t = 100)	0.00	9.49 m	1.01	7.59 m	3.95	1.33 m	3.35	1.74 m
DGL + HRC (t = 50)	0.10	2.22 m	1.25	2.12 m	2.55	3.54 m	1.02	15.04 m
DGL + HRC (t = 100)	0.07	3.36 m	1.11	3.28 m	2.38	5.90 m	0.85	25.15 m

Note: Bold indicates the best performance. The symbol “BS(4)” denotes beam search with a beam width of 4.

Table 2. Performance comparison of different solvers on uniformly distributed synthetic CVRP instances.

Method	CVRP-50		CVRP-500		CVRP-5000
	Gap (%)↓	Time↓	Gap (%)↓	Time↓	Gap (%)↓	Time↓
(Near-)Optimality	0.00	5.1 h	0.00	26.4 h	0.00	79.2 h
UDC	–	–	5.62	7.4 m	3.33	16.7 m
Omni-TSP	4.04	2.4 s	6.32	1.6 m	48.74	21.5 m
BQ	3.18	4.4 s	3.31	1.4 m	5.19	2.0 h
ELG	8.88	6.9 s	7.86	12.5 s	8.20	4.7 m
INViT	5.06	1.9 m	9.57	2.4 m	7.62	9.8 m
DGL + BS(4)	1.14	2.21 m	4.39	4.50 m	1.16	13.94 m
LEHD + RRC (t = 50)	1.04	0.30 m	3.18	4.33 m	6.17	25.63 m
LEHD + RRC (t = 100)	0.76	0.55 m	2.90	7.15 m	5.70	32.43 m
L2C-Insert (t = 50)	1.10	2.43 m	3.37	11.40 m	1.94	3.45 m
L2C-Insert (t = 100)	0.75	4.59 m	3.12	22.04 m	1.59	5.02 m
DGL + HRC (t = 50)	1.11	4.55 m	3.40	6.46 m	0.40	11.70 m
DGL + HRC (t = 100)	1.07	8.12 m	3.22	8.22 m	0.35	20.00 m

Note: Bold indicates the best performance. “–” indicates that UDC cannot solve instances with 50 nodes. The symbol “BS(4)” denotes a beam search with a beam width of 4.

Figure 5. Trade-off between the solution quality and the inference runtime.

In Table 3 and Table 4, we present the performance of different solvers on real-world TSP and CVRP instances, respectively. In Table 5, we present the inference runtime of DGL + HRC on TSPLIB and CVRPLIB Set-X instances. Compared with synthetic datasets, the node coordinates of real-world instances exhibit more complex and heterogeneous distributions, making their structural characteristics more difficult to capture and posing greater challenges to cross-distribution generalization [9]. Moreover, existing models are typically trained on synthetic CVRP instances with customer demands restricted to a fixed range, whereas real-world instances may exhibit substantially different demand-to-capacity ratios, further increasing the difficulty of generalization. Consequently, on large-scale real-world CVRP instances, HRC does not achieve gaps to the (near-)optimal solutions as small as those observed on synthetic datasets. Nevertheless, HRC still achieves the best overall performance among all compared baseline methods. To further illustrate the impact of shifts in the demand-to-capacity ratio, Figure 6 compares the demand-to-capacity ratios of customer nodes in a synthetic training instance and two representative CVRPLIB Set-X instances, namely X-n298-k31 and X-n247-k50. As shown, X-n298-k31 exhibits a demand-to-capacity ratio that is more similar to that of the synthetic training instance, leading to better HRC performance. In contrast, X-n247-k50 exhibits a substantially different demand-to-capacity ratio, with a considerable proportion of customer demands accounting for approximately 40–75% of the vehicle capacity, far beyond the range observed during training. This pronounced distribution shift makes it more difficult for the neural solver to adapt effectively, resulting in a larger gap of $6.331\%$ on X-n247-k50. Closing this gap through targeted fine-tuning on a limited number of instances with distributions similar to those in TSPLIB and CVRPLIB remains challenging, as these benchmarks contain highly heterogeneous instances that do not follow a unified distribution. Future work could explore domain generalization techniques, such as invariant representation learning, to improve the solver’s robustness on real-world instances. Finally, similar to other NCO solvers, HRC remains feasible under all valid capacity settings. When the vehicle capacity is sufficiently large, all customer nodes can be served in a single route. Conversely, if the vehicle capacity is smaller than the demand of any individual customer, the instance itself is infeasible and violates the standard CVRP definition.

Table 3. Performance comparison of different solvers on TSPLIB instances.

Method	TSPLIB
	≤1000 (48)	1001–10,000 (24)	>10,000 (5)
	Gap (%)↓	Gap (%)↓	Gap (%)↓
UDC	3.10 (42)	14.11	23.36 (1)
Omni-TSP	9.66	34.89	OOM
BQ	8.42	14.50	45.21 (1)
ELG	4.51	5.52	7.80
INViT	3.20	7.63	7.57
DGL	2.17	5.58	5.31
LEHD + RRC (t = 100)	0.54	6.62	28.87 (3)
L2C-Insert (t = 100)	0.58	8.15	25.97
DGL + HRC (t = 100)	0.48	1.94	2.26

Table 4. Performance comparison of different solvers on CVRPLIB Set-X instances.

Method	CVRPLIB
	100–200 (22)	201–500 (46)	>500 (32)
	Gap (%)↓	Gap (%)↓	Gap (%)↓
UDC	–	8.87	8.16
Omni-TSP	8.14	8.24	11.21
BQ	13.35	9.95	11.18
ELG	4.51	5.52	7.80
INViT	6.61	9.27	10.21
DGL	5.9	6.99	7.80
ICAM	4.41	3.92	4.70
LEHD + RRC (t = 100)	3.91	4.28	7.43
L2C-Insert (t = 100)	2.86	4.32	6.27
DGL + HRC (t = 100)	2.81	4.26	4.44

Table 5. Average inference runtime of DGL + HRC on TSPLIB and CVRPLIB Set-X instances.

TSPLIB
≤1000 (48)	1001–10,000 (24)	>10,000 (5)
23 s	39 s	437 s
CVRPLIB
100–200 (22)	201–500 (46)	>500 (32)
19 s	19 s	23 s

Figure 6. Comparison of customer demand-to-capacity ratios between a synthetic training instance and two representative CVRPLIB Set-X instances. (a) Synthetic training instance. (b) CVRPLIB instance X-n298-k31. (c) CVRPLIB instance X-n247-k50.

To demonstrate the generality of HRC, we further integrate it with LEHD and evaluate its performance. As shown in Table 6, HRC consistently improves solution quality, demonstrating its effectiveness across different NCO solvers.

Table 6. Performance comparison between RRC and HRC.

Method	TSP-100	TSP-1000	TSP-5000
	Gap (%)↓	Gap (%)↓	Gap (%)↓
LEHD + RRC (t = 100)	0.0036	1.5164	10.6918
LEHD + HRC (t = 100)	0.0019	1.0737	5.8798

4.3. Ablation Study

In this section, we conduct ablation studies on synthetic TSP and CVRP instances to evaluate the contribution of each component in HRC. Specifically, we consider five different settings. Setting_1: Perform 100 random reconstructions using the fine-tuned DGL-S. Setting_2: Apply only the 2-opt operator until convergence to a local optimum. Setting_3: Apply only the kNN-DGR operator until convergence to a local optimum. Setting_4: First perform 100 random reconstructions using the fine-tuned DGL-S, followed by the 2-opt and kNN-DGR operators until convergence to a local optimum. Setting_5: First apply the 2-opt and kNN-DGR operators until convergence to a local optimum, and then perform 100 random reconstructions using the fine-tuned DGL-S. Setting_6: Within each iteration, sequentially apply 2-opt, DGL-S-based reconstruction, and kNN-DGR. Setting_7: Within each iteration, sequentially apply 2-opt, kNN-DGR, and DGL-S-based reconstruction. Setting_8: Perform 100 random reconstructions using the original DGL. Setting_9: Within each iteration, sequentially apply DGL-S-based reconstruction and 2-opt. Setting_10: Within each iteration, sequentially apply DGL-S-based reconstruction and kNN-DGR. Setting_11: Within each iteration, sequentially apply DGL-based reconstruction, 2-opt, and kNN-DGR. Setting_12: Remove experience replay from HRC. Setting_13: Remove pseudo-label replacement from HRC.

As shown in Table 7 and Table 8, compared with the single-neighborhood iterative improvement methods, HRC achieves performance improvements of 66.54% over Setting_1, 33.07% over Setting_2, and 71.85% over Setting_3 on TSP-10000. Similarly, on CVRP-5000, HRC achieves improvements of 76.19% over Setting_1, 69.58% over Setting_2, and 75.18% over Setting_3. These results demonstrate the effectiveness of HRC compared with single-neighborhood optimization methods. Setting_4 and Setting_5 also combine all three operators but apply them in separate consecutive phases. Consequently, the improvement produced by one neighborhood mechanism cannot be immediately refined or complemented by the others during the iterative search, leading to an inferior performance. By contrast, HRC alternates large- and small-neighborhood reconstruction within each iteration, allowing DGL-S to escape local optima and enabling 2-opt and kNN-DGR to promptly refine the resulting solution. Furthermore, Setting_6 and Setting_7 modify the within-iteration operator order while retaining this alternating mechanism. Their performance is nearly identical to that of HRC, indicating that the specific operator order has only a minor influence. These results suggest that the main advantage of HRC arises from the iterative coordination of complementary neighborhood operators rather than from a particular execution order.

Table 7. Ablation study results for different design choices (TSP).

Method	TSP-100	TSP-1000	TSP-5000	TSP-10000
	Gap (%)↓	Gap (%)↓	Gap (%)↓	Gap (%)↓
DGL	0.63	2.19	3.83	3.05
Setting_1	0.12	1.37	3.08	2.54
Setting_2	0.54	1.84	2.90	1.27
Setting_3	0.56	2.15	3.81	3.02
Setting_4	0.10	1.29	2.55	1.10
Setting_5	0.11	1.25	2.51	0.97
Setting_6	0.07	1.11	2.37	0.85
Setting_7	0.07	1.11	2.37	0.86
Setting_8	0.13	1.43	3.19	2.61
Setting_9	0.11	1.23	2.50	0.98
Setting_10	0.07	1.21	2.88	2.12
Setting_11	0.08	1.20	2.49	0.95
Setting_12	0.10	1.16	2.42	0.90
Setting_13	0.10	1.13	2.40	0.89
HRC	0.07	1.11	2.38	0.85

Table 8. Ablation study results for different design choices (CVRP).

Method	CVRP-50	CVRP-500	CVRP-5000
	Gap (%)↓	Gap (%)↓	Gap (%)↓
DGL	2.02	5.47	1.65
Setting_1	1.58	4.33	1.47
Setting_2	1.73	4.82	1.15
Setting_3	1.76	4.97	1.41
Setting_4	1.31	3.94	1.04
Setting_5	1.38	4.17	1.06
HRC	1.07	3.22	0.35

As shown in Table 9, increasing the subgraph size $S_{\mathrm{sub}}$ consistently improves solution quality, reducing the gap from 2.6322% to 2.2385%. However, it also increases the inference runtime from 134.82 s to 187.26 s, revealing a clear trade-off between effectiveness and efficiency.

Table 9. Sensitivity analysis of subgraph size $S_{\mathrm{sub}}$ on TSP-5000.

${\mathit{S}}_{\mathbf{sub}}$	Gap (%) ↓	Time (s) ↓
30	2.6322	134.82
50	2.5507	145.62
99	2.3781	151.02
200	2.2385	187.26

5. Discussion and Limitations

The proposed HRC relies on several simplifying assumptions that may not fully hold in real-world applications, including the absence of time-window constraints, relatively stable instance scales and distributions, and the use of Euclidean distance as the travel-cost metric. The details are as follows.

Constraint assumptions: HRC, and most existing NCO solvers, primarily focuses on TSP and CVRP instances without time-window constraints. Future work should incorporate more complex operational constraints to better align the framework with practical logistics scenarios. One possible direction is to dynamically re-embed the remaining nodes at each encoding step according to the current temporal state, thereby enabling the model to account for evolving feasibility conditions.

Scale and distribution assumptions: As shown in Table 3 and Table 4, the performance of HRC, as well as that of most NCO solvers, degrades on real-world instances compared with synthetic ones. This degradation is mainly caused by the unknown and heterogeneous distributions of real-world data. Future research could explore domain generalization techniques, such as invariant representation learning, to identify features that remain robust across different scales and distributions, thereby improving out-of-distribution generalization.

Distance assumptions: HRC currently adopts Euclidean distance for cost calculation, whereas real-world logistics systems may involve more complex distance metrics, such as Manhattan distance in urban road networks [31]. Extending HRC to support more realistic travel-cost models therefore represents another important direction for future research.

6. Conclusions

In this paper, we propose HRC, which is designed to improve the performance of NCO solvers on large-scale instances. Specifically, HRC proposes a fine-tuning method to improve the performance of the base solver on SHPP instances. Then, HRC adopts a two-stage reconstruction strategy to enable a more thorough exploration of the solution space. Experimental results on both synthetic and real-world instances demonstrate that HRC outperforms the compared reconstruction strategies. Ablation studies further demonstrate the effectiveness of all proposed designs.