An Adaptive Layered Clustering Framework with Improved Genetic Algorithm for Solving Large-Scale Traveling Salesman Problems

Abstract

Traveling salesman problems (TSPs) are well-known combinatorial optimization problems, and most existing algorithms are challenging for solving TSPs when their scale is large. To improve the efficiency of solving large-scale TSPs, this work presents a novel adaptive layered clustering framework with improved genetic algorithm (ALC_IGA). The primary idea behind ALC_IGA is to break down a large-scale problem into a series of small-scale problems. First, the k-means and improved genetic algorithm are used to segment the large-scale TSPs layer by layer and generate the initial solution. Then, the developed two phases simplified 2-opt algorithm is applied to further improve the quality of the initial solution. The analysis reveals that the computational complexity of the ALC_IGA is between $O(nlogn)$ and $O\left(n^2\right)$. The results of numerical experiments on various TSP instances indicate that, in most situations, the ALC_IGA surpasses the compared two-layered and three-layered algorithms in convergence speed, stability, and solution quality. Specifically, with parallelization, the ALC_IGA can solve instances with $2\times {10}^5$ nodes within 0.15 h, $1.4\times {10}^6$ nodes within 1 h, and $2\times {10}^6$ nodes in three dimensions within 1.5 h.

1. Introduction

As an important branch of optimization, combinatorial optimization plays a significant role in management and economics, computer science, artificial intelligence, biology, engineering, etc. [1]. The traveling salesman problems (TSPs) are the main subject of combinatorial optimization problems, in which the goal is to find a closed route through all the cities once, and only once. This problem is equivalent to finding a Hamilton circuit with the minimum distance. The TSP, and its variants, such as asymmetric TSPs (ATSPs) [2], clustered TSPs (CTSPs) [3], dynamic TSPs (DTSPs) [4], multiple TSPs (MTSPs) [5], and wandering salesman problems (WSPs) [6], have wide applications in laser engraving [7], integrated circuit design [8], transportation [9], energy saving [10], logistics problems [11], communication engineering [12], and medical waste transportation, which is closely related to the COVID-19 pandemic [13]. The TSP was first considered in mathematical format in 1930 to solve a school bus routing problem, and then spread by researchers of Rand corporation. However, these problems were first considered only dozens of cities, but with the increase in applications, the scale of the problems may exceed millions [14].

Although the description of TSP is simple, it has been proven as NP-Hard, which means that the time required to obtain the exact solution for TSP will increase exponentially when the size of the problem aggrandizes. Lots of algorithms have been developed for TSPs, and they can be split into four categories: exact methods, approximation algorithms, intelligence algorithms, and heuristics algorithms. The exact solver, such as brute-force search, linear programming [15], dynamic programming [16], brand and bound [17], brand and cut [18], and cutting plane [19] are powerful tools for small scale TSPs. However, the computational complexity of an exact algorithm is very huge, such that solving the instance with 85900 nodes will take over 136 CPU-years by Concorde, which is a mature exact solver for TSPs [20]. Since there is no efficient exact solution to any NP-hard problem, numerous efficient approximation solutions are presented for finding efficient approximation solutions in polynomial time complexity and with provable solution quality [21]. Although such algorithms can obtain high approximation ratio such as $1+ϵ$ for Euclidean TSPs [22] and $7/5+ϵ$ for TSPs [23], the running times of these approaches, even though asymptotically polynomial, can be rather large, see [24].

The intelligence algorithms are inspired by the nature world and have high capabilities to approximate the global optimal for optimization problems. Evolutionary algorithm (EA) [25], ant colony optimization algorithm (ACO) [26], ant colony system (ACS) [27], shuffled frog leaping algorithm (SFLA) [28], simulated annealing algorithm (SA) [29], particle swarm optimization (PSO) [30], and other well-known algorithms [31,32] all belong to intelligence algorithms. The novel intelligence algorithm can be employed to solve the problem with $2\times {10}^5$ nodes with high quality in an hour on a retail computer, but it is still hard to tackle while the scale is larger [33]. There are two main drawbacks of intelligent algorithms: one is that they frequently converge to the local optimum; the other one is that the parameters affect the solution quality deeply but usually can only be determined empirically [34]. The main heuristic algorithms for TSPs can be grouped into the Lin–Kernighan family and stem-and-cycle family; they could provide high-quality solutions for nearly 2 million cities’ problems [35]. For higher quality solutions and lower running time, some researchers combined intelligence algorithms and heuristics algorithms; see [36,37,38] and the reference therein.

Genetic algorithm (GA) was proposed by Holland in 1975, the basic idea stems from “survival of the fittest” in evolutionism. Most types of GAs contain three main segments: selection operator, crossover operator, and mutation operator. Due to the high effectiveness and versatility of GAs, they have been widely employed to solve TSPs and other challenging optimization problems [39]. However, there are still several doubts about TSPs, including premature convergence, population initialization, problem encoding, etc. [40].

On the other hand, crossover operators have a significant influence on the performance of GA and are a key factor in global searching and convergence speed. As a matter of fact, various crossover operators have been proposed for TSP, including partially mapped crossover (PMX) [41], ordered crossover (OX) [42], cycle crossover (CX) [43], sequential constructive crossover operator (SCX) [44], completely mapped crossover operators (CMX) [45], and others based on heuristic algorithms such as bidirectional heuristic crossover operator (BHX) [46]. Additionally, merging GAs with local search or heuristic algorithms will reveal both of their advantages, including high convergence speed and the capacity for global optimization; therefore, it has been a hot topic of study [36,47,48].

Although the size of TSPs are larger than ${10}^5$, seeking a high quality solution is extremely difficult, even the high powerful implementation of the Lin–Kernighan heuristic (LKH) maintained by Helsgaun [49] will take over an hour on a ${10}^5$ nodes instance, see the experiments in [33] and

Table 1. The results of LKH with single core on some large-scale TSPs.

Instance	BKS	Ascent (s)	Preprocessing (s)	LKH (s)	Total (s)	Solution
mona-lisa100K	5,757,191	2415.47	3716.53	278.46	3995.15	5,758,345
vangogh120K	6,543,609	3690.94	5690.02	307.73	5997.94	6,544,870
venus140K	6,810,665	5001.29	7918.02	354.21	8272.45	6,812,071
pareja160K	7,619,953	6469.65	10,157.78	374.95	10,533.01	7,621,538
courbet180K	7,888,731	8217.3	12,700.44	459.66	13,160.39	7,890,278
earring200K	8,171,677	10,003.84	15,290.48	513.88	15,804.67	8,173,683

. In addition, even a small improvement in quality can take a long time; the question of how to obtain an acceptable approximation solution in a reasonable time is more useful in real-world applications [50]. Thus, a new series of two-layered algorithms has been proposed, and the fundamental concepts of them can be divided into two categories. The first type of them is to use various clustering techniques to divide the cities into small groups, calculate the sub-TSPs within those groups, and then merge the groups into a Hamilton cycle [51,52,53]. The other one is to determine the start and end points for each small group after clustering firstly, and then solve the fixed start and end points of TSPs, which are also called WSPs; finally, combine all the groups [54]. These algorithms are much faster than algorithms without clustering and can solve 180 K size TSP within a few hours [7].

Naturally, two-layered algorithms can be developed to be three-layered or multiple-layered; very recent works can be seen in [55,56]. Admittedly, in order to fully utilize all the CPUs of computers, parallelizability is becoming extremely essential for algorithms designed to solve large and complicated problems. Some parallel algorithms for TSPs can be seen in [57,58].

In this paper, in order to develop a fast, easy implementation and high parallelizability algorithm for TSPs, an adaptive layered clustering framework with improved genetic algorithms (ALC_IGA) is supposed. This algorithm is not only an improvement of GA, but also an extension of the two-layered and three-layered methods in the references [7,51,55] for TSPs. The key contributions of this study are as follows:

• An improved genetic algorithm (IGA) integrated with hybrid selection, a selective BHX crossover operator, and simplified 2-opt local search has been proposed; a numerical comparison of IGA, GA, and ACS on TSPs shows the high performance of IGA.
• Plentiful numerical results also prove the effectiveness of the novel IGA for solving the WSPs.
• An adaptive layered clustering framework is proposed to break down a large-scale problem into a series of small-scale problems. The computational complexity of the ALC_IGA is between $O(nlogn)$ and $O\left(n^2\right)$; moreover, the parallelability of it has been discussed.
• We show a numerical experiment for parameters tuning of the proposed ALC_IGA; the results reveal that the larger the parameter set, the higher the solution quality that is obtained, but a longer time is required.
• Dozens of two-dimensional Euclidean instances have been tested with ALC_IGA and some two-layered algorithms, and the results show that ALC_IGA has advantages in terms of accuracy, stability and convergence speed over the two-layered algorithms proposed by [7,51].
• Lots of large-scale instances ranging in size from $4\times {10}^4$ to $2\times {10}^5$ have been tested, and the results show that the parallel ALC_IGA is more than four times faster than the other three compared algorithms, and obtains the best solution in the most cases. The results on very large-scale TSPs, with sizes ranging from $2\times {10}^5$ to $2\times {10}^6$, also demonstrate the excellent effectiveness of ALC_IGA.

The remainder of the paper is organized as follows: a brief literature review of some related concepts is presented in Section 2; the main procedures of IGA are shown in Section 3; the details ALC_IGA are discussed in Section 4; the results of experimental analyses and algorithms comparisons are shown in Section 5; A summary of this paper and future works are listed in Section 6.

2. Some GAs and Layered-Based Algorithms for TSPs

Numerous algorithms have been introduced for the TSPs, the well-known and typical combinatorial optimization problem. The four primary kinds are heuristic algorithms, approximation algorithms, intelligent algorithms, and exact algorithms. Considering exact algorithms cannot be used for middle-scale TSPs, which is NP-Hard, the intelligence algorithms and heuristic algorithms have been the focus of attention. However, for large-scale TSPs, the classical intelligence algorithms lose efficacy. The two primary methods for large-scale TSPs by intelligence algorithms are improving intelligence algorithms and partitioning the large-scale problems into smaller ones by clustering. In this section, the well-known GA is explored, and several approaches based on clustering for large-scale TSPs are briefly reviewed.

2.1. GAs for TSPs

GA is one of the intelligence algorithms that is widely applied to solve both continuous and discrete optimization problems. Grefenstette et al. [59] studied GA for TSPs in detail in 1988 and provided various proposals for further work, including merging GA with other heuristic algorithms and considering the impact of parameters. In the over 40 years that have passed ever since, the GA for TSPs has tremendous advancements in terms of representation, population initialization, fitness function, selection, crossover, mutation, and integrated with other algorithms.

First, when using GA, the primary task is to find a representation that closely relates to the structure of the problem. There are five different representations of TSPs: binary, path, adjacency, ordinal, and matrix. Larranaga et al. [60] reviewed representations and operators for TSPs. They concluded that the path representation performs well under most circumstances, and lots of powerful substantial crossover and mutation operators have been developed for it.

The crossover operator plays an important role in GA. A proper crossover operator could raise the average quality of the population, which would accelerate the convergence and save time. The most popular PMX was first proposed by Goldberg and Lingle in 1985 [41], in which each offspring only uses information from each of their parents partially. Firstly, two random cut points are generated, and then the portions from the parents between the two cut points are swapped to generate offspring. Then, the other portions are complemented in order from the original parents. Iqbal et al. [45] presented a new CMX in 2020, which differs from prior mapping crossover operators in that it uses cycle-based cut selections at the parental genes rather than random cuts. The numerical research suggests that the new CMX outperforms well-known crossover operators such as and PMX in middle-scale instances. In 2022, Zhang et al. [46] proposed a genetic algorithm with jumping gene and heuristic operators for TSPs, where the heuristic operators include 2-opt and BHX. The key distinction between the BHX and Grefenstette’s heuristic algorithm is that the BHX always chooses the candidate that is closest to the present city out of the four possible candidates. According to the numerical study, the new algorithm converges far more speedily than the CMX and other latest crossover operators.

On the other hand, because the strengths of heuristic algorithms have been shown in TSPs, numerous studies have attempted to use heuristic algorithms as crossover operators for GA. Grefenstette created a probability distribution in 1987 by using the distances between the chosen city and its four nearby neighbors [61]. They then chose the next visited city at random from this distribution until all cities were visited. Ulder et al. [62] presented a genetic local search framework in 1990, which could be combined with 2-opt, Lin–Kernighan neighborhoods, or any other heuristic algorithms. They concluded that although the new algorithms are superior to the simulated annealing and threshold accepting algorithm, combining the elements of these strategies is possible to obtain better performance.

