Solving the clustered traveling salesman problem via traveling salesman problem methods

Transformation of the CTSP to the TSP

As the literature review shows, a number of dedicated solution approaches have been developed to solve the CTSP. However, one observes that these approaches have difficulty producing robustly and consistently high-quality solutions for large-scale CTSP instances with tens of thousands of vertices. Moreover, the best performing CTSP methods (e.g., VNRDGILS (Mestria, 2018), HHGILS (Mestria, 2016), and GPR1R2 (Mestria, Ochi & de Lima Martins, 2013)) are computationally expensive (e.g., requiring 1,080 s to find good solutions for instances with 1,173 ≤ n ≤ 2,000).

On the other hand, problem transformation has been highly successful in solving several difficult optimization problems such as the latin square completion problem via graph coloring (Jin & Hao, 2019) and the winner determination problem via weighted maximum cliques (Wu & Hao, 2015). It is known that the CTSP can be transformed to the conventional TSP (Chisman, 1975). Therefore, in principle, the CTSP can be solved by any TSP algorithm. However, to our knowledge, no computational study on using problem transformation to solve the CTSP has been presented in the literature. This work fills the gap by exploring the problem transformation approach of Chisman (1975) and testing three representative state-of-the-art TSP solvers including both exact and inexact solution approaches.

The basic idea of transforming the CTSP to the TSP is to add a large artificial cost M to all inter-cluster edges in order to force the salesman to visit all the cities within each cluster before leaving it.

Given a CTSP instance G = (V, E) with distance matrix C, we define a TSP instance G′ = (V′, E′) with distance matrix C′ as follow.

• Define V = V′ and E = E′.

• Define the travel distance c′_ij in G′ by

$$c_{ij}^{\mathrm{\prime }}=\{\begin{array}{cc}{c}_{ij}+M& \mathrm{i}\mathrm{f}i\mathrm{a}\mathrm{n}\mathrm{d}j\mathrm{b}\mathrm{e}\mathrm{l}\mathrm{o}\mathrm{n}\mathrm{g}\mathrm{t}\mathrm{o}\mathrm{d}\mathrm{i}\mathrm{f}\mathrm{f}\mathrm{e}\mathrm{r}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{c}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{s}\\ c_{ij}& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}$$

Obviously, if the value of M is sufficiently large, then the best Hamiltonian cycle in G′ is a feasible CTSP solution in G, in which the vertices of each cluster are visited contiguously.

Property.An optimal solution to the TSP instance corresponds to an optimal solution to the original CTSP instance.

Proof. Let S′ and S be the optimal solutions of the TSP instance G′ and the original CTSP instance G, respectively. Let m be the number of clusters of G. To minimize the total travel cost, there are only m inter-cluster edges in S′. Therefore, S′ is a feasible CTSP solution for G and satisfies the following relation:

$$f(S^{{}^{\prime }})=f(S)+m\times M$$

Obviously, S′ corresponds to S by subtracting the constant m × M.

Solution methods for the TSP

There are numerous solution methods for the TSP. In this work, we adopt three very powerful TSP solvers whose codes are publicly available, including one exact solver (Concorde (Applegate, Bixby & Chvatal, 2006)) and two inexact (heuristic) solvers (LHK-2 (Helsgaun, 2009) and GA-EAX (Nagata & Kobayashi, 2013)).

Notice that the TSP instance converted from a CTSP instance has a particular feature that the vertices are grouped into clusters and the distance between each pair of vertices within a same cluster is in general small, while this distance is large for two vertices from different clusters. Along with the presentation of the TSP solvers, we discuss their suitability for solving such clustered instances each time this is appropriate.

Edge assembly crossover based genetic algorithm

Population-based evolutionary algorithms are another well-known approach for the TSP. A popular example is the powerful genetic algorithm introduced by Nagata & Kobayashi (2013). This algorithm (called GA-EAX, see Algorithm 1) is characterized by its powerful edge assembly crossover (EAX) operator introduced in Nagata & Kobayashi (1997) and Nagata & Soler (2012) with an efficient implementation and a cost-effective selection strategy for maintaining population diversity.