Tsai et al. [63] proposed a genetic algorithm with a neighbor-join operator in 2002, and numerical experiments suggest that the new neighbor-join operator has lower error rates than the 2-opt and swap operator combined with GA in all compared instances, and is nearly as efficient as 2-opt. In 2014, Wang [36] constructed a hybrid genetic algorithm for TSPs that combined two local optimization strategies. The computation results demonstrate that the hybrid genetic algorithm can achieve higher accuracy than the GA in a reasonable amount of time. However, this method is also sensitive to parameter settings. A list-based simulated annealing algorithm combined with tour construction algorithms and enhancement algorithms was developed as a hybrid genetic algorithm by Ilin et al. in 2022 [29]. The tour is built using the nearest insertion algorithm, the cheapest insertion method, and the other two techniques, and a 2-opt local search is used to improve the tour.

Remark 1.

Based on the results in [64], we note that the GA-based approach seems to be clearly inferior to the local search approaches. Despite this, as a basic intelligent algorithm, research on GA is still meaningful and attracts a lot of attention, as seen in the references mentioned therein.

2.2. Layered-Based Algorithms for TSPs

Even though intelligence algorithms are becoming more sophisticated, they can only solve a TSP with $2\times {10}^5$ nodes in 1 h by using fast C++ programming and parallel techniques [33]. Because the small-scale TSPs can be solved efficiently and precisely, some researchers attempt to cluster the large-scale TSPs into a succession of small-scale TSPs. In this subsection, we give a summary of the advancements produced to the clustering-based (layered-based) algorithms.

As far as is known, Ding et al. [51] may be the first to employ the well-known k-means clustering algorithm for TSPs. The k-means algorithm is used to partition the large-scale cities into several small clusters, and a two-level GA is used to generate the final tour. The low-level GA is used to find the shortest Hamilton cycle inside each cluster, and the high-level GA is utilized to determine the in and out nodes of each cluster. The numerical experiment illustrates that the new algorithm handled the 1000 cities instance in 66 s on Matlab, which is substantially faster than the classical genetic algorithm. Due to the uneven distribution of cities, the scales of clusters produced by k-means may still be quite large, leading the low-layer computation to take a long time.

In 2009, Yang et al. [54] introduced an adaptive clustering method to reduce the computational complexity of the sub-clusters. It checks whether each cluster is smaller than the specified size after k-means and if so, repeats k-means until all clusters are smaller. Then, a GA is used to find the visited order of the clusters based on the coordinates of the clusters’ centers. Finally, the clusters are connected using the nearest nodes between the adjacent traveled clusters. The numerical experiment shows that the adaptive clustering method can solve an instance with 85,900 cities in 1 h. Although Yang’s algorithm ensures that the low layer is solved quickly, there may be too many clusters produced, resulting in slow computation of the high level.

The influences of different clustering and intelligence algorithms combined for layered algorithms were first investigated by Phienthrakul [65] in 2014. He developed a greedy cluster connection procedure and then analyzed the influence of GA and ACO based on k-means and Gaussian mixer models. The numerical results show that the four algorithms have only minor differences in accuracy and execution time and can be efficiently applied to large-scale TSPs.

Although the notion of using a clustering method to solve large-scale TSPs has developed and grown, the work mentioned above does not verify the algorithms’ efficacy for TSPs with more than ${10}^5$ nodes. Wu et al. [7] investigated large-scale laser engraving in 2020, which is a widely used technology in modern production and can be represented as a TSP. They suggested a new two-layered ant colony system algorithm (TLACS) based on k-means, in which the ACS optimizes the visited order of clusters, and the start point and the end point for each cluster are determined. After the start point and the end point of each cluster have been determined, the local traveling path of each cluster can be depicted as a WSP. The ACS will then be used to find the shortest route of each groups. Finally, all groups are connected by the order and entrance and exit nodes, and the global path is determined. The numerical experiment shows that the TLACS can solve the large-scale TSPs with $2\times {10}^5$ nodes in approximately 1 h.

Naturally, based on clustering algorithms, the two-layered method could be expanded to a three-layered method. This concept was realized recently by Liang et al. [55]. Firstly, they applied k-medoids algorithm to divide the large-scale instance into some medium-scale groups, and then applied k-medoids algorithm for all medium-scale groups again to divide them into small-scale groups. The authors then proposed a three-layered evolutionary optimization framework comprised of two GAs and a parallel multifactorial evolutionary algorithm (3L-MFEA-MP). Their results show that three-layered algorithms have two main advantages over two-layered algorithms. One is speeding up the computation, whereas the other is that the three-layered algorithms reduce path length by almost 30% on four large-scale instances.

As can be seen, the global tour generated by the two-layered or three-layered algorithms is rough and unrefined, so a further optimization phase is necessary. In 2018, Liao and Liu [66] first applied the k-opt algorithm to optimize the tour generated by the hierarchical hybrid algorithm, which is a method proposed by them based on ACO and density peaks clustering algorithms. Although their results demonstrate that k-opt will significantly improve the performance of the hierarchical hybrid algorithm, the numerical experiments only test on the medium-scale instances on no more than 3038 cities. We remark that the computational complexity of k-opt is usually not affordable [67], so the direct application to complex issues is not feasible.

3. IGA for TSPs and WSPs

The GA is a popular optimization algorithm and is frequently applied to TSPs. As the main idea of the adaptive layered clustering framework is to break down a large-scale problem into a series of small-scale problems, GA is suitable for these sub-tasks. However, the poor convergence speed and accuracy of the traditional GAs will increase the total time consumption of the new framework. In this section, a novel IGA is introduced to fast and precisely solve small-scale TSPs and WSPs with the following key modifications: a hybrid selection algorithm is introduced; a selective bidirectional heuristic crossover is adopted to speed up the convergence; a hybrid mutation operator is suggested to jump the local optimal; and a simplified 2-opt is used to balance the convergence speed and global searching capability.

3.1. Path Encoding and Population Initialization

Path encoding is the fundamental task involved in using GA. Due to the conclusion in [60], one of the most intuitive and high-performance route encoding methods for TSPs is path representation. In path representation, all cities are encoded as unique integers and arranged into a chromosome. The position in the chromosome indicates the visited order of the city, that is, for $i,j=1,2,\cdots ,n$, if city i is the j-th element in a chromosome, then city i is the j-th to be traveled. The initial population will impact both the rate of convergence and the capacity of global searching for GA. In this study, the initial population is generated randomly, and then a 2-opt local search is applied to improve the quality of the initial population.

3.2. Fitness Function and Selection Operator

The role of the selection operator is to choose some eligible chromosomes for the next generation; a decent selection operator will help to converge rapidly and prevent local optimal, but a poor one will not. Because the objective values of TSPs are not stable, a proper transformation for the objective values is required, which is called the fitness function [46].

Assuming there are N individuals in the population, $C_i$ is the i individual, $L\left(C_i\right)$ represents the tour length of $C_i$, and $f\left(C_i\right)$ denotes the fitness value of $C_i$. Some well-known fitness functions are as follows:

• Reciprocal-based fitness function is one of the most used fitness functions; it is the reciprocal of objective function value:

  $$f\left(C_i\right)=1/L\left(C_i\right).$$
• A linear order-based fitness function that sorts individuals in ascending order by objective function values, where $R\left(C_i\right)$ denotes the order of $C_i$. Then, $f\left(C_i\right)$ presented by:

  $$f\left(C_i\right)=\frac{N-R\left(C_i\right)}{N}.$$
• Nonlinear order-based fitness function also sorts the individuals, but $f\left(C_i\right)$ is defined by:

  $$f\left(C_i\right)=\alpha {(1-\alpha )}^{R\left(C_i\right)-1},$$

  where $\alpha$ is a constant in $[0.01,0.3].$

Some deserving individuals will be picked for the following generation once all the fitness values of individuals have been evaluated. Once all fitness values of individuals have been confirmed, some good individuals will be selected for the next generation. The most common selection method is roulette wheel selection. If M individuals must be chosen for the next generation, see the detailed steps in Algorithm 1.

Algorithm 1 Roulette wheel selection.

Input: A set of N individuals, the number of selected requirements M, current iteration number of GA $Iter$. Output: A set of M selected individuals. 1: for $Iter$ = 1 To M do 2:    Calculate the selection probability of $C_i$: $$p\left(C_i\right)=\frac{f\left(C_i\right)}{{\sum }_{j=1}^{2N}f\left(C_j\right)}.$$ 3:    Generate a random number P between 0 and 1. 4:    Select the first $C_j$ satisfied $P\le {\sum }_{h=1}^{j}p\left(C_h\right)$. 5:    Remove $C_j$ from the population. 6: end for

The pseudo-code of the proposed hybrid selection algorithm is shown in Algorithm 2.

Algorithm 2 Hybrid selection algorithm.

Input: A set of N individuals, the number of selected requirements M, current iteration number of GA $Iter$. Initialize parameters: $\alpha =0.15$, and $r_1$, $r_2$ are two random numbers. Output: A set of M selected individuals. 1: Calculate the objective value for each individuals. 2: if  $r_1\ge 1/Iter$  then 3:    if $rand\ge r_2$ then 4:      Calculate fitness values by nonlinear order-based fitness function. 5:    else 6:      Calculate fitness values by linear order-based fitness function. 7:    end if 8:    Select M individuals by roulette wheel selection. 9: else 10:    Calculate fitness values by reciprocal-based fitness values. 11:    Select M individuals according to the smallest fitness values. 12: end if

3.3. Selective Bidirectional Heuristic Crossover

The crossover operation is the primary role of GA in producing new offspring. As stated in Section 2.1, there are numerous crossover operators proposed for path representation. Recently, Zhang et al. [46] presented a novel BHX, and the numerical results show its excellent effectiveness in enhancing the quality of the offspring.

The drawback of the BHX is that two parents will only have one unique offspring, which will reduce the size of the population gradually. Hence, a method of enriching the population must be developed to use BHX. It is known that monogamy is not the only type of mating system in nature; polygynandry is another prevalent mating system in species that live in troupes. An individual can mate with several individuals, and the number of mates is governed by individual quality. Inspired by the polygynandry mating system, a selective bidirectional heuristic crossover (SBHX) has been developed, in which the good gene of a parent may be preserved for two or more offspring.

Algorithm 3 depicts the main steps of SBHX.

Algorithm 3 Selective bidirectional heuristic crossover.

Input: A set of N individuals, the number of selected offspring M, current iteration number $Iter$. Output: A set of M selected individuals. 1: Calculate the reciprocal-based fitness $f\left(C_i\right)$ of each individual $C_i$. 2: for $Iter$ = 1 to $M/2$ do 3:    Apply Algorithm 1 to select two individuals $C_1$ and $C_2$. 4:    The start and end points are connected in $C_1$ and $C_2$, and then each chromosome becomes a ring. Let $O_1$ and $O_2$ represent the two rings. 5:    Randomly generate a start city s between 1 and n, and a blank offspring $C_{next}$. 6:    while $C_{next}$ is not filled up do 7:      Starting from s in $O_1$, searching for the first city $O_1^r$ that $C_{next}$ has not yet visited on the right, and $O_1^l$ on the left. 8:      Similarly to the last operation, remark the two cities as $O_2^r$ and $O_2^l$. 9:      Compute the distance between s and the four feasible cities. 10:    Choose the nearest city to s and replace s as the selected city. 11:    end while 12: end for

3.4. Mutation Operator

The mutation operator is another important phase of GA. Similar to how genetic mutations never stop happening and are essential to biodiversity, the mutation operator also enriches population diversity, which prevents the GA from falling into a local optimal. Lots of swap, inversion, and heuristic mutation operators have been applied in GA for TSPs; see [36,46]. Suppose that there are n cities in the i-th individual $C_i$; to employ the swap or inversion mutation operator, two integers $p_1$ and $p_2$ between $[1,n]$ will be generated first. In the swap operator, the two cities $C_i^{p_1}$ and $C_i^{p_2}$ are exchanged. In the inversion operator, the gene fragmentation between $p_1$ and $p_2$ is reversed.

As the heuristic mutation operators usually have high computational complexity, a hybrid mutation operator combined with a swap mutation operator and inversion mutation operator is proposed in this paper. Firstly, a mutation probability is set by hand, and then if individual $C_i$ has a chance to be mutated, the probability will control which mutation operator will be selected. The pseudo-code of the new mutation operator is shown in Algorithm 4.

Algorithm 4 Hybrid mutation operator.

Input: A population of N individuals. Initialize parameters: The probability p of mutation, the probabilities $r_1$ and $r_2$ to select of mutation operator, $r_1\ge r_2$. Output: The population after mutation. 1: for $C_i$ in population do 2:    if $rand<p$ then 3:      Randomly generated $q\in [0,1]$. 4:      if $q>r_1$ then 5:         The swap mutation operator is used for $C_i$. 6:      else if $q>r_2$ then 7:         The inversion mutation operator is used for $C_i$. 8:      else 9:         Continue. 10:      end if 11:   end if 12: end for