Algorithm 1:

GA-EAX for the CTSP.

Require: TSP instance G, population size p; number of offspring solutions r generated from each parent pair

Ensure: best solution S*

1: $POP=\{P_1,P_2,...,P_p\}\leftarrow$ Initial_Population(G)

2: while stopping condition is not met do

3: Randomly shuffle the solutions in POP

4: fori = 1,2,…, pdo

5: $S_1\leftarrow P_i$, $S_2\leftarrow P_{i+1}$ /* Note: Pp + 1 = P1 */

6: $(o_1,...,o_r)\leftarrow$ EAX(S1, S2)

7: $P_i\leftarrow$ Select_Best(o1,…, or, S1)

8: end for

9: end while

10: $S^{\ast }\leftarrow$ Best(POP)

11: Return S*

DOI: 10.7717/peerj-cs.972/table-7

The key EAX operator generates, from two high-quality tours (parents), one offspring tour by first inheriting the edges from the parents to construct disjoint subtours and then connecting the subtours with new edges in a greedy fashion (similar to building a minimal spanning tree). Let S_A and S_B be the parents, EAX operates as follows (see Fig. 2 for an example):

1. Generate an undirected multigraph defined as G_AB = (V, E_A ∪ E_B), where E_A and E_B are the sets of edges of parents S_A and S_B, respectively.

2. Extract all AB-cycles from G_AB. An AB-cycle is defined as a cycle in G_AB, such that edges of E_A and edges of E_B are alternately linked.

3. Construct an E-set by selecting AB-cycles according to a given selection strategy (e.g., single, k-multiple, block and block2 (Nagata & Kobayashi, 2013)), where an E-set is a set of AB-cycles.

4. Copy parent S_A to an intermediate solution o. Then, remove the edges of E_A in the E-set from o and add those of E_B in the E-set to o. This leads to an intermediate solution o with one or more subtours.

5. Connect all the subtours in o with new short edges to generate a complete tour (a feasible offspring solution) by using a greedy heuristic.

Note that different versions of EAX can be developed by using different selection strategies of AB-cycles for constructing E-sets. The GA-EAX algorithm employs the single and block2 strategies to generates offspring solutions from parent solutions. To maintain a healthy population diversity, GA-EAX also uses an edge entropy measure to select the solution to be used to replace a parent in the population.

Other studies (e.g., Hains, Whitley & Howe, 2012) also indicated the usefulness of edge-assembly-like crossovers for solving clustered instances of the TSP. As shown in the next section, the EAX-based genetic algorithm performs remarkably well on all the clustered instances transformed from the CTSP.

Benchmark instances

Our computational assessments are based on three sets of 73 benchmark instances with 101 to 24,978 vertices. Sets 1 and 2 include 20 medium instances (101 ≤ |V| ≤ 1,000) and 15 large instances (1,173 ≤ |V| ≤ 2,000), which are classical and widely used in the CTSP literature (e.g., Mestria, Ochi & de Lima Martins, 2013; Mestria, 2016; Mestria, 2018). Set 3 includes 38 large GTSP instances (1,000 ≤ |V| ≤ 24,978) from Helsgaun (2014).

Sets 1 and 2 (35 instances): These instances belong to the following six types: (1) instances taken from the TSPLIB (Reinelt, 1991) where the clusters are generated by using a k-means clustering algorithm; (2) instances created from a selection of classic TSP instances (Johnson & McGeoch, 2007), where the clusters are created by grouping the vertices in geometric centers; (3) instances generated by using the Concorde interface (Applegate, Bixby & Chvatal, 2006); (4) instances generated using the layout proposed in Laporte & Palekar (2002); (5) instances similar to type 2, but generated with different parameters; (6) instances adapted from the TSPLIB (Reinelt, 1991), where the rectangular floor plan is divided into several quadrilaterals and each quadrilateral corresponds to a cluster. These instances are available at http://www2.ic.uff.br/~labic/conteudo/instance/.

Set 3 (38 instances): These large instances have 1,000 to 24,978 vertices and come from GTSPLIB for the generalized traveling salesman problem (GTSP). They were generated from TSP instances by using Fischetti, Salazar González & Toth (1997) clustering algorithm and tested in Helsgaun (2014) by considering them as CTSP instances. These instances are available at http://www.ruc.dk/~keld/research/CLKH. In Helsgaun (2014), six very large instances with 31,623 to 85,900 vertices were also tested. We ignore these instances, because they are too large for the exact Concorde solver and the GA-EAX solver stops abnormally when solving these instances.

TSP solvers and experimental protocol

For our study, we employed three representative TSP solvers presented in “Solution Methods for the TSP”, which are among the most powerful methods for the TSP in the literature.

• Exact Concorde TSP solver (http://www.math.uwaterloo.ca/tsp/concorde/index.html): We used version Concorde-03.12.19 and ran the solver with its default parameter setting with a cutoff time of 24 CPU hours per instance.

• Inexact CLKH solver (http://www.ruc.dk/~keld/research/CLKH): We used the version CLKH-1.0 which is based on the latest version 2.0.9 (http://akira.ruc.dk/~keld/research/LKH/) of LKH-2. The default parameter setting given in Helsgaun (2014) was adopted to run CLKH. Notice that to reduce its run time, the maximum number of trials (iterations) is set to 1,000 in CLKH, while this number is set to n (instance size) by default in LKH-2.

• Inexact GA-EAX TSP solver (https://github.com/sugia/GA-for-TSP): We used GA-EAX with its default parameter setting given in Nagata & Kobayashi (2013): p = 300, r = 30 and GA-EAX terminates if the difference between the average tour length and the shortest tour length in the population is less than 0.001. Following Kerschke et al. (2018) and Kotthoff et al. (2015), we reset the random seed for GA-EAX for each run (which was set to a fixed value in the official implementation).

The experiments were carried out on a computer running Linux operating system with an Intel E5-2670 processor (2.8 GHz and 4G RAM). Given the stochastic nature of CLKH and GA-EAX, we ran each algorithm 10 times for each instances while the deterministic Concorde TSP solver was run one time to solve each instance.

Computational results and comparison of popular TSP solvers

Our computational studies aim to answer the following questions: How do state-of-the-art exact TSP solvers perform on clustered instances converted from the CTSP? How do state-of-the-art inexact (heuristic) TSP solvers perform on clustered instances converted from the CTSP?

The results of the three TSP solvers (Concorde, CLKH, GA-EAX) on the 20 medium and 15 large CTSP benchmark instances are summarized in Table 1 (Set 1) and Table 2 (Set 2). Columns 1 to 3 show the basic information of each instance: the instance name (Instance), the number of vertices (|V|) and the number of clusters (m). Column 4 gives the optimal objective value reported by the exact Concorde TSP solver, followed by the required run time in seconds. For both the CLKH and GA-EAX solvers, we show the best (Gap_best) and average (Gap_avg) results over 10 independent runs in the form of the percentage gap to the optimal solution, as well as the average run time in seconds. If the best solution over 10 independent runs equals the optimal solution obtained with the exact Concorde TSP solver, the corresponding cell in column Gap_best shows ‘=’ along with the number of runs that succeeded in finding the optimal solution. Finally, row ‘Avg.’ provides the average run time in seconds for each approach, and the average gap between the average objective values obtained with CLKH/GA-EAX and the optimal values obtained with the Concorde TSP solver.

From Tables 1 to 2, we can make the following observations:

First, the exact Concorde TSP solver performs very well on these 35 instances and is able to solve all of them exactly. Specifically, the 20 medium instances can be solved easily in a short run time (an average of about 14 s). The 15 large instances are more difficult and the run time needed to solve these instances increases considerably (an average of 1,133.8 s, reaching 7,214.3 s for the most difficult instance).

Second, the CLKH solver performs globally very well on these 35 instances. For the 20 medium instances, CLKH attains all the optimal solutions but one with an average run time of 47.8. For the 15 large instances, CLKH reaches the optimal solutions for 13 instances with an average run time of 257.3 s.

Third, the GA-EAX solver performs remarkably well by attaining the optimal values for all 35 instances but one. For the 20 medium instances, GA-EAX consistently hits the optimal solutions for each of its 10 run (except for one instance for which it has a hit of 9 out of 10). The average run time is only 5.7 s for the medium instances and 33.6 s for the large instances. Compared to Concorde and CLKH, GA-EAX is thus extremely time efficient. Moreover, contrary to the Concorde and CLKH solvers, the computation time required by GA-EAX remains very stable across the instances of the same set, indicating a high robustness and scalability of this solver.

Table 3 presents the results of the three TSP solvers on the 38 large GTSP instances of Set 3. Notice that the Concorde solver failed to exactly solve 17 instances in 24 h, the corresponding cell (in parentheses) in column ‘Optimum’ indicates the best tour length (best upper bound) found by CLKH and GA-EAX. In this case, the percentage gaps (Gap_best and Gap_avg) are calculated by using the best bound, and column Gap_best shows ‘=’ the number of runs for an algorithm to find the best bound.

From Table 3, we can make the following observations. First, Concorde manages to optimally solve 21 large GTSP instances with up to 3,162 vertices with a run time ranging from 17.4 s to 45,008.4 s while its solution time is not completely consistent with the size of the problem instances. For the 21 instances that can be solved exactly by Concorde, CLKH attains 15 best upper bounds, while GA-EAX reaches all best upper bounds in less computing time. Second, for most of the instances with |V| < 10,000, compared with CLKH, GA-EAX has a better performance both in terms of solution quality and computation time. For the instances with 10,000 ≤ |V| ≤ 24,978, the solution quality of GA-EAX is better than that of CLKH in most cases, while requiring more computation time.

To sum up, the exact Concorde solver is very efficient for the instances with up to 1,000 vertices (order of seconds) and can even find optimal solutions for instances with up to some 3,000 vertices at a price of more run time (order of minutes to hours). For larger instances, both inexact solvers (CLKH and GA-EAX) are reliable alternatives to find optimal or sub-optimal solutions with some advantages for GA-EAX. These heuristic solvers also perform very well on smaller instances.

To deepen our computational study, we call upon to the performance profile, an analytic tool for evaluating the performances of multiple compared optimization algorithms (Dolan & Moré, 2002). The performance profile uses a cumulative distribution function for a performance metric, such as run time, objective function values, number of iterations, and so on. Precisely, let S be a set of algorithms and P be a set of problem instances. For a given performance metric f_s,p (that is the performance of algorithm s ∈ S solving instance p ∈ P), the performance ratio is defined by $r_{s,p}={\displaystyle \frac{f_{s,p}}{min\{f_{a,p}:a\in S\}}}$. Then, for each algorithm s ∈ S, the performance function is given by ${\rho }_s(\tau )={\displaystyle \frac{|\{p\in P:r_{s,p}\le \tau \}|}{|P|}}$. Thus, the value of ρ_s(1) corresponds to the fraction of problem instances that algorithm s can achieve many times the performance of the best algorithm (meaning the probability that the algorithm s will win over the rest of the compared algorithms). For a large value τ, the value of ρ_s(τ) indicates a high robustness of algorithm s.

To make a fair and meaningful comparison with this tool, we focus on the two inexact solvers CLKH and GA-EAX and run each solver 10 times on each of the 73 instances. We use the software ‘perprof-py’ (Siqueira, da Silva & Santos, 2016) to draw the performance profiles (see Fig. 3) where the quality of the solution is measured by the average objective value and average run time. These performance profiles tend to show an advantage of GA-EAX over CLKH for solving these clustered instances with up to 24,978 vertices.

TSP solvers v.s. state-of-the-art CTSP heuristics

In “Computational Results and Comparison of Popular TSP Solvers”, we observed that the exact Concord TSP solver and the inexact CLKH and GA-EAX TSP solvers are powerful tools for solving clustered TSP instances converted from the CTSP. We now answer the following question: Do these general TSP solvers compete well with state-of-the-art CTSP heuristics specially designed for the problem?

For this purpose, we adopt GA-EAX as our representative TSP solver and compare it with three best performing CTSP heuristics in the literature: VNRDGILS (Mestria, 2018), HHGILS (Mestria, 2016), and GPR1R2 (Mestria, Ochi & de Lima Martins, 2013). Indeed, according to the experimental studies reported in Mestria, Ochi & de Lima Martins (2013) and Mestria (2016, 2018), these three heuristics perform the best among the recent CTSP heuristics available in the literature (see Table 4). This study is based on the 35 medium and large instances of Sets 1 and 2 (no results for the three CTSP heuristics are available on the large GTSP instances of Set 3).

Table 5 provides the comparative results of the GA-EAX TSP solver along with the results reported by the three CTSP algorithms on the medium and large instances. For each instance and algorithm, columns ‘f_best’, ‘f_avg’ and ‘t(s)’ show respectively the best objective value over 10 independent runs, the average objective value and the average run time in seconds. Furthermore, the row ‘Avg.’ shows the average performances for each compared algorithm, including the average percentage gap of the best/average result to the optimal result obtained with the Concorde TSP solver and the average run time in seconds. To determine whether there exists a statistically significant difference in performance between the GA-EAX TSP solver and each CTSP algorithm in terms of best and average results, the p-values from the Wilcoxon signed-rank tests are given in the last row of Table 5. Entries with “-” mean that the corresponding results are not available in the literature. The best objective values obtained by the compared algorithms are indicated in bold if they attain the optimal solution. Notice that the results of the CTSP algorithms (VNRDGILS, HHGILS and GPR1R2) correspond to 10 executions per instance on a computer with 2.83 GHz Intel Core 2 CPU and 8 GB RAM and the time limit per run was set to 720 s for medium instances and 1,080 s for large instances.

Table 6 summarizes the statistical results for each compared algorithm on the two sets of medium and large instances. The first row indicates the number of optimal solutions found by each approach. The average percentage gap of the best/average result from the optimal result is provided in row ‘Average Gap_best/Gap_avg’. Finally, row ‘Average time (s)’ provides the average run time in seconds for each algorithm.

From Tables 5 and 6, we observe that the GA-EAX solver significantly outperforms the three CTSP algorithms on the medium and large instances in terms of both the best and the average results. For the large instance set, the improvement gaps between the results of GA-EAX and those of the CTSP methods are very high, ranging from 10.39% to 15.49%. Furthermore, in terms of the average run time, GA-EAX is about 30 to 130 times faster than the CTSP algorithms. The above results thus indicate that the GA-EAX TSP solver has a strong dominance over current best performing CTSP approaches in the literature. In addition, the small p-values (<0.05) from the Wilcoxon signed-rank tests further confirm the statistically significant difference of the compared results.

To have a finer analysis of the compared algorithms, Fig. 4 provides boxplot graphs to compare the distribution and range of the average results for each compared algorithm, except GPR1R2 for the medium instances since its results on several medium instances are not available. In this figure, the average objective value f_avg of a given algorithm is normalized according to the relation y = 100 * (f_avg − f_opt)/f_opt, where f_opt is the optimal value. The plots in Fig. 4 show clear differences in the distributions of the average results between GA-EAX and each compared CTSP heuristic, which further confirms the efficiency of the GA-EAX TSP solver with respect to these dedicated CTSP heuristics.

Finally, considering the results of the Concorde solver and the CLKH solver reported in “Computational Results and Comparison of Popular TSP Solvers”, we conclude that these TSP solvers also dominate the current best CTSP algorithms in the literature.