3.5. Simplified 2-Opt Local Optimization

k-opt is a well-known class of local optimization algorithms; here, k is an integer greater than 1. The first proposed and simplest algorithm of them is 2-opt, which was developed by Croes [68] for solving TSPs in 1958. Although k-opt have better quality than 2-opt when $k>2$, they involve high computational complexity. The 2-opt local optimization applied in GA can improve the quality of the current population and speed up the convergence under suitable parameters set. However, since BHX and 2-opt are heuristic algorithms with drawbacks in searching the global optimal, combining them will almost certainly result in premature convergence. In the proposed improved genetic algorithm, a simplified 2-opt (S_2-opt) is developed to enhance the quality of individuals after mutation. The pseudo-code of the S_2-opt for GA is shown in Algorithm 5. The simplified 2-opt operator has a simple iterative structure, and only one parameter must be set. It can avoid the local optimal by setting T to a small value or achieve a fast convergence speed by setting T to large.

Algorithm 5 Simplified 2-opt for GA.

Input: A population of N individuals. Initialize parameters: Max iteration T for simplified 2-opt, the number n of cities in each individual. Output: The optimized population. 1: for $C_i$ in population do 2:    for h = 1 to T do 3:      Calculate the tour distance $d_1$ of $C_i$. 4:      Randomly generated $p_1$ and $p_2$ in $[1,n]$. 5:      Inverse the gene fragment between $p_1$ and $p_2$, set as $C_{new}$. 6:      Compute the tour length $d_2$ of $C_{new}$. 7:      if $d_1>d_2$ then 8:         Replace $C_i$ by $C_{new}$. 9:      end if 10:    end for 11: end for

The main flow of the IGA can be seen in Figure 1; the stop condition of IGA is set as no improvement of solution in specified iterations. Since the WSP is a TSP with fixed start and end nodes, it can be solved as a TSP by setting the distance between the start node and the end node to $-M$, where M is a large positive number [6]. With the help of this feature, the proposed IGA can also be employed to solve WSPs.

4. The Framework of ALC_IGA for Large-Scale TSPs

In recent years, some two-layered algorithms have been proposed, and they significantly reduce the time expenditure for large-scale TSPs [7,51]. Liang et al. [55] recently proposed a three-layered algorithm with k-means and indicated that it outperforms some two-layered algorithms by numerical experiments. Notwithstanding, both two-layered and three-layered algorithms may still have medium-scale or large-scale groups. Naturally, this will require a significant amount of time to solve the underlying problems. Thus, upgrading the two-layered and three-layered algorithms to the adaptive layered algorithm stands to reason.

We propose a brand new framework for adaptive layered clustering that takes into account the IGA created in the previous section. The framework is divided into two parts: the first is applying clustering and IGA to initialize the solution, and the second is optimizing the initial solution. Based on our new algorithm, the large-scale TSPs can be transformed into solving some TSPs and WSPs that are smaller than the specified size. The processing flows are illustrated in Figure 2, and the details of solution initialization and optimization are represented subsequently in Section 4.1 and Section 4.2.

4.1. Solution Initialization

In the solution initialization phase, we combine the adaptive layered clustering and IGA. For each cluster that is larger than the specified size, k-means will be applied to divide the problem into some small clusters and then determine the number of layers, visit order, entry cities, and exit cities of the sub-clusters. When the size of a cluster is smaller than the specified size, IGA is used to determine the Hamiltonian path from the entry node to the exit node within the cluster. When the size of a cluster is larger than the specified size, k-means is used again to split the cluster. These processes are repeated until the paths of all clusters are determined. Then, combining all sub-paths, and we obtain the initial feasible path.

The procedure of main steps of the solution initialization phase is illustrated in Figure 2. Its pseudo-code is given in Algorithm 6.

Algorithm 6 Solution initialization framework.

Input: A TSP problem G, the size N of G, the nodes are designated by $c_1,c_2,\cdots ,c_N$, a positive integer M, and denote the size of $G_i$ by $S\left(G_i\right)$. Output: The initial solution $R\left(G\right)$ for TSP G. 1: if  $S\left(G\right)\le M$  then 2:    Apply IGA to solve G, and output the solution $R\left(G\right)$. 3: else 4:    Divide the problem G into $k_1$ clusters by k-means. 5:    Denote the groups by $\{G_1,G_2,\cdots ,G_{k_1}\}$, the coordinate vectors of centers are $\{V\left(G_1\right),V\left(G_2\right),\cdots ,V\left(G_{k_1}\right)\}$, the sizes of groups marked as $\{S\left(G_1\right),S\left(G_2\right),\cdots ,S\left(G_{k_1}\right)\}$. 6:    if $max\{S\left(G_1\right),S\left(G_2\right),\cdots ,S\left(G_{k_1}\right)\}\le M$ then 7:      Set $D_{ij}$ as ${min}_{k,h}d(c_{ik},c_{jh})$, where $c_{ik}\in G_i$, $c_{jh}\in G_h$, $k\in \{1,2,\cdots ,S\left(G_i\right)\}$, $j\in \{1,2,\cdots ,S\left(G_h\right)\}$. 8:      Use IGA to solve the distance matrix M and record the visited order $\{O\left(G_1\right),O\left(G_2\right),\cdots ,O\left(G_{k_1}\right)\}$. 9:    else 10:      Obtain the visited order $\{O\left(G_1\right),O\left(G_2\right),\cdots ,O\left(G_{k_1}\right)\}$ by IGA for solving $\{V\left(G_1\right),V\left(G_2\right),\cdots ,V\left(G_{k_1}\right)\}$. 11:    end if 12:    for $G_i$ in $\{G_1,G_2,\cdots ,G_{k_1}\}$ do 13:      Find the last visit group $G_h$ and the next visit group $G_j$. 14:      Set $G_i^{entry}$ as the nearest city in $G_i$ to $G_h$, and set $G_i^{exit}$ as the nearest city to $G_j$. 15:      if $G_i^{entry}$ = $G_i^{exit}$ then 16:         Set $G_i^{exit}$ as the second nearest city to $G_j$. 17:      end if 18:    end for 19:    while some groups are unsolved do 20:      for $G_i$ in $\{G_1,G_2,\cdots \}$ do 21:         if $G_i$ is unsolved then 22:           if $S\left(G_i\right)\le M$ then 23:              Apply IGA to obtain the shortest route from $G_i^{entry}$ to $G_i^{exit}$. 24:           else 25:              Divide the $G_i$ into $k_{ih}$ clusters by k-means. 26:              Denote the groups by $\{G_{i1},G_{i2},\cdots ,G_{i{k}_{ih}}\}$, the coordinate vectors of centers are $\{V\left(G_{i1}\right),V\left(G_{i2}\right),\cdots ,V\left(G_{i{k}_{ih}}\right)\}$, the sizes of groups marked as $\{S\left(G_{i1}\right),S\left(G_{i2}\right),\cdots ,S\left(G_{i{k}_{ih}}\right)\}$. 27:              Find the visited order $\{O\left(G_{i1}\right),O\left(G_{i2}\right),\cdots ,O\left(G_{i{k}_{ih}}\right)\}$ by the same method in lines 6–11. 28:              Set the entry and exit cities of each groups by the same method mentioned in lines 12–18. 29:           end if 30:         end if 31:      end for 32:    end while 33:    Organize the visit orders, entry cities, exit cities, and the internal route of each cluster, and output the initial feasible path $R\left(G\right)$. 34: end if

Remark 2.

We point out that there are many different clustering techniques, which makes it hard to select the ideal clustering strategy for TSPs. The results in [64] indicate that the simple grid-based methods are better than the k-means methods. Because the numerical experiments are only focused on one particular instance, we still use the standard k-means as models.

An example of a 100-cities TSP and M set to 20 is shown in Figure 3. In the first layer, the cities have been divided into two groups $G_1,G_2$ by k-means, and the visit order found by IGA is $O\left(G_1\right)=1$ and $O\left(G_2\right)=2$. On the one hand, since the size of $G_2$ equals M, the visit route $P\left(G_2\right)$ of the 20 cities in $G_2$ could be solved by IGA quickly. On the other hand, because there are 80 cities in $G_1$, that is larger than M, so $G_1$ needs to be divided into small groups again. Repeat the procedures are until all of the group sizes are less than M, resulting in six groups and four layers being determined during the solution initialization phase. To combine the six routes, first, from the bottom layer, connect $P\left(G_{1311}\right)$ with $P\left(G_{1312}\right)$ sequentially, and obtain $P\left(G_{131}\right)=\{P\left(G_{1311}\right),P\left(G_{1312}\right)\}$. Then, in the third layer, connect $P\left(G_{131}\right)$ with $P\left(G_{132}\right)$, then $P\left(G_{13}\right)=\{P\left(G_{131}\right),P\left(G_{132}\right)\}$. Following these steps, the path for the 100-cities TSP is eventually $\{P\left(G_{1311}\right),P\left(G_{1312}\right),P\left(G_{132}\right),P\left(G_{11}\right),P\left(G_{12}\right),P\left(G_2\right)\}$.

4.2. Two Phases 2-Opt for Solution Optimization

Because of the clustering algorithm used, the solution obtained in the solution initialization stage is a little rough and can be continue to be optimized. In [66], Liao and Liu first applied the 2-opt and 3-opt operators to optimize the initial route with the clustering algorithm involved, and the numerical studies show a marked improvement when k-opt is used. Nevertheless, when the number of cities in the problem is exceptionally enormous, the k-opt struggles to work.

To improve the quality of the initial solution in an affordable time, a two-phase simplified 2-opt algorithm (TS_2-opt) is given in Algorithm 7. The TS_2-opt is aimed to optimize the routes and orders of all the groups which belong to a cluster at a higher layer. Once the solution is initialized, TS_2-opt is used to optimize the route of each group in the penultimate layer and repeated layer by layer until the top layer is optimized. Depicted in Figure 3, the green lines show the workflow of solution optimization. Firstly, from the bottom layer, the routes $P\left(G_{1311}\right)$ and $P\left(G_{1312}\right)$ are combined by TS_2-opt to the local optimal routes $P{\left(G_{131}\right)}^{opt}$. Then, the two routes in the third layer also are optimized to $P{\left(G_{13}\right)}^{opt}$ by using TS_2-opt. Follow these steps until the final solution $P{\left(G\right)}^{opt}$ is obtained.

Algorithm 7 Two-phase simplified 2-opt algorithm.

Input: A batch of groups $\{G_{i\cdots j1},G_{i\cdots j2},\cdots ,G_{i\cdots jh}\}$, suppose the order of them is $1,2,\cdots ,h$, and the travel routes of them $\{P\left(G_{i\cdots j1}\right),P\left(G_{i\cdots j2}\right),\cdots ,P\left(G_{i\cdots jh}\right)\}$. Initialize parameters: The first phase max iteration $L_1$; the second phase max iteration $L_2$; the length selected for optimization R. Output: An optimized route $P\left(G_{i\cdots j}\right)$ for $G_{i\cdots j}$. 1: Compute the distance $d_{bks}$ of the tour $\{P\left(G_{i\cdots j1}\right),P\left(G_{i\cdots j2}\right),\cdots ,P\left(G_{i\cdots jh}\right)\}$. 2: for $ite{r}_1$ = 1 to $L_1$ do 3:    Randomly generated two different integers $p_1$, $p_2$ between $[2,h-1]$. 4:    Denote the route between $G_{i\cdots j{p}_1}$ and $G_{i\cdots j{p}_2}$ as $P_{p_1}^{p_2}$; denote the route between $G_{i\cdots j1}$ and $G_{i\cdots j{p}_1-1}$ as $P_1^{p_1-1}$; denote the route between $G_{i\cdots j{p}_2}$ and $G_{i\cdots jh}$ as $P_{p_2+1}^h$. 5:    Inverse $P_{p_1}^{p_2}$, denote the new route as $Inv\left(P_{p_1}^{p_2}\right)$. 6:    Generate two routes $P_1$ and $P_2$, where $P_1$ is combined by the last R elements of $P_1^{p_1-1}$ and the first R elements of $Inv\left(P_{p_1}^{p_2}\right)$; $P_2$ is combined by the last R elements of $Inv\left(P_{p_1}^{p_2}\right)$ and the first R elements of $P_{p_2+1}^h$. Denote the new order of groups as $\{O\left(G_{i\cdots j1}\right),O\left(G_{i\cdots j2}\right),\cdots ,O\left(G_{i\cdots jh}\right)\}$, the sizes of groups is noted as $\{S\left(G_{i\cdots j1}\right),S\left(G_{i\cdots j2}\right),\cdots ,S\left(G_{i\cdots jh}\right)\}$. 7:    The Algorithm 5 with max iteration number $L_2$ is applied to optimize $P_1$ and $P_2$. Denote the new routes as $P_1^{opt}$ and $P_2^{opt}$. 8:    Replace $P_1$ and $P_2$ in $\{P_1^{p_1-1},Inv\left(P_{p_1}^{p_2}\right),P_{p_2+1}^h\}$ with $P_1^{opt}$ and $P_2^{opt}$, respectively. Denote the new route as $P_{opt}$. 9:    Compute the distance $d_{opt}$ of $P_{opt}$. 10:    if $d_{bks}>d_{opt}$ then 11:      Assign $d_{opt}$ to $d_{bks}$. 12:      Divide $P_{opt}$ into h segments $\{P_{m_1},P_{m_2},\cdots ,P_{m_h}\}$, here $S\left(P_{m_k}\right)$ is equal to $\left\{S\left(G_{i\cdots jr}\right)\right|r=m_k\}$. 13:    end if 14:    Replace $\{P\left(G_{i\cdots j1}\right),P\left(G_{i\cdots j2}\right),\cdots ,P\left(G_{i\cdots jh}\right)\}$ by $\{P_{m_1},P_{m_2},\cdots ,P_{m_h}\}$. 15: end for 16: Output $R=P_{opt}$.

Suppose there are three groups $\{G_{11},G_{12},G_{13}\}$ belonging to the same higher group $G_1$, and the visit orders of them are $\{2,3,1\}$, respectively. Figure 4 illustrates the major processing of TS_2-opt in detail. Each cluster is represented by a different color, whereas the start and end locations are marked by larger shapes. In Step 1 of Figure 4, the three routes are arranged by order and assume the $G_{11}$ is chosen, then the path of $G_{11}$ is inverted. In Step 2, the segments at the junctions of the clusters are determined according to R, where R equals 5 for simplicity. The next step is to optimize the two segments provided by Step 2. In Step 4, three new routes are generated according to Step 3 and the input routes. Once all four steps have been completed, return to Step 1 until the termination condition is met.

We note that the purpose of the TS_2-opt is not to reach the global optimal, but rather to optimize the visit orders and junctions between groups that belong to the same group at the higher layer. Despite sacrificing some precision, the computation speed of TS_2-opt is very fast, which is critical in large-scale TSPs.

4.3. Parallelizability and Computational Complexity Analysis

We show the highly parallelizable capability of the proposed ALC_IGA. In the phase of solution initialization, the operations for clusters are independent in each layer; the operations of subgroups that do not belong to the same cluster in different layers are also independent. As an illustration, there are three tasks in the third layer shown in Figure 3; find the visit route for $G_{11}$ and $G_{12}$, and apply k-means to divide $G_{13}$ into small groups. As they are stand-alone, if there are three or more cores of the CPU, they can be computed on different cores simultaneously. Furthermore, if k-means is faster than the other two tasks, then the computations of $G_{131}$ and $G_{132}$ in the next layer can also be allocated to the free cores even if $P\left(G_{11}\right)$ and $P\left(G_{12}\right)$ are still being calculated.

In the second phase of ALC_IGA, solution optimization also can be parallelized, but the parallel effectiveness is not as high as in the first phase. Firstly, the complex calculation in solution optimization is only the optimization of the junctions, but there are only two junctions in each iteration, so parallel computing is unnecessary. Secondly, the optimization of the solution starts from the bottom and ends at the top layer, but the higher-layer optimizations must wait for lower-layer optimizations to finish. In the example shown in Figure 3, there is only one task in the fourth layer, which is connecting $G_{1311}$ and $G_{1312}$. Because the route of $G_{131}$ is not determined before the computation of the fourth layer is finished, the free cores can not be used to combine $G_{131}$ and $G_{132}$ in the third layer.

Notwithstanding, parallel techniques can be used in each layer to speed up computation while the scale of the problem is very large. The computational complexity of the major stages of the proposed ALC_IGA is presented in the remainder of this subsection.

We recall that the time complexity of k-means is known as $O\left(NKID\right)$, where N is the number of points, K is the number of clusters, I is the specified max iterations, and D is the number of dimensions. For the sake of simplicity, we assume that there are n nodes in the TSP, and m and k are two positive integers, $T_1$ is the max run time of the IGA for solving m-nodes TSP, I and D are fixed. After that, we look at the time complexity in two parts.

In the best-case scenario, we assume that $n=m^k$, and each use of clustering divides the cluster into m sub-clusters, where the number of nodes of each sub-cluster is equal. Firstly, in the second layer, the IGA well is used once to obtain the visited cluster order, and in the third layer, it is m times. We deduce that the total times of IGA are $1+m+m^2+\cdots +m^{k-1}$, and by $n=m^k$ we have $\frac{n-1}{m-1}$, then the upper bound of the total time of IGA is $\frac{n-1}{m-1}{T}_1$, which is $O\left(n\right)$. Secondly, in the top layer, the time complexity of k-means is $O\left(nm\right)$; in the second layer, the time complexity of k-means is $O\left(\frac{n}{m}m\right)m$, which is $O\left(nm\right)$. Subsequently, we can infer that the time complexity of each layer is always $O\left(nm\right)$. Note that when there are $k={log}_{m}n$ layers, then the total time complexity of ALC_IGA is $O\left(mn{log}_{m}n\right)$, and since the m is a given constant, the time complexity of ALC_IGA is $O(nlogn)$.

In the worst case, each cluster ends up with $m-1$ groups that contain a single city and a single group that contains all the other cities. It can be seen that in this condition, the numbers of k-means and IGA are both far more than the best scenario. Suppose $n=k(m-1)+m$, then there will be k times clustering and $k+1$ times IGA. The time of IGA applied is no more than $(k+1)T_1$, it is $O\left(n\right)$. Similar to the best-case analysis, the computational complexity of clustering in the worst condition is $O\left(mn\right)+O\left(m\right(n-(m-1)\left)\right)+\cdots +O\left(m\right(n-(k-1)(m-1)\left)\right)$; by some calculation, we obtain that the time complexity of the k-means used is $O\left(n^2\right)$. Accordingly, the computational complexity of ALC_IGA in the worst condition is $O\left(n^2\right)$.

In summary, the computational complexity of the ALC_IGA ranges from $O(nlogn)$ to $O\left(n^2\right)$. The computational complexity of ALC_IGA is closer to $O(nlogn)$, however, in the majority of cases. This is supported by the numerical experiments presented in Section 5.

Remark 3.

Comparing with the algorithms in [7,51,55], we note briefly that ALC_IGA exhibits several innovations and advantages as follows:

• As a tool for solving sub-TSPs, IGA has been improved in some aspects based on existing techniques, and has shown significant improvements compared to GA [51] and ACS [7] on small-scale TSP problems; see the experiments in Section 5.
• ALC_IGA only requires attention to one parameter: the maximum number of clusters for k-means. This simplicity is more convenient than that of two- or three-layered algorithms and is crucial for solving large-scale TSPs.
• Based on the characteristics of layered-clustering computation, we have proposed a fast fine-tuning algorithm; this step has not been introduced in [7,51,55].
• By applying adaptive layered clustering, we are able to analyze the time complexity of ALC_IGA, which is still challenging to in the case of two or three-layered algorithms.

5. Numerical Results and Discussions

Four-part numerical experiments are presented in this paper to illustrate the effectiveness of ALC_IGA. First, Section 5.4 shows that IGA is substantially superior to GA and ACS in terms of accuracy and convergence speed. The implications of the primary parameter setting performance on ACL_IGA are examined in the second part. The third part proves the superiority of ALC_IGA on middle-scale benchmark datasets over two two-layered algorithms from the literature. The last part proves the excellent performance and parallelizability of the proposed ALC_IGA in comparison to some representative algorithms.

5.1. Experimental Setting

In this study, all experiments were computed on a Dell PowerEdge R620 with two Intel Xeon E5-2680V2 10-core processors and 64.0 GB of 1066 MHz DDR3 memory under Windows 10 OS. The speed of all cores is locked to 2.80 GHz without turbo boost technology and disabled hyperthreading to ensure the fairness and stability of the numerical experiments. All the programs are edited and run on MATLAB R2020a, the used parallel technique is the parallel computing toolbox in MATLAB, and only the experiments in Section 5.7 were run in parallel. By default, each instance was computed 20 times under the same setting. In detail, if the algorithm was single-threaded, the instance on 20 cores was executed simultaneously; if the algorithm was multi-threaded, they were run one by one. The sources of GA, ACS [27], IGA, two-level genetic algorithm (TLGA) [51], TLACS [7], and ALC_IGA are published on GitHub (https://github.com/nefphys/tsp, published on 4 January 2023), and the instances involved are also on this repository.

5.2. Benchmark Instances

Numerous instances are used to study the effectiveness of the proposed IGA and ALC_IGA. The major instances come from three sources: the famous benchmark TSP datasets TSPLIB (http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/, accessed on 30 October 2022); the TSP test data gathered by William Cook for large instances (https://www.math.uwaterloo.ca/tsp/data/index.html, accessed on 30 October 2022); hard to solve instances of the Euclidean TSPs (TNM) [69]. The TSP test data used in this research can be divided into three categories: National TSPs; VLSI TSPs; and Art TSPs. Moreover, the TNM data were generated by the C++ source provided by the authors of [69]. A two-dimensional Santa (http://cs.uef.fi/sipu/santa/, accessed on 30 October 2022) and a three-dimensional Gaia (https://www.math.uwaterloo.ca/tsp/star/gaia1.html, accessed on 30 October 2022) with millions of nodes were also investigated.

For various experimental tasks, the instances are classified into three categories: small-scale TSPs $(n\le 500)$, medium-scale TSPs $(500<n\le 4\times {10}^4)$, and large-scale TSPs $(n>4\times {10}^4)$. Small-scale TSPs were used to study the effectiveness of IGA, middle-scale TSPs were employed to tune parameters and compare ALC_IGA with TLACS and TLGA in a single thread, and large-scale TSPs were adopted to compare ALC_IGA with some relevant algorithms in parallel and verify the efficiency of ALC_IGA.

5.3. Evaluation Criteria

The following are the evaluation criteria for the algorithmic analyses on instances:

• The minimum objective value among all runs: $R_{best}$.
• The average objective value among all runs: $R_{avg}$.
• The standard deviation of results among all runs: $R_{std}$.
• The best known solution of the instance: $BKS$.
• The deviation percentage of $R_{best}$ is defined by:

  $$P{D}_{best}=\frac{R_{best}-BKS}{BKS}\times 100\%.$$
• The deviation percentage of $R_{avg}$ is defined by:

  $$P{D}_{avg}=\frac{R_{avg}-BKS}{BKS}\times 100\%.$$
• The running time $T_{Rb}$ in seconds while $R_{best}$ was found.
• The average of the running time in seconds among all runs: $T_{avg}$.
• The count of the best $R_{best}$, $R_{avg}$, $R_{std}$, and $T_{avg}$ are denoted as $C_{Rb}$, $C_{Ra}$, $C_{std}$, and $C_{Ta}$.

5.4. Performance Comparison of IGA, GA, and ACS

In addition to clustering, the most time-consuming part of ALC is eliminating the sub-TSPs. That is why the IGA proposed. To illustrate that IGA is efficient on TSPs, a comparison of IGA, GA, and ACS is imperative, and 42 small-scale benchmark instances were used in this numerical comparison. The parameters setting of IGA were as follows: the population was set to 0.4 times the number of nodes; the maximum number of iterations for S_2-opt was set to 20 times the number of nodes; the parameters of selection operator, $r_1$ and $r_2$, were set to 0.15 and 0.5; and the probability of mutation was set to 0.05. The population size of GA was set to 0.8 times the size of the instance and the mutation number was always set at three individuals. The parameters setting of ACS is as same as the literature [7]. Finally, the termination condition for the three compared algorithms is when there has been no improvement in the population for X iterations. In this experiment, X were set to 100, 100, and ${10}^4$ for IGA, ACS, and GA, respectively. The results of the comparison without parallelization are displayed in

Table 2. Results obtained by IGA, GA, and ACS on 42 small-scale instances.

Instance		IGA			GA			ACS
Name	BKS	${\mathit{R}}_{\mathit{best}}$$\left({\mathit{PD}}_{\mathit{best}}\right)$	${\mathit{R}}_{\mathit{std}}$	${\mathit{T}}_{\mathit{Rb}}$	${\mathit{R}}_{\mathit{best}}$$\left({\mathit{PD}}_{\mathit{best}}\right)$	${\mathit{R}}_{\mathit{std}}$	${\mathit{T}}_{\mathit{Rb}}$	${\mathit{R}}_{\mathit{best}}$$\left({\mathit{PD}}_{\mathit{best}}\right)$	${\mathit{R}}_{\mathit{std}}$	${\mathit{T}}_{\mathit{Rb}}$
		${\mathit{R}}_{\mathit{avg}}$$\left({\mathit{PD}}_{\mathit{avg}}\right)$		${\mathit{T}}_{\mathit{avg}}$	${\mathit{R}}_{\mathit{avg}}$$\left({\mathit{PD}}_{\mathit{avg}}\right)$		${\mathit{T}}_{\mathit{avg}}$	${\mathit{R}}_{\mathit{avg}}$$\left({\mathit{PD}}_{\mathit{avg}}\right)$		${\mathit{T}}_{\mathit{avg}}$
eil51	426	426 (0)	0.37	1.94	428 (0.47)	3.18	9.02	427 (0.23)	4.03	3.8
		426.85 (0.2)		1.72	436 (2.35)		11.42	430.95 (1.16)		2.56
berlin52	7542	7542 (0)	0	1.81	7542 (0)	206.62	8.85	7542 (0)	103.39	3.56
		7542 (0)		1.71	7836.95 (3.91)		6.14	7600.25 (0.77)		2.3
st70	675	675 (0)	3.1	3.49	675 (0)	8.3	16.28	682 (1.04)	7.2	5.91
		676.65 (0.24)		2.88	689.45 (2.14)		17.56	696.4 (3.17)		4.39
pr76	108,159	108,159 (0)	465.2	4.89	108,936 (0.72)	3423.57	18.91	112,647 (4.15)	657.37	7.05
		108,611.3 (0.42)		3.6	113,302.85 (4.76)		20.53	113,573.65 (5.01)		7.3
eil76	538	538 (0)	2.6	4.12	549 (2.04)	8.43	16.76	539 (0.19)	4.22	7.8
		540.3 (0.43)		3.57	558.65 (3.84)		26.14	546.25 (1.53)		9.55
rat99	1211	1211 (0)	5.4	6.35	1230 (1.57)	19.24	25.94	1229 (1.49)	6.95	15.89
		1217.25 (0.52)		5.92	1276.5 (5.41)		23.33	1239.05 (2.32)		15.39
kroA100	21,282	21,282 (0)	49.28	5.94	21,389 (0.5)	510.46	29.03	21,867 (2.75)	246.01	16.23
		21,327 (0.21)		5.53	22,134.75 (4.01)		21.58	22,310.65 (4.83)		10.49
rd100	7910	7910 (0)	12.88	6.04	7965 (0.7)	181.42	29.27	8074 (2.07)	80.08	16.68
		7917.3 (0.09)		5.66	8332.3 (5.34)		40.3	8195.65 (3.61)		23.02
eil101	629	630 (0.16)	4.49	7.92	638 (1.43)	7.73	29.4	635 (0.95)	11.26	15.31
		636.45 (1.18)		5.76	658.35 (4.67)		22.05	661.2 (5.12)		16.56
lin105	14,379	14,379 (0)	43.05	7.82	14,531 (1.06)	319.22	31.11	14,486 (0.74)	60.69	17.37
		14,414.05 (0.24)		5.99	15,080.8 (4.88)		26.73	14,596.25 (1.51)		14.62
pr107	44,303	44,303 (0)	119.04	9.49	44,577 (0.62)	728.56	33.58	44,707 (0.91)	198.61	15.89
		44,460.9 (0.36)		6.88	45,283.25 (2.21)		38.55	45,054.75 (1.7)		13.55
pr124	59,030	59,030 (0)	270.36	10	59,838 (1.37)	746.56	40.4	59,210 (0.3)	326.31	22.74
		59,357.15 (0.55)		11.51	60,725.3 (2.87)		35.17	59,664.95 (1.08)		22.61
bier127	118,282	118,423 (0.12)	352.24	14.27	120,538 (1.91)	2110.45	55.57	121,306 (2.56)	643.63	21.38
		118,982.65 (0.59)		15.57	124,348.1 (5.13)		46.66	122,591 (3.64)		20.44
ch130	6110	6128 (0.29)	32.35	13.4	6221 (1.82)	87.47	55.16	6292 (2.98)	32.14	26.49
		6178.45 (1.12)		12.96	6397.35 (4.7)		66.31	6331.55 (3.63)		21.52
xqf131	564	565 (0.18)	3.71	13.32	577 (2.3)	10.46	48.99	593 (5.14)	4.26	30.3
		575.05 (1.96)		11.29	594.85 (5.47)		46.33	599.3 (6.26)		63.67
pr136	96,772	96,870 (0.1)	691.4	23.05	97,605 (0.86)	1340.64	68.59	105,463 (8.98)	657.71	30.5
		97,810.2 (1.07)		20.19	100,223.55 (3.57)		75.11	106,761.45 (10.32)		19.16
pr144	58,537	58,537 (0)	23.66	22.16	58,746 (0.36)	1379.65	62.2	58,701 (0.28)	87.31	30.3
		58,561.15 (0.04)		16.88	60,252.7 (2.93)		48.28	58,824.15 (0.49)		46.68
kroA150	26,524	26,583 (0.22)	137.74	19.81	27,276 (2.84)	499.34	71.77	27,840 (4.96)	224.01	43.56
		26,758.25 (0.88)		18.18	28,026.55 (5.66)		71.92	28,334.55 (6.83)		59.19
ch150	6528	6533 (0.08)	8.55	14.91	6697 (2.59)	180.44	78.56	6720 (2.94)	28.95	35.78
		6556.85 (0.44)		12.31	6914.5 (5.92)		84.22	6758 (3.52)		29
pr152	73,682	73,682 (0)	207.17	16.63	74,424 (1.01)	983.05	74.12	74,849 (1.58)	410.16	31.11
		73,968.05 (0.39)		16.26	75,970.1 (3.11)		65.55	75,539.3 (2.52)		44.05
u159	42,080	42,080 (0)	185.91	16.25	42,396 (0.75)	138.31	56.49	43,582 (3.57)	406.45	44.13
		42,201.9 (0.29)		12.35	42,470.45 (0.93)		41.8	44,194.8 (5.03)		39.03
rat195	2323	2332 (0.39)	9.68	32.84	2402 (3.4)	31.16	119.44	2402 (3.4)	9.57	71.04
		2343.25 (0.87)		48.16	2450.75 (5.5)		93.94	2422.45 (4.28)		90.99
d198	15,780	15,885 (0.67)	76.13	40.34	15,979 (1.26)	179.24	163.14	16,487 (4.48)	188.48	63.99
		15,993.45 (1.35)		50.12	16,270.4 (3.11)		147.3	16,731.7 (6.03)		93.31
kroA200	29,368	29,380 (0.04)	112.12	31.57	30,196 (2.82)	448.98	172.31	30,798 (4.87)	256.21	66.66
		29,526.75 (0.54)		25.16	30,935.75 (5.34)		160.72	31,320.5 (6.65)		79.73
pr226	80,369	80,500 (0.16)	255.01	46.71	81,124 (0.94)	1789.16	168.17	83,027 (3.31)	435.43	84.47
		80,883.05 (0.64)		39.63	84,492.25 (5.13)		154	84,005.2 (4.52)		113.67
pr264	49,135	49,135 (0)	243.7	73.85	50,411 (2.6)	1627.27	380.4	51,893 (5.61)	333.2	135.88
		49,287.35 (0.31)		92.22	53,602.05 (9.09)		497.31	52,451.6 (6.75)		256.38
pr299	48,191	48,248 (0.12)	330.8	108.56	50,372 (4.53)	1029.18	433.79	52,663 (9.28)	330.56	182.62
		48,645.35 (0.94)		91.98	51,657.1 (7.19)		472.81	53,056.7 (10.1)		221.02
lin318	42,029	42,203 (0.41)	310.79	131.16	44,466 (5.8)	838.64	573.21	46,273 (10.1)	344.83	198.23
		42,630.25 (1.43)		168.95	45,454.3 (8.15)		656.22	47,145.25 (12.17)		156.24
pma343	1368	1373 (0.37)	4.57	125.75	1423 (4.02)	15.67	652.51	1478 (8.04)	15.32	281.64
		1379.5 (0.84)		82.22	1450.25 (6.01)		792.98	1512.55 (10.57)		462.81
pka379	1332	1337 (0.38)	5.89	175.62	1390 (4.35)	18.06	898.63	1416 (6.31)	18.21	373.21
		1344.7 (0.95)		173.24	1424.55 (6.95)		910.52	1442.9 (8.33)		387.1
bcl380	1621	1630 (0.56)	8.52	125.36	1723 (6.29)	29.13	1106.53	1732 (6.85)	13.06	368.99
		1644.05 (1.42)		94.35	1789.95 (10.42)		1344.2	1753.1 (8.15)		475.46
pbl395	1281	1288 (0.55)	5.57	181.8	1369 (6.87)	19.78	1265.45	1427 (11.4)	10.27	347.13
		1300.6 (1.53)		184.75	1401.95 (9.44)		1269.97	1444.7 (12.78)		563.52
rd400	15281	15,350 (0.45)	74.95	261.87	15,993 (4.66)	196.73	1581.54	17,338 (13.46)	105.81	419.85
		15,512.55 (1.52)		200.67	16,414.55 (7.42)		1617.67	17,519.65 (14.65)		375.42
pbk411	1343	1359 (1.19)	7.02	216.66	1421 (5.81)	24.53	1419.09	1492 (11.09)	15.07	462.24
		1368.15 (1.87)		202.87	1472.55 (9.65)		1940.95	1518.5 (13.07)		447.8
fl417	11,861	11,910 (0.41)	49.41	218.09	11,993 (1.11)	338.81	1548.44	12,559 (5.88)	101.44	432.18
		11,973.75 (0.95)		253.43	12,488.4 (5.29)		1585.45	12,664.55 (6.77)		554.4
pbn423	1365	1369 (0.29)	8.61	214.1	1459 (6.89)	29.16	1508.73	1515 (10.99)	15.95	504.08
		1386.45 (1.57)		231.72	1512.15 (10.78)	1677.52		1545.6 (13.23)		542.73
pbm436	1443	1446 (0.21)	7.19	189.32	1538 (6.58)	22.71	1881.99	1570 (8.8)	11.29	527.42
		1458.55 (1.08)		238.13	1594.9 (10.53)		2523.16	1595 (10.53)		744.35
pr439	107217	107,666 (0.42)	754.5	264.02	110,702 (3.25)	2445.65	2097.05	117,852 (9.92)	1099.39	464.33
		108,535.5 (1.23)		218.1	115,479.95 (7.71)		2074.73	120,033.4 (11.95)		463.28
pcb442	50778	51,380 (1.19)	176.52	332	54,091 (6.52)	990.52	1888.44	56,711 (11.68)	348.22	554.25
		51,597.35 (1.61)		443.97	55,595.1 (9.49)		1889.08	57,762.95 (13.76)		572.78
d493	35,002	35,484 (1.38)	194.6	469.09	36,888 (5.39)	336.55	3096.78	38,744 (10.69)	412.42	771.14
		35,750 (2.14)		650.09	37,488.9 (7.11)		3437.53	39,710 (13.45)		753.55
Average		0.27	125.45	90.43	2.79	556.08	585.95	5.19	197.51	192.60
$C_{Rb}$/$C_{Ra}$/$C_{std}$/$C_{Ta}$		42/42/39/41			2/0/0/0			1/0/3/1

, and various evaluation criteria were considered, including $R_{best}$, $P{D}_{best}$, $R_{avg}$, $P{D}_{avg}$, $R_{std}$, $T_{Rb}$, $T_{avg}$, $C_{Rb}/C_{Ra}/C_{std}/C_{Ta}$, and the average value for $P{D}_{avg}$, $R_{std}$, and $T_{avg}$.

From Table 2, the $C_{Rb}/C_{Ra}/C_{std}/C_{Ta}$ of IGA, GA, and ACS are $42/42/39/41$, $2/0/0/0$, and $1/0/3/1$, respectively. It is clear that the innovative IGA consistently produces superior results over GA and ACS. Additionally, the average computation time of IGA is the least in 97% instances, and its stability also has a far higher level than the other two algorithms. More specifically, the average $P{D}_{best}$ of IGA is 0.27%, but GA and ACS are 2.79% and 5.19%, respectively, 10 times and 19 times of IGA. In almost all cases, the $P{D}_{avg}$ of IGA is less than 2%, but GA and ACS are often greater than 5%, especially ACS, and even greater than 10% in some instances. In the view of stability, the average of the evaluation criteria $R_{std}$ of IGA is 125.45, only 22.56% of GA and 63.52% of ACS. The average computation time of IGA is 90.43 s, which is less than one-sixth as long as GA or half as long as ACS. The above discussion indicates that all the accuracy and the convergence speeds of IGA are substantially superior to the traditional GA and ACS, which proves that the proposed IGA can reduce the computation time and improve the solution of ALC_IGA.

In Figure 5, the convergence speeds of IGA, GA, and ACS are compared under four instances with sizes ranging from 51 to 226. It can be observed that the convergence speed of IGA in the initial stage is much faster than that of GA and ACS. This is due to the heuristic crossover SBHX and the local search S_2-opt combined in IGA.

We know that the suggested IGA can be utilized to solve WSP as stated in Section 3, with just a minor adjustment to the distance between the start and end cities. In this part, to validate the effectiveness of IGA for WSP, the 42 instances in Table 2 were re-investigated. The start and end cities of these instances were determined using the first and last elements of the best known solutions provided by TSPLIB and TSP test data, and the distances between start and end cities were set to −${10}^5$. The benchmark algorithm is the famous TSP solver LKH proposed by Helsgaun [49]. The results, which include $R_{best}$, ${PD}_{Best}$, $R_{avg}$, $P{D}_{avg}$, $R_{worst}$, $R_{std}$, $T_{Rb}$, and $T_{avg}$ are shown in

Table 3. Results obtained by IGA on 42 small-scale WSPs.

Instance		IGA
Name	LKH	${\mathit{R}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{R}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{R}}_{\mathbf{worst}}$	${\mathit{R}}_{\mathit{std}}$	${\mathit{T}}_{\mathit{Rb}}$	${\mathit{T}}_{\mathit{avg}}$
eil51	420	420	0	420.95	0.23	426	2.09	1.72	1.91
berlin52	7387	7387	0	7387	0	7387	0	1.77	1.95
st70	666	666	0	669.05	0.46	675	3.19	2.94	3.51
pr76	104,443	104,443	0	104,856.4	0.4	105,375	469.08	3.56	4.15
eil76	530	530	0	532.95	0.56	535	1.5	3.84	4.1
rat99	1207	1211	0.33	1217.35	0.86	1225	4.6	6.14	7.27
kroA100	21,106	21106	0	21,262.5	0.74	21,509	92.99	6.26	6.46
rd100	7787	7787	0	7796.2	0.12	7947	35.53	5.42	6.58
eil101	629	629	0	631.8	0.45	637	2.44	5.89	6.9
lin105	14,336	14,336	0	14,400.7	0.45	14,509	60.77	6.55	7.5
pr107	39,270	39,270	0	39,413.85	0.37	39,729	134.11	7.83	10.84
pr124	58,810	58,810	0	58,898.9	0.15	59,030	78.16	9.73	12.5
bier127	117,393	117,650	0.22	118,336.9	0.8	119,236	594.61	10.87	12.81
ch130	6028	6075	0.78	6119.35	1.52	6201	40.47	12.69	13.33
xqf131	529	529	0	535.6	1.25	541	3.7	9.83	10.74
pr136	96,386	96,475	0.09	97,392.7	1.04	99,228	862.65	17.2	22.12
pr144	56,126	56,126	0	56,134.65	0.02	56,162	13.41	14.29	16.14
kroA150	26,387	26,390	0.01	26,594.2	0.79	26,975	164.62	24.62	19.39
ch150	6498	6498	0	6528.1	0.46	6591	19.52	15.77	15.25
pr152	64,215	64,215	0	64,459.35	0.38	65,335	335.55	13.21	19.92
u159	41797	41,797	0	41,925.8	0.31	42,410	179.63	12.93	16.2
rat195	2260	2260	0	2264.7	0.21	2297	8.42	19.28	24.15
d198	12,804	12,855	0.4	12,914.7	0.86	13,019	48.92	61.13	48.05
kroA200	29,206	29,218	0.04	29,411.5	0.7	29,688	121.34	28.33	35.48
pr226	78,587	78,637	0.06	79,045.9	0.58	80,116	378.15	39.01	49.5
xqg237	1004	1012	0.8	1021.4	1.73	1032	5.53	35.45	46.88
gil262	2375	2378	0.13	2396.7	0.91	2415	10.32	66.78	72.32
pr264	46,430	46,430	0	46,914.8	1.04	47,922	439.57	70.32	64.26
pr299	47,534	47,563	0.06	48,069.9	1.13	48,544	275.39	133.62	112.19
lin318	41,608	41,704	0.23	42,139.8	1.28	42,714	266.71	179.63	119.53
pma343	1323	1326	0.23	1336.5	1.02	1357	9.26	146	125.9
pka379	1267	1269	0.16	1282.8	1.25	1312	11.47	155.4	153
bcl380	1606	1609	0.19	1623.9	1.11	1660	12.9	95.49	121.71
pbl395	1277	1284	0.55	1292.65	1.23	1311	6.71	141.11	157.49
rd400	15,192	15,310	0.78	15,435.5	1.6	15,620	79.69	157.5	209.83
pbk411	1337	1348	0.82	1367.8	2.3	1380	7.64	274.59	203.49
fl417	11,414	11,423	0.08	11,464.45	0.44	11,679	54.26	274.92	225.02
pbn423	1361	1362	0.07	1382.6	1.59	1407	10.21	243.59	196.58
pbm436	1420	1431	0.77	1446.15	1.84	1460	8.36	186.44	179.57
pr439	104,810	104,957	0.14	105,786.2	0.93	106,390	383.21	322.24	271.09
pcb442	50,331	50,734	0.8	51,205.2	1.74	51,654	252.19	333.2	327.85
d493	32,897	33,097	0.61	33,363.95	1.42	33,722	154.92	510.58	473.19
Average		-	0.20	-	0.86	-	134.38	87.33	81.83

.

It is clear from Table 3 that the IGA can produce the solution of WSP with a high level of accuracy. We note that all $P{D}_{best}$ are lower than 1% and 18 out of 42 are as good as LKH. The $P{D}_{best}$ of 25 out of 42 instances produced by IGA are less than 0.1%, and all the $P{D}_{best}$ are lower than 1%. The outcomes on WSPs are even superior to those of IGA on TSPs in some aspects. In detailed, the averages of $P{D}_{best}$, $R_{std}$, and $T_{avg}$ are 0.2%, 134.28, and 81.83, respectively. By comparison, they are 0.27%, 125.45, and 90.43 on TSPs, that indicating that the IGA is able to find better solutions on WSPs in a shorter time than on TSPs. Especially on d493, the average execution time $T_{avg}$ of IGA on WSPs is only 473.19, whereas it is 650.09 on TSPs.

According to the aforementioned analyses, the proposed IGA significantly outperforms GA and ACS in terms of convergence speed, solution quality, and stability. Additionally, on the WSP, which appeared more often in ALC_IGA, IGA also performed very well.

5.5. Parameters Tuning for ALC_IGA

The solution initialization phase of ALC_IGA shown in Section 4.1 shows that the main parameter of ALC_IGA in only the first phase is M, which limits the time required to solve TSP or WSP less than $T_1$. The results from the previous subsection show that, under ordinary situations, the IGA can handle TSPs with less than 100 nodes in 6 s and solve TSPs with less than 150 nodes in 20 s. Consequently, a decent M should not go beyond 150 too much. In order to choose a favorable M for ALC_IGA to balance the computation time and quality of solution, numerical comparison of M was set to 50, 100, and 150 on 45 instances, which are considered in this subsection. These instances were medium-scale, with sizes ranging from $1.3\times {10}^3$ to $2.5\times {10}^4$. Due to the fact that the distribution of nodes greatly affects the clustering effect, in order to fairly study the influence of M on the results of ALC_IGA, a variety of instances coming from TSPLIB, TSP test data, and TNM data were studied in this experiment. In the following subsections of this paper, the termination condition of IGA is set to when there has been no improvement in the population for 30 iterations, and the other parameters are as same as in the last Section 5.7. Denote the ALC_IGA with $M=50,100,150$ as ALC_IGA50, ALC_IGA100, and ALC_IGA150, respectively; the major five evaluation criteria $R_{best}$, $P{D}_{best}$, $R_{avg}$, $P{D}_{avg}$, $T_{avg}$ and $C_{Rb}/C_{Ra}/C_{Ta}$ of the results, which ran without parallelization, are presented in

Table 4. Comparison of results obtained by ALC_IGA in single core with M setting to 50, 100, and 150, respectively.

Instance		ALC_IGA50			ALC_IGA100			ALC_IGA150
Name	BKS	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$
rl1323	270,199	9.63	14.83	14.67	10.07	11.7	25.36	5.99	9.84	32.49
dca1389	5085	10.05	11.56	16.05	5.17	8.32	27.7	6.12	7.49	52.5
fl1400	20,127	3.42	7.89	15.86	6.04	10.17	22.66	6	9.16	39.92
u1432	152,970	5.62	7.06	15.99	4.73	5.62	24.17	4.41	5.29	45.62
fl1577	22,249	10.78	14.05	18.35	8.88	12.32	29.87	7.38	11.37	41.37
fnb1615	4956	8.35	10.05	18.32	7.14	8.82	35	5.31	7.49	47.57
d1655	62,128	8.44	9.78	19.13	5.43	6.93	30.27	3.17	4.22	53.45
vm1748	336,556	8.46	9.74	21.64	6.4	7.71	42.32	5.15	6.86	63.85
u1817	57,201	9.37	10.89	20.25	7.47	9.53	32.81	6.98	8.81	71.13
dkd1973	6421	7.16	8.24	23.86	5.17	6.14	40.96	6.73	7.99	54.72
Tnm2002	37,029,600	7.33	10.74	21.7	8.4	13.72	28.08	9.36	14.93	49.52
d2103	80450	12.56	15.9	25.49	10.56	12.7	45.11	9.03	10.69	70.55
bva2144	6304	7.92	9.68	24.25	5.9	7.49	39.01	4.6	5.65	68.61
u2319	234,256	2.64	3.2	25.39	1.8	2.25	41.08	1.76	2.16	69.86
pr2392	378,032	8.48	9.83	30.69	7.85	9.22	46.79	6.65	8.31	121.08
pcb3038	137,694	8.13	9	37.59	6.42	7.33	72.23	5.56	6.5	112.85
ltb3729	11,821	9.86	11.07	42.9	6.97	8.54	67.82	5.74	7.16	114.96
fl3795	28,772	13.79	16.04	43.27	10.4	12.85	68.44	9.23	12.3	100.94
Tnm4000	74,858,233	4.73	7.55	42.1	8.88	12.05	62.52	10.88	16	86
fnl4461	182,566	6.95	7.72	56.3	5.35	5.9	108.01	4.52	5.29	160.13
bgf4475	13,221	13.46	15.06	51.97	10.51	11.6	84.75	9.15	10.43	121.42
fea5557	15,445	12.35	13.34	64.25	8.73	9.6	99.42	8.11	8.87	172.33
rl5915	565,530	17.75	19.14	66.7	12.81	14.58	108.87	11.43	12.86	158.25
rl5934	556,045	15.77	17.94	68.37	12.59	13.82	107.29	10.5	11.73	151.87
Tnm6001	112,708,118	7.68	9.76	62.41	5.96	9.05	89.06	9.32	12.26	120.36
xsc6880	21,535	12.77	13.91	79.76	10.25	11.04	130.57	9.05	9.64	191.37
bnd7168	21,834	11.88	12.63	87.6	8.41	9.31	142.97	7.73	8.56	226.37
lap7454	19,535	13.87	14.62	87.4	9.89	10.67	127.22	8.96	9.59	204.57
Tnm8002	150,561,446	12.85	14.74	88.22	6.24	8.01	112.69	7.29	10.04	132.49
ida8197	22,338	10.89	12.53	96.35	9.21	10.01	160.35	7.66	9	240.39
dga9698	27,724	14.88	15.82	116.08	11.08	12.23	190.04	9.55	10.49	272.45
Tnm10000	188,414,262	20.6	23.02	103.41	5.13	6.97	127.58	5.94	8.93	160.26
xmc10150	28,387	13.61	14.51	113.46	10.75	11.77	191.94	9.47	10.4	284.55
rl11849	923,288	14.22	15.03	141.87	10.8	11.47	224.3	9.31	10.18	358.89
usa13509	19,982,859	9.81	10.93	165.83	8.26	8.82	318.67	6.69	7.18	492.82
xvb13584	37,083	11.16	11.85	155.75	8.48	9.13	236.12	7.77	8.27	373.29
brd14051	469,385	8.07	8.52	174.4	5.92	6.18	334.87	5.16	5.49	552.78
d15112	1,573,084	7.94	8.43	190.14	6.13	6.62	349.63	5.54	5.79	598.85
xia16928	52,838	13.24	13.85	194.99	8.77	9.53	312.44	8.26	8.74	477.84
pjh17845	48,083	11.19	12	204.99	8.22	8.88	324.65	7.63	8.38	524.2
d18512	645,238	8.06	8.39	233.68	6.47	6.86	438.17	5.27	5.57	720.64
Tnm20002	377,692,238	15.16	23.22	209.17	5.44	6.58	268.69	4.88	6.42	379.48
ido21215	63,501	12.57	13.18	246.85	9.77	10.25	401.68	8.8	9.14	656.89
lsb22777	60,977	13.35	13.83	268.06	9.85	10.71	409.42	8.76	9.8	660.7
bbz25234	69,335	12.08	12.69	290.48	9.45	9.98	482.27	8.5	8.99	746.58
Average		10.64	12.31	91.02	7.96	9.4	148.09	7.23	8.76	231.93
$C_{Rb}$/$C_{Ra}$/$C_{Ta}$		3/3/45			5/4/0			37/38/0

.

From Table 4, the $C_{Rb}/C_{Ra}/C_{Ta}$ of the ALC_IGA50, ALC_IGA100, and ALC_IGA150 are $3/3/45$, $5/4/0$, and $37/38/0$, respectively. As can be seen, the ALC_IGA50 is the fastest, whereas the ALC_IGA150 algorithm usually produces the best results. When the size of instance is less than $2\times {10}^3$, ALC_IGA50 has the minimum $P{D}_{best}$ and $P{D}_{avg}$ on fl1400, and ALC_IGA10 has the lowest $P{D}_{best}$ on dca1389 and dkd1973. However, the $P{D}_{best}$ and $P{D}_{avg}$ of ALC_IGA150 on the three instances are all less than 10%, and this is still a respectable result. When the instance size is larger than $2\times {10}^3$, the ALC_IGA50 and ALC_IGA100 only perform better than the ALC_IGA150 on TNM instances. Concerning specifics, the ALC_IGA50 works well on Tnm2002 and Tnm4000, the ALC_IGA100 excels on Tnm6001, Tnm8002, and Tnm10000, but the ALC_IGA150 provided the best result on the large instance of Tnm20002. The results of ALC_IGA150 are therefore superior to those of ALC_IGA50 and ALC_IGA100 in TSPLIB and TSP test data, and it is still a suitable approach for TNM data. The average of $P{D}_{best}$ and $P{D}_{avg}$ for the three algorithms shown at the bottom of Table 4 also support this.

Furthermore, considering the algorithms’ running times, the mean of $T_{avg}$ of ALC_IGA50 is 91.02, which is three-fifths of the time taken by ALC_IGA100 and two-fifths of ALC_IGA-150. This indicates that the fastest algorithm is ALC_IGA50, and the ratio of running time hardly changes with the size of the instance. However, even the slowest proposed ALC_IGA150 could handle the ${10}^4$ nodes instance with just approximately 10% deviation percentage in the same amount of running time as the IGA, which can only solve the instance with a size of roughly 400 nodes. The fastest ALC_IGA50, which is more than 60 times faster than the IGA, can deal with $2.5\times {10}^4$ nodes in the same amount of time. Thus, the high efficiency of ALC_IGA has been verified.

Figure 6 displays the deviation percentage of each run among all instances. It is noteworthy that for all three algorithms, most of the deviation percentages are under 20%. In particular, the deviation percentages of the ALC_IGA100 and ALC_IGA150 are less than 10% in the majority of instances. Furthermore, the figure also reveals that the ALC_IGA100 and ALC_IGA150 have many overlapping regions, indicating that the performance of the two algorithms is roughly equivalent.

Additionally, the relationship between the running time of ALC_IGA and the value of M is taken into account. The average execution time for the instances of the three algorithms is plotted in Figure 7 in different colors. In order to discuss the computational complexity of the algorithms, the exponential curve fitting for each group was calculated. Because the computation time of ALC_IGA150 is larger than the other two, its slope shown in the figure is undoubtedly the steepest. The approximated time complexities of ALC_IGA50, ALC_IGA100, and ALC_IGA150 are $O\left(n^{0.9992}\right)$, $O\left(n^{0.9958}\right)$, and $O\left(n^{1.02}\right)$, respectively, which are all extremely close to the linear computational complexity $O\left(n\right)$. With 95% confidence bounds, the upper bound of the computational complexity for ALC_IGA50 is 1.0326, and the other two are 1.0963 and 1.151. The statistical outcomes of curve fitting are shown in

Table 5. The exponential curve fitting $a·n^b$ of the running time of ALC_IGA with single core while M is set to 50, 100, and 150.

M	a	b	SSE	${\mathit{R}}^2$	Adjusted ${\mathit{R}}^2$	RMSE
50	0.0118 ± 0.0038	0.9992 ± 0.0334	1705	0.9938	0.9936	6.297
100	0.0198 ± 0.0192	0.9958 ± 0.1005	41246	0.9459	0.9446	30.97
150	0.0247 ± 0.0314	1.02 ± 0.131	167900	0.9146	0.9126	62.49

. It can be seen that all three fitting models have high confidence, especially the $R^2$ of ALC_IGA50, which is over 0.99. The above results prove the computational complexity analysis of the proposed ALC_IGA in Section 4.3.

To sum up, the quality of the solution obtained by ALC_IGA has a strong relationship with the data distribution and the value of M. On the other hand, the larger M is set, the longer the computation time required by ALC_IGA according to the numerical experiments. In most cases, setting M to 100 is a typical compromise choice to balance computation time and quality.

5.6. ALC_IGA Compared with Two-Layered Algorithms

The effectiveness of ALC_IGA on medium-scale problems was confirmed in Section 5.5, although it is unclear whether it is superior to the other layered algorithms. To illustrate the performance of ALC_IGA, the proposed ALC_IGA was compared with two typical algorithms, which were TLGA [51] and TLACS [7]. The TLGA and TLACS were re-coded in Matlab, and to be fair, the running time and the solution quality were improved to be better than the literature. The main parameters were set as follows: the M of ALC_IGA was set to 100; the numbers of cluster centers of TLACS and TLGA were automatically adjusted according to the size of the instance; the termination conditions of ALC_IGA, TLACS, and TLGA were that when there has been no improvement of the solution for 30, 30, and 100 iterations, respectively. All of the algorithms were implemented in single-thread. There were 45 medium-scale instances whose sizes ranging from $1\times {10}^3$ to $4\times {10}^5$ were investigated in this experiment.

As is shown in

Table 6. Results obtained by ALC_IGA, TLACS, and TLGA with single thread on medium-scale instances.

Instance		ALC_IGA			TLACS			TLGA
Name	BKS	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$
vm1084	239,297	5.88	7.72	21.32	12.03	13.63	13.59	53.63	66.69	92.61
d1291	50,801	8.76	10.65	20.89	14.08	16.34	15.32	58.1	65.88	61.76
rl1323	270,199	10.01	11.46	24.65	17.88	20.35	13.86	70.35	79.18	69.01
fl1400	20,127	4.57	9.74	23.93	4.25	6.85	28.78	54.8	74.71	147.38
fl1577	22,249	7.79	13.08	29.34	10.19	12.27	18.86	86.64	98.19	82.13
d1655	62,128	5.03	6.54	29.27	13.15	14.32	21.17	50.89	61.03	115.34
vm1748	336,556	6.7	7.64	31.65	12.74	14.19	22.95	64.18	76.08	108.67
u1817	57,201	7.88	9.49	33.76	10.88	12.34	19.89	54.99	61.58	102.33
d2103	80,450	10.58	12.45	44.22	19.26	21.76	24.17	59.41	68.84	166.26
u2152	64,253	8.06	9.37	39.2	12.12	13.45	28.12	57.26	63.54	144.79
u2319	234,256	1.84	2.3	41.32	4.3	5.09	31.11	32.87	36.72	150.83
pr2392	378,032	7.17	9.13	44.87	10.99	13.38	37.39	53.73	62.36	132.17
pcb3038	137,694	6.66	7.38	76.63	12.17	13.25	48.31	51.59	57.4	175.13
fl3795	28,772	11.53	12.98	66.47	13.01	14.28	112.8	101.58	116.31	275.55
dkf3954	12,538	9.02	9.89	76.13	14.47	16.08	68.82	61.99	67.22	247.99
Tnm4000	74,858,233	8.58	12.59	59.12	3.59	5.17	44.85	259.8	298.2	214.53
fnl4461	182,566	5.53	5.93	112.01	10.1	10.75	90.24	47.59	52.67	240.54
ca4663	1,290,319	8.61	10.45	100.84	14.37	16.41	155.92	76.7	92.73	378.54
xqd4966	15,316	5.56	6.53	100.23	11.07	12.45	105.53	71.28	94.91	349.59
fqm5087	13,029	5.52	6.56	99.07	11.15	12.03	99.23	81.88	94.76	325.78
fea5557	15,445	8.93	9.84	106.72	14.06	15.72	111.2	63.68	74.72	417.61
rl5915	565,530	14.14	15.1	103.29	20.18	22.21	113.81	75.64	85.77	386.15
rl5934	556,045	12.66	13.9	105.45	19.4	20.16	107.38	72.67	84.82	374.8
tz6117	394,718	6.86	7.63	136.46	13.17	14.13	205.99	66.47	73.76	429.67
xsc6880	21,535	9.94	11.14	132.75	15.76	17.26	150.23	64.88	72.96	495.94
bnd7168	21,834	8.18	9.13	139.69	14.7	16.02	163.16	63.15	70.91	518.01
lap7454	19,535	9.76	10.75	128.89	15.9	16.71	172.89	67.42	74.47	594.09
ida8197	22,338	9.19	9.92	152.68	14.87	15.74	190.42	61.98	72.42	610.65
dga9698	27,724	11.3	12.18	176.72	17.14	17.88	256.85	71.31	77.97	690.84
Tnm10000	188,414,262	5.43	7.57	132	1.96	3.05	163.07	393.56	458.1	722.56
xmc10150	28,387	10.9	11.68	175.01	16.45	17.23	265.42	72.03	77.04	734.97
rl11849	923,288	10.35	11.43	224.34	15.54	16.63	359.35	69.73	75.44	933.61
usa13509	19,982,859	8.21	8.65	295.5	13.61	14.53	664.7	66.37	71.67	1378.6
brd14051	469,385	5.72	6.11	342.91	10.96	11.71	528.3	50.36	58.39	1232.43
d15112	1,573,084	6.1	6.44	356.77	11.02	11.92	641.19	52.75	57.46	1443.81
it16862	557,315	8.55	9.11	361.73	12.7	13.39	790.6	63.35	75.35	1547.82
d18512	645,238	6.59	6.84	434.83	11.1	11.71	795.83	52.15	57.02	1722.17
boa28924	79,622	11.19	11.83	529.35	15.76	16.41	1473.54	79.98	86.43	2760.68
Tnm30001	566,973,296	8.06	8.68	417.43	1.18	1.78	905.14	640.39	730.39	2924.84
pbh30440	88,313	11.33	11.77	585.99	15.9	16.33	1685.75	72.34	80.03	3306.87
xib32892	96,757	10.34	10.84	613.21	15.07	15.63	1897.12	76.96	83.16	3252.86
fry33203	97,240	11.44	11.79	617.37	15.2	16.01	1992.54	76.68	82.39	3600.66
bby34656	99,159	9.67	10.19	647.45	14.92	15.38	2192.23	70.47	77.38	3866
pba38478	108,318	10.7	11.21	732.33	15.34	15.89	2614.56	73.06	79.11	4093.7
ics39603	106,819	11.97	12.54	725.33	16.4	16.81	2584.34	76.36	83.37	4318.36
Average		8.51	9.74	209.98	12.89	14.1	489.48	89.84	102.43	1020.86
$C_{Rb}$/$C_{Ra}$/$C_{Ta}$		41/40/30			4/5/15			0/0/0

, the evaluation criteria $C_{Rb}/C_{Ra}/C_{Ta}$ of ALC_IGA are $41/40/30$, the $C_{Rb}/C_{Ra}/C_{Ta}$ of TLACS are $4/5/15$, and $C_{Rb}/C_{Ra}/C_{Ta}$ of TLGA are $0/0/0$. First of all, it is pointed out that TLGA has no advantage in all instances compared with the other two algorithms in terms of solution quality and convergence speed. The TLACS obtained the four best $P{D}_{best}$ and five best $P{D}_{avg}$ among all 45 instances. In detail, TLACS outperforms ALC_IGA on fl1400 and fl1577, but ALC_IGA defeats TLACS on fl3795. The other three instances where TLACS performs better are all hard-to-solve instances [69]. That is because the fewer clusters generated, the better solution produced, which is according to the results in Section 5.5. The averages of $P{D}_{best}$ and $P{D}_{avg}$ for ALC_IGA are 8.51 and 9.74, whereas for TLACS and TLGA, they are 12.89 and 14.10, and 88.84 and 102.43, respectively. The analyses above verify that the accuracy of ALC_IGA is superior to TLACS and TLGA in all scenarios except for TNM instances.

From Table 6, the average values of $T_{avg}$ of ALC_IGA, TLACS and TLGA are 209.98, 489.48, and 1020.86 s. It can be seen that the proposed ALC_IGA is much faster than the other two algorithms. In detail, when the size of the instance is less than $4.5\times {10}^3$, TLACS is faster than ALC_IGA in most cases. When the size of the instance is between $4.5\times {10}^3$ and ${10}^4$, the running times of ALC_IGA and TLACS are very close. When the size of the instance is larger than ${10}^4$, the proposed ALC_IGA has huge advantages, especially when the problem size is greater than $3\times {10}^4$, as the computation time of ALC_IGA is less than one-third of TLACS and less than one-fifth of TLGA.

Figure 8 converts a large amount of data in Table 6 into an explicit image. The real lines represent the $P{D}_{avg}$ and $T_{avg}$ of ALC_IGA. It is closer to the horizontal axis, which means that the ALC_IGA has a high performance in accuracy and convergence speed. The results of the run times for ALC_IGA, TLACS, and TLGA with exponential curve fittings were $O\left(n^{0.945}\right)$, $O\left(n^{1.611}\right)$, and $O\left(n^{1.221}\right)$. This reveals that the gap in computation time between ALC_IGA and the other two algorithms will increase as the size of the problem increases.

5.7. Results on Large-Scale TSP Instances

In this section, to investigate the performance of ALC_ IGA in large-scale instances, the new ALC_IGA is compared to the TLACS [7], an accelerating genetic algorithm evolution via ant-based mutation and crossover (ER-ACO) [32] and a 3L-MFEA-MP [55]. The ALC_IGA and TLACS were implemented in Matlab R2022a and parallelized by the parallel computing toolbox in Matlab. The ER-ACO was set on an AMD Ryzen 2700 CPU with 16 threads in parallel. The parallel 3L-MFEA-MP was coded in Python, and it was implemented on a server with a 24-core Intel Xeon CPU and 96 GB RAM. The sizes of the 15 involved instances range from $4\times {10}^4$ to $2\times {10}^5$.

The results and five evaluation criteria $R_{best}$, $P{D}_{best}$, $R_{avg}$, $P{D}_{avg}$, and $T_{avg}$ are shown in

Table 7. Comparison of ALC_IGA and three relevant algorithms in parallel in large-scale instances.

Instance	BKS	Algorithms	${\mathit{R}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{R}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{avg}}$
rbz43748	125,183	ALC_IGA	138,336	10.51	138,780	10.86	78.97
		TLACS	143,707	14.8	144,783	15.66	460.23
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
fht47608	125,104	ALC_IGA	138,369	10.6	138,854	10.99	90.39
		TLACS	143,328	14.57	144,080	15.17	500.51
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
fna52057	147,789	ALC_IGA	162,347	9.85	162,900	10.22	89.73
		TLACS	170,295	15.23	170813	15.58	545.47
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
bna56769	158,078	ALC_IGA	174,110	10.14	175,110	10.77	121.35
		TLACS	181,703	14.95	182,421	15.4	604.53
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
dan59296	165,371	ALC_IGA	183,301	10.84	183,803	11.15	112.64
		TLACS	190,994	15.49	191,471	15.78	607.85
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
Tnm80002	1,513,392,208	ALC_IGA	1,719,287,088	13.6	1,815,094,672	19.94	145.72
		TLACS	1,521,978,113	0.57	1,528,977,655	1.03	876.21
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
Tnm90001	1,702,667,051	ALC_IGA	1,900,341,576	11.61	2,038,420,433	19.72	161.17
		TLACS	1,712,186,024	0.56	1,717,989,072	0.9	949.71
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
Tnm100000	1,891,945,975	ALC_IGA	2,107,195,713	11.38	2,237,645,170	18.27	171.85
		TLACS	1,902,231,611	0.54	1,910,148,253	0.96	1497.72
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
mona-lisa100K	5,757,191	ALC_IGA	5,930,206	3.01	5,934,489	3.08	235.13
		TLACS	6,401,529	11.19	6,417,896	11.48	1657.04
		ER-ACO	-	7.99	-	8.9	1792.95
		3L-MFEA-MP	6,513,686	13.34	6,525,173	13.34	1030.72
sra104815	251,342	ALC_IGA	276,998	10.21	277,851	10.55	212.9
		TLACS	288,535	14.8	289,519	15.19	1562.05
		ER-ACO	-	-	-	-	-
		3L-MFEA-MP	-	-	-	-	-
vangogh120K	6,543,609	ALC_IGA	6,742,349	3.04	6746733	3.1	314.21
		TLACS	7,332,648	12.06	7,344,261	12.24	2269.41
		ER-ACO	-	8.66	-	9.22	1975.97
		3L-MFEA-MP	7,423,925	13.55	7,430,063	13.55	1256.78
venus140K	6,810,665	ALC_IGA	7,018,375	3.05	7,021,104	3.09	341.17
		TLACS	7,638,796	12.16	7,647,611	12.29	3262.63
		ER-ACO	-	8.33	-	8.72	2496.99
		3L-MFEA-MP	7,718,441	13.41	7,724,201	13.41	1518.13
pareja160K	7,619,953	ALC_IGA	7,854,282	3.08	7,858,881	3.14	428.04
		TLACS	8,623,198	13.17	8,629,465	13.25	3734.21
		ER-ACO	-	8.47	-	9.47	3049.45
		3L-MFEA-MP	-	-	-	-	-
courbet180K	7,888,731	ALC_IGA	8,148,232	3.29	8,150,953	3.32	498.64
		TLACS	8,940,877	13.34	8,956,732	13.54	4454.45
		ER-ACO	-	8.37	-	9.83	3666.29
		3L-MFEA-MP	-	-	-	-	-
earring200K	8,171,677	ALC_IGA	8,454,565	3.46	8,460,779	3.54	522.74
		TLACS	-	-	-	-	-
		ER-ACO	-	9.18	-	9.83	4236.65
		3L-MFEA-MP	9,365,519	14.65	9,368,743	14.65	2382.31

. Compared to ALC_IGA with TLACS, the advantage of ALC_IGA in running time is apparent again. The running time of ALC_IGA is roughly one-sixth of TLACS when the problem size is around $5\times {10}^4$, but when the size approaches $2\times {10}^5$, the running time of it is just one-ninth of TLACS. The performance of ALC_IGA is better than TLACS in most conditions, but TLACS works pretty well on TNM instances.

There are four instances compared with 3L-MFEA-MP; results shown in Table 7 reveal that the performance of it is very close to TLACS, and the difference between them in terms of $P{D}_{best}$ and $P{D}_{avg}$ is about 2%, whereas, compared with ALC_IGA, the 3L-MFEA-MP is far worse than it in terms of convergence speed and solution quality. On the involved six instances, the $P{D}_{best}$ and $P{D}_{avg}$ of the novel intelligence algorithm ER-ACO exceeded ALC_IGA by 2.5 times. Additionally, the proposed ALC_IGA runs significantly faster than ER-ACO.

Figure 9 shows the average computation times and deviation percentages of the four algorithms. It is clear that ALC_IGA performs well in most situations and is significantly faster than the others. According to the results illustrated in Section 5.5, the only drawback of ALC_IGA is on TNM instances, which can be improved by setting M larger.

Finally, the results of ALC_IGA under M set to 50, 100, and 150 for five huge instances are also given. The ara238025, lra498378, and lrb744710 are three instances containing hundreds of thousands of nodes, which are the very large-scale integration instances of TSP test data. The Santa, which has 1437195 cities, as a benchmark instance for large-scale TSPs, has been investigated thoroughly by several well-known solvers in [64]. Gaia was published by William Cook in 2019 and includes two million coordinates of stars.

Five evaluation criteria and the averages of them are presented in

Table 8. Results obtained by the ALC_IGA with parallelization on five large instances over $2\times {10}^5$ nodes.

Instance	BKS	M	${\mathit{R}}_{\mathit{best}}$	${\mathit{PD}}_{\mathit{best}}$	${\mathit{R}}_{\mathit{avg}}$	${\mathit{PD}}_{\mathit{avg}}$	${\mathit{R}}_{\mathit{std}}$	${\mathit{T}}_{\mathit{avg}}$	${\mathit{T}}_{\mathit{Rb}}$
ara238025	578,761	50	649,841	12.28	653,160	12.85	1534	242.59	250.69
		100	634,357	9.61	637,414	10.13	1001	392.4	390.87
		150	630,357	9.17	631,805	9.17	905	621.9	587.38
lra498378	2,168,039	50	2,504,137	15.5	2,511,139	15.83	3620	586.65	561.38
		100	2,424,156	11.81	2,431,562	12.15	4526	799.82	822.77
		150	2,398,861	10.92	2,404,857	10.92	4126	1447.49	1241.13
lrb744710	1,611,232	50	1,803,710	11.95	1,806,807	12.14	1553	832.53	856.56
		100	1,773,389	10.06	1,775,519	10.2	1402	1164.27	1209.86
		150	1,756,006	9.09	1,757,731	9.09	1199	1728.67	1718.95
santa1.4M	108,996,000	50	126,452,359	16.02	126,870,650	16.4	282,274	2355.69	2502.04
		100	122,732,785	12.6	123,183,399	13.02	282,164	3403.22	3101.24
		150	121,831,057	11.78	122,134,133	12.05	189,127	5022.14	4812.72
gaia2079471	288,843,524	50	329,200,974	13.97	329,395,175	14.04	106,820	5010.2	4865
		100	322,144,985	11.53	322,360,796	11.6	117,896	5225.05	5377.99
		150	319,244,386	10.58	319,408,762	10.58	86,203	7891.54	7694.04
		50	-	13.944	-	14.252	79,160.2	1805.53	1807.13
Average		100	-	11.122	-	11.42	81,397.8	2196.952	2180.546
		150	-	10.308		10.362	56,312	3342.348	3210.844

. It shows again that the larger the M set, the better the solution obtained and the longer computation time needed. For ALC_IGA50, ALC_IGA100, and ALC_IGA150, the averages of $P{D}_{best}$ are 13.944, 11.122, and 10.308, respectively, which are extremely close to the average of $P{D}_{avg}$. This illustrates the strong stability of ALC_IGA, which the average of $R_{std}$ has also proven. While M was set to 50 or 100, the $1.4\times {10}^6$ nodes instance can be handled within 1 h on our implement, and even the large three-dimensional Gaia can be fixed within 1.5 h. Figure 10 depicts the best solutions obtained by the ALC_IGA with $M=100$.

6. Conclusions and Discussion

Inspired by two-layered [7,51] and three-layered [55] algorithms for TSPs, ALC_IGA with high parallelizability is proposed to solve large-scale TSPs with millions of nodes in this paper. In the first phase, ALC_IGA ensures that all sub-TSPs and sub-WSPs are smaller than the specified size through k-means repeatedly applied, thereby reducing the computation time. In the second phase, the TS_2-opt is developed to rapidly improve the initial solution. The IGA is also proposed for small-scale TSPs and WSPs, with the following significant modifications: the polygynandry-inspired SBHX is designed for high convergence speed; the S_2-opt for balancing convergence speed and falling into local optimum is created. According to the study, the computational complexity of ALC_IGA is between $O(nlogn)$ and $O\left(n^2\right)$.

The numerical results on 42 instances show that the proposed IGA is better than both GA and ACS in terms of convergence speed and accuracy, and it performs better on WSP than on TSP. According to the numerical results on lots of instances from diverse sources, in most conditions, ALC_IGA outperforms TLGA, TLACS, and 3L-MFEA-MP and the novel ER-ACO in terms of precision, stability, and computation speed. The worst situation of ALC_IGA is on the hard-to-solve TSP instances, where the errors are still less than 20% and can be improved by adjusting the parameters.

Mariescu-Istodor and Fränti [64] compared three types of algorithms for solving the large-scale Santa problem within 1 h on an enterprise server without parallelization. They achieved a high-quality solution (111,636 km) using their LKH and grid clustering implement (https://cs.uef.fi/sipu/soft/tspDiv.zip, accessed on 20 March 2023), which outperforms the best result (121,831 km) obtained by ALC_IGA with parallelization. Moreover, it is worth noting that LKH without clustering achieved a 108,996 km solution, which is over 12% better than our result. As a result, we give the following suggestions for future research:

• It is worth combining the adaptive layered clustering framework with LKH and some new techniques in [64] and other references.
• Investigate the impact of different clustering algorithms on the quality of solutions.
• Explore better tuning algorithm to enhance solution quality.
• Extending ALC_IGA to tackle large-scale ATSPs, CTSPs, DTSPs, and other related problems would also be meaningful.