Diversity Management Techniques for the Upper-Bounded Hamiltonian p-Median Problem

Abstract

The Hamiltonian p-median problem (HpMP) generalizes the classical traveling salesperson (TSP) and the Hamiltonian cycle problems. The HpMP aims to find a collection of p non-intersecting cycles that span all the vertices of a given edge-weighted graph $G=(V,E,w)$ while minimizing the sum of the costs of the cycles. This paper introduces a memetic algorithm (MA) with explicit diversity management for the upper-bounded HpMP (UB-HpMP), where upper-bounded means that each cycle in the solution cannot exceed a maximum number of vertices. This MA approaches the problem as a set-partitioning problem, where each cluster of the partition contains the vertices of each cycle. Moreover, it uses a novel crossover operator based on the Hungarian algorithm, exploits the Lin–Kernighan heuristic, a state-of-the-art algorithm for the TSP, and uses best-non-penalized (BNP) selection to explicitly manage the population’s diversity. The proposed MA is tested against state-of-the-art algorithms and classical techniques, including those with and without implicit diversity management, as well as an open-source heuristic solver. The computational experimentation results show that explicit diversity management has advantages over other techniques.

1. Introduction

Given a complete edge-weighted graph $G=(V,E,w)$, the Hamiltonian p-median problem (HpMP) is a combinatorial optimization $\mathcal{NP}$-hard problem that aims to find p cycles that span all the vertices in $V\left(G\right)$ by minimizing the sum of the costs of the cycles [1]. The cycles must be disjoint, which means that a vertex $v\in V\left(G\right)$ cannot be contained in more than one cycle. The HpMP is strongly related to the classical $\mathcal{NP}$-hard traveling salesperson problem (TSP), since they are equivalent in the case of $p=1$.

In addition to the TSP, the HpMP is closely related to other routing optimization problems, such as the multiple traveling salesperson problems (mTSPs). In a nutshell, mTSPs receive as input a complete edge-weighted graph and a positive integer m. The goal is to find m salespersons’ paths that visit all the vertices in $V\left(G\right)$ exactly once and minimize an objective function associated with the edge-weights. In the literature, mTSP variants have been studied based on their characteristics. One of these characteristics is the consideration of depots, which are “special” vertices from which the salespersons depart. Some widely studied mTSP variants in this category are the single-depot case (SmTSP) and the multiple-depot case (MmTSP) [2]. Regarding mTSP variants that do not consider depots, they are known in the literature as depot-free multiple traveling salesperson problems (DFmTSP) [3,4], and in contrast to the depot variants, they have received less attention. Another feature to categorize mTSP variants is the nature of the salespersons’ paths. The two main approaches are closed paths and open paths. In closed paths, salespersons depart, visit a set of vertices, and return to their initial vertex of departure by forming a cycle. The case of open paths is similar, but the salespersons do not return to their initial vertex of departure. Concerning objective functions, the two popular ones adopted in the literature are minsum and minmax [5]. The minsum objective function seeks to minimize the sum of the cost of the salespersons’ paths or cycles. In contrast, minmax minimizes the most expensive path or cycle. According to the nomenclature proposed for mTSPs that do not consider depots (DFmTSP variants) [3], the specific one that considers only closed paths and the minsum objective function is classified as the minsum closed-path depot-free multiple traveling salesperson problem (minsum CP-DFmTSP). This specific variant has the same characteristics and conditions as the HpMP. Thus, the HpMP is considered a special case of the DFmTSP, and both are equivalent to the TSP for $p=m=1$. Despite the HpMP being a fundamental variant among optimization routing problems, it has not been studied as intensively as the TSP and mTSPs with depots.

In general, the HpMP and mTSPs have many applications in logistics, transportation, scheduling, and other fields [6,7,8]. However, there are some scenarios where the HpMP fits better than other routing problems. Some specific scenarios are submarine patrol routing [9], supervisor allocation [10], the hot rolling scheduling problem [11], and the laser multi-scanner problem [12]. Moreover, the HpMP and mTSPs variants may involve additional constraints related to the minimum or maximum number of vertices they can include in their cycles or paths. Such constraints are known in the literature as load-balance constraints or bounding constraints [2]. Upper-bound constraints mean that each cycle allows only a maximum number of vertices.

In the literature, the HpMP and similar routing problems have been approached through various optimization techniques, such as exact algorithms, approximation algorithms, heuristics, and metaheuristics [3]. Among metaheuristic proposals, evolutionary algorithms (EAs) stand out due to their practical advantages in addressing hard optimization problems [13]. In particular, memetic algorithms (MAs) have excelled at solving complex combinatorial problems [14]. However, they often face challenges that can hinder their performance. Premature loss of diversity is a critical issue, and MAs are particularly prone to it [15]. Given this, we hypothesize that explicit diversity preservation mechanisms help MAs find feasible, high-quality solutions for the Hamiltonian p-median problem with upper-bound constraints (UB-HpMP). To validate this hypothesis, we propose a memetic algorithm with explicit diversity management. To better adapt the method to the problem at hand, it incorporates a novel representation of solutions as well as novel genetic operators. One of the main features of our proposal is that it addresses the problem from a set-partitioning problem approach, where each cluster of the partition corresponds to a cycle of vertices. In the literature, this approach is known as group-based representation, and genetic algorithms are one of the outstanding solution methods that use it [16,17]. Additionally, we propose an intensification phase that uses the Lin–Kernighan heuristic [18] as an exploitation mechanism of our MA. Moreover, we emphasize the importance of maintaining appropriate diversity levels in EAs for this problem. For this purpose, to measure the similarity of solutions, we propose the use of a distance metric based on the set-partitioning problem and the Hungarian algorithm [19]. Furthermore, the MA proposed uses additional genetic operators from the literature that have proven effective in approaching other graph optimization problems. Finally, to analyze the importance of diversity in evolutionary algorithms for the UB-HpMP, we used benchmarks from the literature and carried out exhaustive computational experimentation using different diversity mechanisms, including a cellular memetic algorithm (cMA), which implicitly affects diversity.

The rest of the paper is organized as follows: Section 2 presents a review of the literature and related work on the HpMP and mTSP problems, focusing on metaheuristic and evolutionary computing proposals. It also emphasizes the importance of diversity in evolutionary algorithms for optimization problems. Section 3 describes the problem definition and the specific conditions studied in this research. Section 4 introduces our proposal, an evolutionary memetic algorithm with novel components and explicit management of diversity for the UB-HpMP. Section 5 shows the computational experimentation, the parameter setting of the algorithms tested, and discusses the main findings and results. Finally, Section 6 states the conclusions as well as directions for future work.

2. Literature Review

The multiple traveling salesperson problem (mTSP) and its specific cases (including the HpMP) can be viewed as a family of problems, to which we will refer just as the mTSP problems. Thus, this section reviews the most important advances in mTSPs but emphasizes the HpMP. Notably, existing literature often considers the mTSPs and the HpMP to be interchangeable, although they differ conceptually from the concept of depot. Thus, some papers claim to address the mTSP but actually work with the HpMP. This is clarified in detail in [3].

The first integer programs (IPs) for the mTSPs were proposed in 1960–1976 [20,21,22]. It is important to note that these first IPs initially considered the concept of depot. Specifically referring to the HpMP, it was introduced in 1990 as a routing-location problem [1]. Initially, it was studied from a set-partitioning formulation and a vehicle routing problem approach. Later, a polyhedral IP was proposed in 2000, inspired by the laser multi-scanner problem [12]. Over the years, IPs for mTSP and its variants have been improved and extended in order to include additional restrictions for approaching more realistic situations. For instance, [2] improved and extended IPs for mTSPs by introducing bounding constraints, which were very helpful in restricting each salesperson to visit a minimum and a maximum number of vertices. Although such restrictions could be very useful in addressing real-world problems, only a limited number of studies consider these types of constraints. Also, a recent IP and a lower-bound formulation were proposed in [23] for the HpMP. In [3], a nomenclature for depot-free multiple traveling salesperson problems (DFmTSPs) was proposed. Then, various IPs based on the TSP and its extensions were proposed. These IPs were demonstrated to have practical and theoretical advantages, in addition to providing a large enough scope to address multiple DFmTSP cases, including combined problems that consider depots and those that do not. Other exact approaches for the HpMP include a branch-and-price algorithm based on a set-partitioning formulation [24], and recent efforts focus on the development of branch-and-cut algorithms [25,26,27].

As previously mentioned, the HpMP and mTSPs are $\mathcal{NP}$-hard. Thus, in order to try to solve relatively large instances in practical running times, many researchers have focused on heuristic and metaheuristic algorithms. For instance, a constructive heuristic based on dynamic programming has been proposed [25]. Also, a two-phase constructive heuristic that integrates the capacitated vertex k-center problem and the Lin–Kernighan heuristic has been devised [28]. Among the metaheuristic algorithms proposed for the HpMP, evolutionary computing and metaheuristics that are mostly based on advanced local search procedures stand out. Some metaheuristics based on local search include an iterated local search (ILS) that exploits classic intensification TSP heuristics like 1-opt and 2-exchange [25], and a parallel general variable neighborhood search (GVNS) [29]. Regarding evolutionary algorithms, partheno genetic algorithms (PGAs) [30], an evolutionary strategy algorithm that exploits the 3-opt local search [23], and a hybrid genetic algorithm (HGA) [31] have been proposed. Furthermore, some proposals consist of hybridizing evolutionary algorithms with other approaches. Such is the case of [32], where a genetic algorithm is integrated with an invasive weed algorithm (IWO), and [33], where a partheno genetic algorithm and an ant colony-based optimization algorithm are combined; such a proposal is known as AC-PGA (ant colony-partheno genetic algorithm). For the latter, the authors carried out computational experimentation and demonstrated the superiority of the AC-PGA metaheuristic over existing methods, such as the PGAs proposed in [30]. It is interesting to note that ant-inspired algorithms in the literature are claimed to provide efficient solutions for similar routing problems—for instance, the mTSP with capacity and time windows [34], and the multi-objective green vehicle routing problem [35].

It is important to remark that among the proposals for the HpMP and mTSPs, just a few consider bounding constraints over the cycles or paths. In fact, as far as we have reviewed, only the proposals of Zhou et al. [30], Jiang et al. [33], and Cornejo-Acosta et al. [28] consider bounding constraints in their metaheuristic or heuristic proposals.

Finally, some of the advantages that the HpMP has over the classic mTSPs are that classical mTSPs require as input a set of depots (i.e., the depots must be defined in advance). This requirement may be a limitation because, in some practical applications, the location of depots may be unknown or they may not even exist as part of the problem.

2.1. Group-Based Representation in Evolutionary Algorithms

Evolutionary algorithms are a general problem-solving technique for hard search and optimization problems that cannot be solved efficiently with conventional approaches. The design of evolutionary algorithms includes selecting an appropriate representation scheme for the solutions. This is important because some genetic operators, such as crossover and mutation, usually depend on it. Classic representations include vectors of bits; integers; or real numbers, permutations, and tree-based representations in the case of genetic programming [13]. However, a less common approach is the group-based representation, where a set of elements is partitioned into distinct groups or clusters to encode the solution. In combinatorial optimization, many problems naturally align with this paradigm. This concept of using groups in genetic algorithms was introduced by Falkenauer [36] to approach the bin packing, economies of scale, and the conjunctive conceptual clustering problems. Over the years, this paradigm has been extended to other optimization problems in logistics and planning, including some routing problems such as the VRP [37,38]. Thus, we decided to adopt this paradigm in this research. Therefore, the advances in group-based genetic algorithms have led to the development of variation operators designed to work at group levels by considering diverse constraints and conditions. A review of variation operators for group-based problems and genetic algorithms can be found in [17].

2.2. Diversity in Evolutionary Algorithms

In the literature, research on evolutionary computing includes designing mechanisms such as selection, crossover, mutation, and replacement. These elements are crucial because they directly impact the practical performance of evolutionary algorithms. A key to proper performance is to provide a proper balance between exploration and exploitation [39]. In this context, exploration refers to searching in regions not previously explored, while intensification is the process of performing small modifications to the solutions explored so far with the aim of attaining better solutions in regions already explored. Among the genetic operators used in evolutionary computation, the replacement mechanism is of special importance, as it selects the survivors for the next generation. In the literature, some classical replacement mechanisms include generational, truncation (replace worst), and generational with elitism [13]. However, in some situations, these operators do not promote proper maintenance of diversity. Diversity handling techniques are normally used to maintain a good balance between exploration and intensification during the evolutionary process. Thus, maintaining proper diversity management in the evolution process may help to avoid premature convergence. In the literature, proper diversity management has proven to be important in multi-objective and single-objective evolutionary algorithms [40], for continuous optimization [41], and combinatorial optimization [42]. For combinatorial optimization, diversity preservation has been studied for similar routing problems, like the capacitated vehicle routing problem with time windows [43] and TSP [44]. It has been noted that when integrating MAs with the Lin–Kernighan heuristic, special attention must be taken to avoid a premature loss of diversity [45]. Optimization techniques that use diversity management are the leading methods in the state-of-the-art of some combinatorial optimization problems and challenges, such as the linear ordering problem [46], the job scheduling problem [47], and the one-sided crossing minimization problem [48].

Among the techniques in the literature for handling diversity, there are two categories: implicit and explicit [42]. Among the implicit techniques, those that modify the structure of the population are one of the most popular. This category includes evolutionary algorithms that work with structured populations, such as island-based and cellular schemes. Researchers who have studied these approaches have concluded that there exist important implicit effects on diversity preservation, since in these models, the candidate solutions can only interact with other candidate solutions in a defined neighborhood of the structured population. This usually delays convergence. Among the explicit techniques, those that alter the replacement strategy have proven to be very effective. An example is the best-non-penalized (BNP) [40,42]. In summary, the BNP is a replacement operator that promotes diversity of solutions by avoiding choosing similar solutions for the next generation of the algorithm. Thus, a distance metric to measure similarity is also needed. In this research, we propose the use of the BNP that incorporates a distance metric from a set-partitioning problem approach proposed by Gusfield [19]. This is because our MA uses a group-based representation, where the clusters of a partition contain the vertices in the cycles of a solution for the UB-HpMP. Thus, a metric distance for partitions is convenient. Summarizing, the proposal of [19] consists of a metric distance that calculates the minimum number of elements to be removed so the partitions become identical. For this purpose, the assignment problem is used, which can be solved in $O\left(n^3\right)$, where n is the total number of clusters in both partitions. This distance metric can be practical for partitions with a relatively small number of clusters. However, for large cases when the number of clusters significantly increases, this approach may not be feasible due to its complexity. Thus, other partition distance algorithms should be considered. For instance, the 2-approximation algorithm proposed in [49] could be considered, which has complexity $O\left(\rho n\right)$, where $\rho$ is the number of clusters and n is the number of elements in the set to be partitioned. Another interesting proposal is presented in [50], where the distance between two partitions can be computed in $O\left(n\right)$ when certain conditions are met. In this research, the partitions contain a relatively small number of clusters. Hence, our proposal integrates a proposal by Gusfield [19]. In our review, only the proposal of He et al. [31] was found to study the HpMP by considering diversity preservation. It uses the Hamming distance as the metric distance between solutions. However, that research significantly differs from ours in the genetic operators and in the fact that it does not consider bounding constraints.

3. Problem Definition

In this section, we list the fundamental definitions we use in the remaining sections of the paper. First, we define the concept of a closed path or cycle and its cost, which is fundamental in the context of traveling salesperson problems. Then, the notation of solutions for the HpMP and their objective function are defined. Then, we define the set-partitioning notation that we use in our approach for the pseudocodes’ description in the following sections.

Definition 1. 

Given a complete edge-weighted graph $G=(V,E,w)$, a closed path or cycle is a sequence of vertices $s_i=(v_1,v_2,\cdots ,v_{k-1},v_k)$ that starts and ends at the same vertex (i.e., $v_1=v_k$). All the vertices in the cycle are different, except the first. The size of the cycle is the number of vertices or edges and is denoted by $\left|V\right(s_i\left)\right|=k-1$.

Definition 2. 

The cost of a closed path or cycle $s_i$ in a graph $G=(V,E,w)$ is defined through Equation (1).

$$c\left(s_i\right)=\sum _{j=1}^{\left|V\right(s_i\left)\right|}w\left((s_{i,j},s_{i,j+1})\right)$$

(1)

Function w defines the weights of the edges as $w:E\to \mathbb{R}$, and $w\left((s_{i,j},s_{i,j+1})\right)$ is the cost associated with traversing the edge that joins the jth and $j+1$th vertices in cycle $s_i$.

Definition 3. 

A solution for the HpMP over a given $G=(V,E,w)$ is defined as a set of p non-intersecting cycles $s=\{s_1,s_2,\cdots ,s_p\}$ that span all the vertices in $V\left(G\right)$.

Definition 4. 

Given a solution s for the HpMP, the objective value of s is the minsum objective function of Equation (2), which minimizes the sum of the costs of the cycles.

$$minf\left(s\right)=\sum _{i=1}^{p}c\left(s_i\right)$$

(2)

The sum represents iterations through all of the cycles in s.

Definition 5. 

Given a complete edge-weighted graph $G=(V,E,w)$, a partition of $V\left(G\right)$ is defined as a set $\mathcal{V}\left(s\right)=\{V\left(s_1\right),V\left(s_2\right),\cdots ,V\left(s_p\right)\}$, such that ${\displaystyle \bigcup _{i=1}^p}V\left(s_i\right)=V\left(G\right)$, $V\left(s_i\right)\ne \varnothing$, and $V\left(s_i\right)\cap V\left(s_j\right)=\varnothing$ holds for all $V\left(s_i\right),V\left(s_j\right)\in \mathcal{V}\left(s\right)$. Each $V\left(s_i\right)$ is called a cluster and contains the vertices of the cycle $s_i$.

Definition 6. 

Given a solution s for the HpMP and a positive integer U, s is a solution for the upper-bounded HpMP (UB-HpMP) if and only if Constraints (3) hold.

$$\begin{array}{cccccc}& & \hfill & 2\le \left|V\right(s_i\left)\right|\le U\hfill & \hfill & \forall s_i\in s\hfill \end{array}$$

(3)

In this research, we refer to Constraints (3) as the upper-bound constraints, since they restrict cycles so as not to exceed the maximum number of vertices U allowed per cycle. Moreover, the cycles must contain at least two vertices, since empty cycles or singletons are not allowed. Finally, we consider that the upper-bound constraints are tight, that is, $U=\lceil \left|V\right(G\left)\right|/p\rceil$.

4. A Memetic Algorithm for the UB-HpMP

This section introduces our proposal, a memetic algorithm (MA) for the UB-HpMP. It incorporates ad hoc components, such as a crossover operator, a replacement operator, and an intensification phase that uses the Lin–Kernighan heuristic. Another feature of our proposal is that the MA uses an encoding based on the set-partitioning problem, rather than directly searching for cycles. The MA looks for the proper assignment of clusters of vertices without considering the order in which said vertices appear in the cycles. Then, the intensification phase becomes relevant because it determines the order in which the vertices should be visited in the cycles. Thus, the evaluation of the quality of the cycles is also determined in the intensification phase. With the purpose of facilitating reproducibility, we describe the details of the main components of our proposal and provide the source code for our implementations.

Table 1. Notation of pseudocodes.

Section	Symbol	Description
General	p	•Number of cycles in the solution.
	U	•Maximum number of vertices allowed for each cycle.
	$s=\{s_1,s_2,\cdots ,s_p\}$	•Candidate solution composed of p cycles.
	$f\left(s\right)$	•Objective function value of a candidate solution s.
Crossover	$s_i$	•A cycle of a candidate solution s.
	$V\left(s_i\right)$	•Set of vertices (cluster) that compose the cycle $s_i$.
	$\mathcal{V}\left(s\right)$	•Partition of $V\left(G\right)$ composed of p clusters.
Intensification	$t_{elap}$	•Elapsed time of the intensification process.
	$t_{max}$	•Maximum execution time of the intensification process.
	$t_{LKH}$	•Time limit of each LKH call.
	$n_{LKH}$	•Number of LKH calls to be executed in the intensification process.
	$k_i^l$	•A subpath of length l of the cycle $k_i$.
	$c\left(s_i\right)$	•Cost of the cycle $s_i$.
Replacement	$d(s,k)$	•Distance between candidate solutions s and k (Algorithm 6).
	$d(s,P)$	•Distance from a candidate solution s to its closest solution in the population P, i.e., $d(s,P)=min\left\{d\right(s,k):k\in P\}$.
	$D_{init}$	•Initial threshold for diversity; it is initialized as the mean distance between solutions of the population.
	$state\in [0,1]$	•Current state of the evolutionary algorithm being executed. It can be defined as ${\displaystyle \frac{elapsedtime}{totaltime}}$ or ${\displaystyle \frac{currentgeneration}{totalgenerations}}$, depending on the stopping criterion.
	D	•Threshold for diversity in the population.

shows the most relevant notation of the pseudocodes presented in the following subsections.

4.1. General Framework

Algorithm 1 shows the general template of the proposed MA. The MA receives the population size N. In the first line, the function $GenerateInitialPopulation$ is called. This function initializes the population P as follows. First, for each individual of the initial population, the set of vertices is randomly partitioned in such a way that upper-bound constraints are satisfied. This ensures the initial solution is feasible and that the clusters of the partition, which eventually will represent cycles, span the set of vertices. Then, the Lin–Kernighan heuristic is applied to each cluster in the partition to determine the cycles of each initial solution. In the next line, the best solution is saved as $s^{\ast }$. Then, while a stop condition is not met, the following actions take place.

Once the population P is initialized, in line 4, a selection operator is applied to choose the parents $P^{\prime }$. In our proposal, we used binary tournament selection for this purpose. In line 5, the offspring population O is generated from the parents. At this point, the generated offspring may violate the upper-bound constraints. Thus, a balancing method is applied to repair the offspring in line 6. Then, in line 7, the intensification and evaluation phase is executed over the offspring population. This phase aims to define the order in which the vertices are visited in the offspring cycles. The details of this intensification and evaluation phase are described later. Then, the survivor selection phase is executed in line 8. The BNP (Algorithm 7) is used for this purpose. Lines 9–12 maintain the best-found solution of the algorithm.

Algorithm 1: Memetic algorithm template

4.2. Crossover Operator

In our proposal, a central component is the recombination operator. It takes two partitions as input (the parents) and creates a new offspring partition that combines their features. This is achieved by employing the Hungarian-based crossover (HBX), which was recently proposed for the graph partitioning problem [51].

Two features are particularly important in our context:

• Balance: Since the upper bound is tight, the operator should promote balanced partitions.
• Feature retention: To maintain the characteristics of the parents, pairs of vertices that were grouped together in the original partitions should have a higher probability of remaining together in the offspring than those that were not.

The HBX operator promotes these features by first calculating an intersection matrix C (with dimensions $p\times p$), where each element $c_{i,j}$ represents the intersection between cluster i of the first parent and cluster j of the second parent. Each new cluster in the offspring is then generated by joining p of these intersections.

Since each new cluster is the union of the same number of intersections, balanced clusters are promoted. Furthermore, intersections that appear in the same column or row are joined with a higher probability, and the initial positions are selected using the Hungarian algorithm. Consequently, the largest intersections are distributed across different clusters, which further promotes a proper balance and maximizes the number of vertex pairs that share a cluster in at least one parent.

Algorithm 2 shows all the internal details of HBX. First, line 1 starts by creating a complete edge-weighted bipartite graph G through Algorithm 3, where the vertices are the cycles of the parent solutions, and the weights are the number of common vertices between said cycles. Algorithm 3 has a time complexity of $O\left(p^{2}U\right)$, since for each pair of cycles $\{s_i,k_j\}$, computing their intersection can be performed in $O\left(U\right)$. Then, a maximum weighted-matching M is obtained in line 2. This is performed using the Hungarian algorithm, which solves the assignment problem in polynomial time. Note that, in this case, the time complexity of the Hungarian algorithm is $O\left(p^3\right)$, since the constructed bipartite graph has $2p$ vertices. The HBX uses the edges of M to create an offspring partition from the solutions s and k by promoting the creation of new clusters with vertices that are part of the same clusters from the parents. The purpose is to keep clusters of good-quality cycles in the offspring. Each cluster of the offspring must be composed exactly of the union of p intersections of the bipartite graph G. In addition, each edge of M can be used only once. Thus, to avoid repetitions, B (line 3) is used to track the edges used in the recombination process. S and K (lines 4–5) store eligible vertices that will be used to ensure that each offspring cluster is composed exactly of the union of p intersections. In line 6, the offspring partition $\mathcal{V}\left(o\right)$ is first created as empty. Then, each iteration of the for-loop in line 7 will select the vertices that compose the ith cluster of the offspring. Inside this for-loop, the following actions take place. In line 8, an edge in $\{s_i,k_j\}\in M$ is taken and removed from M, and in line 9, the i$th$ cluster of the offspring is initialized as the empty set. Then, lines 11–19 will be executed in odd iterations, whereas lines 21–29 will be executed in even iterations. In odd iterations, endpoint $s_i$ is fixed, and all adjacent unused edges of $s_i$ are used to compose the ith cluster of the offspring (lines 12–15). Finally, if fewer than p edges are available to compose the i$th$ cluster of the offspring, lines 16–19 will ensure that the missing edges are considered to form the i$th$ cluster of the offspring. This is performed by taking endpoint $k_j$ and considering all its unused adjacent edges as eligible vertices in S. Even iterations (lines 21–29) run the same steps but fix the endpoint $k_j$. The time complexity of Algorithm 2 relies on the bipartite graph $G_{p,p}$. As discussed before, this graph is constructed in $O\left(p^{2}U\right)$ in line 1. Then, the maximum weighted matching M is computed in $O\left(p^3\right)$. Then, in the main for-loop of line 7, the most expensive computations rely on the unions and intersections of clusters of size U for each edge in M. Thus, the complexity of this main for-loop is $O\left(p^{2}U\right)$. We conclude that the time complexity of the HBX is $O(p^{2}U+p^3)$. For better comprehension, Table 2 and Table 3 show an example of two parent solutions, s and k, and the weights of the complete bipartite edge-weighted graph formed by said solutions. Figure 1 shows the maximum weighted matching and the execution of the HBX.

Table 2. Two candidate solutions, $s=\{s_1,s_2,s_3,s_4\}$ and $k=\{k_1,k_2,k_3,k_4\}$, for an example instance with $n=24$ vertices, $p=4$ cycles, and $U=6$.

s	k
$s_1=(v_1,v_2,v_3,v_{13},v_{14},v_{15})$	$k_1=(v_4,v_5,v_6,v_{13},v_{19},v_{22})$
$s_2=(v_4,v_5,v_6,v_{16},v_{17},v_{18})$	$k_2=(v_1,v_2,v_3,v_{16},v_{20},v_{23})$
$s_3=(v_7,v_8,v_9,v_{19},v_{20},v_{21})$	$k_3=(v_7,v_8,v_9,v_{14},v_{17},v_{24})$
$s_4=(v_{10},v_{11},v_{12},v_{22},v_{23},v_{24})$	$k_4=(v_{10},v_{11},v_{12},v_{15},v_{18},v_{21})$

Table 2. Two candidate solutions, $s=\{s_1,s_2,s_3,s_4\}$ and $k=\{k_1,k_2,k_3,k_4\}$, for an example instance with $n=24$ vertices, $p=4$ cycles, and $U=6$.

s	k
$s_1=(v_1,v_2,v_3,v_{13},v_{14},v_{15})$	$k_1=(v_4,v_5,v_6,v_{13},v_{19},v_{22})$
$s_2=(v_4,v_5,v_6,v_{16},v_{17},v_{18})$	$k_2=(v_1,v_2,v_3,v_{16},v_{20},v_{23})$
$s_3=(v_7,v_8,v_9,v_{19},v_{20},v_{21})$	$k_3=(v_7,v_8,v_9,v_{14},v_{17},v_{24})$
$s_4=(v_{10},v_{11},v_{12},v_{22},v_{23},v_{24})$	$k_4=(v_{10},v_{11},v_{12},v_{15},v_{18},v_{21})$

Algorithm 2: Hungarian-based crossover (HBX)

Table 3. Weights of bipartite graph generated from the s and k solutions of Table 2.

	${\mathit{k}}_1$	${\mathit{k}}_2$	${\mathit{k}}_3$	${\mathit{k}}_4$
${\mathit{s}}_{\mathbf{1}}$	1	3	1	1
${\mathit{s}}_{\mathbf{2}}$	3	1	1	1
${\mathit{s}}_{\mathbf{3}}$	1	1	3	1
${\mathit{s}}_{\mathbf{4}}$	1	1	1	3

Table 3. Weights of bipartite graph generated from the s and k solutions of Table 2.

	${\mathit{k}}_1$	${\mathit{k}}_2$	${\mathit{k}}_3$	${\mathit{k}}_4$
${\mathit{s}}_{\mathbf{1}}$	1	3	1	1
${\mathit{s}}_{\mathbf{2}}$	3	1	1	1
${\mathit{s}}_{\mathbf{3}}$	1	1	3	1
${\mathit{s}}_{\mathbf{4}}$	1	1	1	3

After the recombination process ends, the offspring generated may violate the upper-bound constraints. Thus, the balancing phase of Algorithm 4 is executed. This algorithm verifies if clusters exist that exceed the maximum number of vertices allowed. If so, a random vertex is extracted from said cluster and inserted into a random available cluster. Regarding complexity, since each element is moved at most once, this simple balancing algorithm has a complexity of $O\left(n\right)$, where n is the total number of vertices in the partition.  

Algorithm 3: Create bipartite graph

Input: Two candidate solutions $s=\{s_1,s_2,\cdots ,s_p\}$ and $k=\{k_1,k_2,\cdots ,k_p\}$ Output: A complete bipartite graph $G_{p,p}$ 1 $E\leftarrow \left\{\{s_i,k_j\}:s_i\in s\wedge k_j\in k\right\}$ 2 $w\leftarrow \left\{\left(\left\{s_i,k_j\right\},|V\left(s_i\right)\cap V\left(k_j\right)|\right):\{s_i,k_j\}\in E\right\}$         //  $w:E\to \mathbb{R}$ 3 $G_{p,p}\leftarrow (s\cup k,E,w)$         // build complete bipartite graph 4 return  G

Figure 1. (a) is the bipartite complete edge-weighted graph formed by solutions s and k, where maximum weighted matching is in bold. (b–e) correspond to the iterations of the HBX. At each iteration, the clusters of the offspring are composed of the intersections of cycles connected with red edges. For this example, the clusters of the offspring are $V\left(o_1\right)=\{v_7,v_8,v_9,v_{19},v_{20},v_{21}\}$, $V\left(o_2\right)=\{v_4,v_5,v_6,v_{17},v_{13},v_{22}\}$, $V\left(o_3\right)=\{v_{10},v_{11},v_{12},v_{23},v_{24},v_{18}\}$, and $V\left(o_4\right)=\{v_1,v_2,v_3,v_{14},v_{15},v_{16}\}$.

Figure 1. (a) is the bipartite complete edge-weighted graph formed by solutions s and k, where maximum weighted matching is in bold. (b–e) correspond to the iterations of the HBX. At each iteration, the clusters of the offspring are composed of the intersections of cycles connected with red edges. For this example, the clusters of the offspring are $V\left(o_1\right)=\{v_7,v_8,v_9,v_{19},v_{20},v_{21}\}$, $V\left(o_2\right)=\{v_4,v_5,v_6,v_{17},v_{13},v_{22}\}$, $V\left(o_3\right)=\{v_{10},v_{11},v_{12},v_{23},v_{24},v_{18}\}$, and $V\left(o_4\right)=\{v_1,v_2,v_3,v_{14},v_{15},v_{16}\}$.

4.3. The Intensification Process

The intensification and evaluation phase (Algorithm 5) represents a crucial element of our approach. It uses the Lin–Kernighan heuristic through the LKH implementation and works as follows. Overall, this phase consists of two different ideas. On the one hand, the first idea is that subpaths are interchanged among the cycles. The motivation behind this idea is to explore solutions, since new cycles with different vertices are created. On the other hand, the second idea involves intensification and exploitation. The latter uses the Lin–Kernighan and the classic cheapest insertion (CI) heuristics to improve the cycles. We now describe the intensification and evaluation phase in detail.

Algorithm 4: Balancing operator

First, the intensification phase is executed for a predefined time $t_{max}$, as enforced by the while-loop in line 2. Then, the boolean function $callLKH$ is evaluated in line 3. This Boolean function aims to ensure the proper distribution of the LKH executions throughout the intensification phase. It determines when $runLKH$ should be invoked and guarantees that it is executed exactly $n_{LKH}-1$ times during the algorithm’s execution to intensify and evaluate solution s. For instance, if the LKH must be executed 5 times (i.e., $n_{LKH}=5$) during all the intensification phase for a total time of $t_{max}=10$ s, the $callLKH$ function ensures that $runLKH$ is executed at the beginning ($t_{elap}=0$ s), and the other times at $t_{elap}=2.5$ s, $t_{elap}=5$ s, and $t_{elap}=7.5$ s respectively. The fifth time will be executed after the main while-loop finishes. Subsequently, the exploration phase is initiated in lines 7 and 8. Here, two cycles of s are chosen randomly and copied. Then, in line 9, a subpath of size l is selected. In our proposal, we choose the value of l as a random integer in the range of Equation (4).

$$l\in \left[1,max\left(1,⌈{\displaystyle \frac{U(t_{max}-t_{elap})}{2t_{max}}}⌉\right)\right]\cap {\mathbb{Z}}^{+}$$

(4)

Choosing the value of l in this way ensures that at the beginning of the intensification phase, longer sizes of subpaths are selected. Then, as the intensification phase progresses, smaller values of l will be selected. In lines 10–13, random subpaths of length l are extracted from the selected cycles and inserted into each other using the CI heuristic. The CI heuristic inserts a vertex into the cycle at the position that yields the smallest possible increase in cost. Then, in lines 14–16, if the cost of the new cycles is lower, they replace the old selected cycles in s. Note that a final call to $runLKH$ is executed after the while loop terminates, ensuring the function is invoked exactly $n_{LKH}$ times.

In summary, Algorithm 5 implements a two-pronged intensification strategy. First, it performs exploration by interchanging subpaths between cycles. Second, this heuristic search is periodically complemented by the Lin–Kernighan heuristic to improve the quality of the cycles. Note that $runLKH$ executes the Lin–Kernighan heuristic over each $s_i\in S$ during running time $t_{LKH}$. Using the Lin–Kernighan heuristic may be computationally expensive. Thus, a small value of $n_{LKH}$ is recommended.

Algorithm 5: Intensity and evaluation

4.4. Replacement Operator

The BNP is a survivor replacement operator that aims to provide proper diversity handling by choosing candidate solutions for the next generation that are sufficiently distant from one another. This is achieved by using a set-partitioning distance metric among the candidate solutions. In addition, at each iteration, the BNP keeps the best candidate solution for the next generation. Thus, it has a certain level of elitism. For the next generation, it tries to select candidate solutions that are specifically at least a certain distance away D from one another. The value of D decreases linearly as the evolutionary algorithm runs. In this way, the algorithm avoids selecting identical or very similar candidate solutions that may cause a loss of diversity in the population. The BNP balances the search toward exploration at initial stages and shifts the balance toward intensification at the end of the optimization process. Thus, premature convergence and other issues, such as becoming stuck in local optima, may be avoided. The distance metric used in our proposal is described in Algorithm 6, which is based on the set-partitioning problem described in [19]. It uses the assignment problem, which can be solved in $O\left(n^3\right)$ by using the Hungarian algorithm. Note that, like in Section 4.2, the time complexity of the Hungarian algorithm is $O\left(p^3\right)$. Thus, the complexity of Algorithm 6 used for the partition distance is $O(p^{2}U+p^3)$. Algorithm 7 shows the pseudocode of the BNP. Regarding the complexity of the BNP, it depends on the population size and on the algorithm used to compute distances between solutions. Within the main while-loop of line 6, we compute the distances from all solutions in A to the survivors set $P^{\prime }$. This can be performed in $O(N{p}^{2}U+N{p}^3)$ if we compute the distances each time a new survivor is added to $P^{\prime }$, where N is the population size. Thus, since the main while-loop is repeated N times, we conclude that the complexity of the BNP is $O(N^2{p}^{2}U+N^2{p}^3)$.

Algorithm 6: Partitions distance

Input: Two candidate solutions s and k Output: Distance between s and k 1 $n\leftarrow$ number of vertices in s 2 $G_{p,p}\leftarrow$ Create bipartite graph with s and k        // Algorithm 3$\phantom{(}$ 3 $M\leftarrow$ maximum weighted matching of $G_{p,p}$ 4 return $n-\sum _{e\in M}w\left(e\right)$

Algorithm 7: BNP

5. Results

We tested the proposed algorithms with a set of ten instances from the literature [52]. The tested instances are kroA100, kroB100, kroC100, kroD100, kroE100, kroA150, kroB150, kroA200, kroB200, pr226, pr264, pr299, and pr439. The tested values of p are in $\{5,10\}$. The tested upper-bound constraints are all tight; that is, the upper bound is set as $U=\lceil \left|V\right(G\left)\right|/p\rceil$.

For comparison purposes, we implemented classical approaches that do not use any diversity management, such as truncation replacement (Trun) and generational replacement (Gen). In addition, we evaluated an implicit diversity mechanism. As discussed earlier, cellular schemes tend to delay convergence; therefore, a cellular memetic algorithm (cMA) version of the proposed approach was also executed on the test instances. The cMA is quite similar to our MA, the difference being that some operators differ due to the nature of the cellular approach. These will be described in the following subsection.

We also implemented the state-of-the-art ant colony-partheno genetic algorithm (AC-PGA) [33]. The AC-PGA is one of the leading approaches for the problem under consideration in this research. This metaheuristic is a hybrid algorithm that combines features of an ant colony-based optimization (ACO) with a partheno genetic algorithm (PGA). It was initially proposed for the minsum CP-DFmTSP with bounding constraints (equivalent to the UB-HpMP). A detailed description of the AC-PGA metaheuristic is beyond the scope of this paper; however, the details of such an algorithm can be found in [33]. All of these methods were implemented in C++ and executed in hardware with an Intel Xeon E5-2620 v2, 32 GB RAM, running a GNU/Linux OS.

To perform a more robust comparison of the methods proposed, we added as a reference the reported results of the two-phase constructive heuristics OHFF/LKH and OHFF+/LKH proposed in [28]. Also, we implemented a software program for the UB-HpMP by using Timefold software [53]. Timefold is an open-source constraint solver written in Java that employs heuristic and metaheuristic algorithms to address scheduling, routing, and other optimization problems. Moreover, we implemented the lower bound formulation proposed in [23]. Summarizing, this lower bound consists of a binary programming formulation (BPF) that relaxes some constraints of the proposed model in [23]. It removes the subtour-elimination constraints, which are common in routing optimization problems, and limits the number of cycles of size two to at most p. Although this lower bound is a BPF, the authors claim that it can be solved to optimality in reasonable computational time, even for large instances. We implemented this lower bound in the open-source SCIP optimization suite through its Python interface PySCIPOpt version 5.7.1 [54]. It is important to emphasize that this lower bound does not incorporate the upper-bound constraints of the problem at hand. Thus, the gap between the computed bounds and the generated solutions might be loose. For a more detailed review of this lower bound, the reader can refer to [23].

5.1. Parameter Setting

The proposed MA is used with the replacement operators BNP, Trunc, and Gen. In every case, binary tournament selection is applied, and no mutation is used. The crossover operator is the HBX described in Section 4.2. The stopping criterion was based on the running time; specifically, it was set to the duration equivalent to 1000 generations of the algorithm.

To determine an appropriate population size, we conducted preliminary experiments for a small set of instances. This experiment was conducted with BNP replacement.

Table 4. Preliminary experimentation with different population sizes.

Instance	n	p	U	$\mathit{PS}=25$	$\mathit{PS}=50$	$\mathit{PS}=75$	$\mathit{PS}=100$
kroA100	100	5	20	22,824	22,824	22,824	22,824
kroB200	200	5	40	30,673	30,651	30,645	30,645
pr299	299	5	60	49,370	49,370	49,364	49,362
				$PS=15$	$PS=30$	$PS=50$	$PS=75$
pr1002	1002	5	201	263,540	262,821	262,475	262,295

reports the results of this study, where each column for $PS$ shows the average of 30 independent executions for a given population size. Overall, larger population sizes tend to provide better results. However, since using larger population sizes increases the computational cost and does not improve the quality of solutions significantly, we decided to use relatively small population sizes. Particularly, for small instances (less than 1000 vertices), $PS=50$ is used, and for larger instances (more than 1000 vertices), $PS=30$ is used.

Regarding the cMA, some parameters differ due to the nature of the cellular approach. For instance, the cMA uses a 1D grid, and the neighborhood used for each cell is the EAST-WEST. In cellular approaches, the defined neighborhood is used for the parent selection procedure instead of conventional operators, such as binary tournament selection. Furthermore, the cMA uses an update policy known as kFLS [55]. In summary, the kFLS is similar to the update-policy fixed line sweep, which is popular in cellular EAs. It works by updating a cell in a grid at each iteration of the algorithm. Then, at the next iteration, the adjacent cell is updated, and so on. In kFLS, k-adjacent cells in the grid are updated at each iteration. According to the experimental results reported in [55], this update policy can maintain a good balance between exploration and exploitation, which may help to delay convergence. Moreover, according to [55], the value of k can influence the performance of the cellular EA. In this experimentation, we empirically calibrated the value of k by executing the algorithm over a couple of instances with multiple values of k, and we concluded that a value of $k=30$ works fine for this specific problem. This algorithm was executed with similar running times to the executions of the proposed MA.

Table 5. Setting the parameters of the AC-PGA metaheuristic [33].

Parameter	Value
Population size	100
AC-PGA iterations	−
ACO iterations	100
$\rho$	0.1
$\alpha$	2
$\beta$	8
$\gamma$	0.5

shows the configuration we used for the AC-PGA, which is based on the configuration recommended by the original authors. The number of AC-PGA iterations was set in such a way that the algorithm was executed for a similar time to the proposed MA.

For the Timefold solver, we used the quickstart for the capacitated vehicle routing problem and adapted the source code and constraints for the UB-HpMP. The parameter setting was the default, and the execution times were the same as the proposed MA. The executions were performed using the same hardware already mentioned with openjdk 25. The version of Timefold used was 1.29.0.

Setting the LKH

As mentioned earlier, an important component of our proposal is the usage of the Lin–Kernighan heuristic through the LKH implementation version 2.0.9. The LKH usage is computationally expensive. Thus, to properly calibrate the LKH usage in our proposal, we needed to analyze two important aspects. The first one is how much execution time is needed for each LKH call. The second one is the number of times the LKH is used to intensify a solution in the MA (the $n_{LKH}$ parameter).

On the one hand, according to the reference of the LKH [18], the construction phase is close to $O\left(n^2\right)$, where n is the total number of vertices in the complete TSP instance. Thus, in our proposal, the computational time needed by the LKH for a given cluster $V\left(s_i\right)$ is set as $t_{LKH}=2\times \alpha {\left|V\left(s_i\right)\right|}^2$, where $\left|V\right(s_i\left)\right|$ is bounded by U. The value of $\alpha$ can be estimated per instance as $\alpha ={\displaystyle \frac{T_{LKH}\left(G\right)}{{\left|V\left(G\right)\right|}^2}}$, where $T_{LKH}\left(G\right)$ is the execution time of the LKH for a given instance G.

Table 6. Parameter settings of the LKH [18].

Parameter	Value
RUNS	1
TIME_LIMIT	$t_{LKH}$
MOVE_TYPE	5
PATCHING_C	3
PATCHING_A	2

shows the configuration we used for each LKH call, which is almost the default configuration. Thus, for the intensification phase (Algorithm 5), the parameter $t_{max}$ is calculated using Equation (5). This way, we ensure that the LKH intensification phase uses computation times comparable to those of the exploration that integrates subpath changes with the cheapest insertion heuristic.

$$t_{max}=\left\{\begin{array}{cc}\underset{\mathrm{LKH}\mathrm{intensification}}{\underbrace{(t_{LKH}·p·n_{LKH})}}+\underset{\mathrm{Exploration}+\mathrm{CI}}{\underbrace{(\alpha U^2·p·n_{LKH})}},\hfill & \mathrm{if}{n}_{LKH}>0\hfill \\ \underset{\mathrm{Exploration}+\mathrm{CI}}{\underbrace{\alpha U^2·p}},\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(5)

On the other hand, to select an appropriate value of $n_{LKH}$, we conducted an exploratory experiment. For this purpose, we selected a small set of instances: kroA100, kroB200, and pr299. Then, we executed preliminary experimentation with different values of $n_{LKH}$ in $\{0,3,6\}$. Note that the initialization process of our MA also uses the LKH. Thus, even when $n_{LKH}=0$, the LKH is still used, but only for the initialization procedure. It is not used in the intensification phase of the MA.

Table 7. Preliminary experimentation with different levels of LKH usage. Columns $n_{LKH}=3$ and $n_{LKH}=6$ include the relative percentage of improvement with respect to $n_{LKH}=0$.

Instance	n	p	U	${\mathit{n}}_{\mathit{LKH}}=0$	${\mathit{n}}_{\mathit{LKH}}=3$		${\mathit{n}}_{\mathit{LKH}}=6$
kroA100	100	5	20	22,825	22,824	0.01%	22,824	0.01%
kroB200	200	5	40	32,256	30,651	4.98%	30,645	4.99%
pr299	299	5	60	51,664	49,370	4.44%	49,362	4.46%

shows the results obtained for this experimentation. In this table, each column of $n_{LKH}$ shows the average of 30 independent executions. We observe that there are considerable differences when LKH is not used as part of the intensification phase of the MA. In contrast, the differences between using $n_{LKH}=3$ and $n_{LKH}=6$ are not remarkable, and this observation is similar for the three tested instances. Thus, we conclude that the usage of LKH is relevant for the proposal, but a large value of it may not be necessary. Furthermore, a larger value of $n_{LKH}$ significantly increases the computational cost. For the complete experimentation, we used a value of $n_{LKH}=3$.

5.2. Analysis of Results

Table 8. Results for some instances of the TSPLIB dataset. For each method, columns $\mu$ is the average of 30 independent runs, $\sigma$ is the standard deviation, and $GAP$ is the average gap relative to the lower bound LB. The best average results, together with those with no significant difference according to the Wilcoxon rank-sum test, are bolded.

Instance	n	p	U	LB	BNP			Trun			Gen			kFLS
					$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$
kroA100	100	5	20	18,521	22,824	0	23%	22,827	9	23%	22,824	2	23%	22,824	0	23%
		10	10	17,920	24,410	0	36%	24,443	74	36%	24,418	25	36%	24,410	0	36%
kroB100	100	5	20	19,469	23,557	0	21%	23,567	23	21%	23,561	15	21%	23,559	11	21%
		10	10	18,412	24,802	0	35%	24,869	71	35%	24,908	67	35%	24,812	31	35%
kroA150	150	5	30	24,268	27,663	0	14%	27,734	70	14%	27,727	73	14%	27,672	26	14%
		10	15	23,487	28,853	0	23%	29,025	176	24%	29,002	141	23%	28,864	51	23%
kroB150	150	5	30	24,065	27,022	0	12%	27,120	90	13%	27,118	99	13%	27,030	29	12%
		10	15	23,183	28,304	0	22%	28,491	131	23%	28,528	143	23%	28,352	81	22%
kroA200	200	5	40	26,455	30,271	0	14%	30,461	202	15%	30,465	182	15%	30,300	76	15%
		10	20	25,744	31,715	11	23%	32,030	240	24%	32,040	258	24%	31,770	88	23%
kroB200	200	5	40	26,866	30,651	16	14%	30,919	168	15%	30,859	123	15%	30,688	34	14%
		10	20	26,286	31,539	74	20%	32,195	287	22%	31,939	257	22%	31,632	137	20%
pr226	226	5	46	54,895	91,378	0	66%	91,948	924	67%	91,632	356	67%	91,418	102	67%
		10	23	54,145	95,210	0	76%	96,136	631	78%	97,311	1117	80%	95,595	329	77%
pr264	264	5	53	36,818	52,956	0	44%	52,969	28	44%	53,271	404	45%	52,956	0	44%
		10	27	36,506	45,261	41	24%	46,094	547	26%	46,471	417	27%	45,345	228	24%
pr299	299	5	60	44,868	49,370	12	10%	49,557	183	10%	49,481	131	10%	49,381	26	10%
		10	30	44,180	50,524	43	14%	51,307	392	16%	51,175	438	16%	50,700	183	15%
pr439	439	5	88	90,735	111,030	31	22%	111,422	318	23%	111,378	377	23%	111,089	81	22%
		10	44	88,489	113,756	140	29%	115,451	1287	30%	114,837	533	30%	114,557	591	29%
Average							27%			28%			28%			27%

and

Table 9. Continuation of Table 8.

Instance	n	p	U	LB	AC-PGA [33]			OHFF/LKH [28]			OHFF+/LKH [28]			Timefold [53]
					$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$	$\mathit{\mu }$	$\mathit{\sigma }$	$\mathit{GAP}$
kroA100	100	5	20	18,521	25,160	462	36%	27,864	1641	50%	23,554	0	27%	23,656	634	28%
		10	10	17,920	26,447	452	48%	36,203	2975	102%	30,895	0	72%	25,168	418	40%
kroB100	100	5	20	19,469	24,644	454	27%	30,112	748	55%	24,821	0	27%	24,116	358	24%
		10	10	18,412	27,311	407	48%	40,930	3799	122%	29,802	0	62%	25,806	386	40%
kroA150	150	5	30	24,268	31,429	454	30%	35,621	2387	47%	31,577	0	30%	28,963	533	19%
		10	15	23,487	33,948	599	45%	44,823	2764	91%	40,862	0	74%	29,974	402	28%
kroB150	150	5	30	24,065	31,235	428	30%	33,882	3070	41%	29,224	0	21%	28,663	606	19%
		10	15	23,183	33,730	724	45%	46,986	5241	103%	35,186	0	52%	29,502	528	27%
kroA200	200	5	40	26,455	35,763	512	35%	37,381	1257	41%	32,284	0	22%	31,944	511	21%
		10	20	25,744	39,131	592	52%	46,134	3568	79%	35,367	0	37%	33,204	516	29%
kroB200	200	5	40	26,866	35,768	435	33%	36,795	1159	37%	34,059	0	27%	32,328	650	20%
		10	20	26,286	37,992	863	45%	47,045	4401	79%	36,715	0	40%	33,323	423	27%
pr226	226	5	46	54,895	105,698	1181	93%	118,669	9377	116%	107,812	0	96%	99,464	3159	81%
		10	23	54,145	111,017	1906	105%	152,624	17,007	182%	125,730	0	132%	97,636	2715	80%
pr264	264	5	53	36,818	58,829	719	60%	60,864	443	65%	60,552	0	64%	55,556	1768	51%
		10	27	36,506	53,297	643	46%	58,201	7412	59%	51,762	0	42%	45,546	195	25%
pr299	299	5	60	44,868	58,608	835	31%	56,996	2044	27%	54,629	0	22%	51,813	1027	15%
		10	30	44,180	63,706	851	44%	72,845	5111	65%	67,588	0	53%	52,786	897	19%
pr439	439	5	88	90,735	134,433	1992	48%	121,844	3746	34%	118,061	0	30%	117,953	1562	30%
		10	44	88,489	142,904	1938	61%	167,431	13,625	89%	145,451	0	64%	122,703	2607	39%
Average							48%			74%			50%			33%

show the results of the methods tested using the instances described. Column LB refers to the lower bound proposed in [23], which serves as a reference. Columns BNP, Trun (truncation), and Gen (generational) correspond to the proposed MA with different replacement mechanisms. Column kFLS corresponds to the cellular MA. Columns $\mu$ and $\sigma$ of each method represent the average and standard deviation of 30 independent runs with different seeds. The values were rounded to their closest integer. The column $GAP$ corresponds to the average gap with respect to the lower bound; it is computed as $GAP=(\mu /\mathrm{LB}-1)·100\%$.

Based on these results, the proposed MA, whose diversity is managed explicitly through the BNP replacement strategy, outperformed the other approaches. This can be explained by some factors. First, the averages of the solutions obtained were lower than those of the other methods in most of the ten instances tested. Second, in some of the instances, the standard deviation tends to be lower, or even zero. This implies the stability of the proposals, which is important in scenarios where not many executions can be carried out. Lastly, the $GAP$ of the methods that integrate a diversity management technique (BNP and kFLS) yielded lower values. These methods demonstrated the ability to find solutions that are at most 27% above the optimal solution. It is important to note that, although this lower bound is the most recent reported in the literature to the best of our knowledge, it does not consider important constraints of the problem at hand. Therefore, the values obtained using this lower bound may be quite loose with respect to the actual optimal solutions. Regarding Table 9, the Timefold solver outperformed the OHFF/LKH and OHFF+/LKH constructive heuristics and the AC-PGA metaheuristic in most of the cases. This finding is of interest from a practical perspective. Timefold is a general purpose solver, whereas the other methods were specifically designed for the UB-HpMP. Typically, specialized algorithms are expected to outperform general purpose solvers; thus, this suggests that the latter can be a viable alternative for benchmarking and validation of new algorithmic proposals.

Furthermore, the statistical differences in the good-quality solutions found using the tested approaches were validated using the non-parametric Wilcoxon rank-sum test, as shown in

Table 10. Wilcoxon rank-sum ranking test.

Method	Score
BNP	66
kFLS	45
Trun	$-14$
Gen	$-17$
AC-PGA	$-80$

. This table shows the results of applying a ranking test for the BNP, kFLS, Gen, Trun, and AC-PGA methods. The confidence value is $95\%$. We confirm that the proposal utilizing the explicit diversity management technique BNP yielded the best results, followed by the cellular approach, which employs an implicit diversity management technique. In contrast, the proposals that do not use management diversity yielded the lowest scores.

Figure 2 and Figure 3 show the average convergence behavior of the algorithms tested for instances pr299 and pr439 for 30 independent executions. These figures show that the AC-PGA and the constructive heuristics OHFF/LKH and OHFF+/LKH yielded the worst results. For the AC-PGA metaheuristic, this may be due to the lack of a proper balance between exploration and exploitation, which will be discussed later. In addition, we can observe in Figure 2b and Figure 3b that proposals using any management diversity technique obtained the best results. In particular, the proposal that uses the BNP started the first iterations with worse solutions than the other methods. Still, after considerable progress in the evolution process, it eventually equaled and then outperformed the others. According to the literature, the same behavior occurs in other combinatorial optimization problems.

Figure 4 shows the average diversity behavior of the evolution process for the methods tested, for the 30 independent executions. A premature loss of diversity is observed for the methods that use truncation and generational replacement operators. This is expected for the truncation replacement, since it has high pressure selection and high elitism levels. The AC-PGA seems to successfully promote exploration; however, this metaheuristic seems to lack an effective exploitation mechanism, since no quality solutions are found in comparison with the other methods. This could be explained by the fact that the components used for AC-PGA, such as mutation, are very disruptive, which may cause diversity to become stuck and not decrease in all of the algorithm iterations. The kFLS method has more proper diversity management. It starts with a large diversity, and it decreases across the evolution process. However, although diversity initially decreases rapidly, high diversity levels are maintained throughout the complete evolution process. Lastly, the proposal that uses the BNP starts with high diversity levels. These levels are maintained over 35–40% of the execution time, and then decrease linearly across the evolution process. This controlled diversity reduction promotes extensive exploration during the early stages of the algorithm and intensified exploitation in later stages, resulting in a good balance for obtaining good-quality solutions.

Figure 5 shows the box plots obtained from the 30 independent executions of each method for the pr299 and pr439 instances. We can make similar observations to the previous ones. The AC-PGA tends to have worse solutions than the other methods. Moreover, the methods that use management diversity techniques, the BNP and the kFLS, tend to find better quality solutions, in addition to a more stable behavior. These observations support the stated conjecture that proper handling of diversity matters when attempting to solve the UB-HpMP.

Table 11. Best-found solutions for use as a reference. Column BNP (Best) represents the best-found solution of 30 independent runs of the MA with BNP replacement strategy. $GAP$ column represents the relative gap of the best-found solution to the lower bound.

Instance	n	p	U	BNP (Best)	$\mathit{GAP}$
kroA100	100	5	20	22,824	23%
		10	10	24,410	36%
kroB100	100	5	20	23,557	21%
		10	10	24,802	35%
kroA150	150	5	30	27,663	14%
		10	15	28,853	23%
kroB150	150	5	30	27,022	12%
		10	15	28,304	22%
kroA200	200	5	40	30,271	14%
		10	20	31,709	23%
kroB200	200	5	40	30,644	14%
		10	20	31,512	20%
pr226	226	5	46	91,378	66%
		10	23	95,210	76%
pr264	264	5	53	52,956	44%
		10	27	45,213	24%
pr299	299	5	60	49,361	10%
		10	30	50,502	14%
pr439	439	5	88	110,981	22%
		10	44	113,601	28%
pr1002	1002	5	201	262,099	8%
		10	101	264,117	10%
pr2392	2392	5	479	383,698	−
		10	240	391,337	−
Average					26%

shows the best-found solutions of 30 independent executions for the instances tested. We included two additional instances, pr1002 and pr2392. For instance pr1002, we were able to compute the lower bounds and $GAPs$ in approximately 15 h. For instance pr2392, we were not able to compute the lower bounds. The table shows the solutions found by the MA with the BNP replacement strategy. These results are intended to be a reference for the best-known solutions under the constraints for the specific problem studied in this paper, the UB-HpMP.

The stated hypothesis is supported by all of these empirical observations. For instance, the methods that include implicit or explicit diversity mechanisms found the best solutions in all of the ten instances from Table 8 and Table 9. This fact was confirmed through the Wilcoxon rank-sum test of Table 10, where the proposal that uses the BNP mechanism obtained the highest ranking, and the proposal that uses implicit diversity handling was the second. Thus, this suggests that EAs that use explicit diversity management outperform EAs with implicit diversity management, and these in turn outperform approaches that do not manage diversity.

6. Conclusions

In this paper, we studied the upper-bounded Hamiltonian p-median problem (UB-HpMP), a special case of the depot-free multiple traveling salesperson problem (DFmTSP). In the literature, the UP-HpMP has received less attention than other similar routing problems. We stated the hypothesis that proper diversity handling matters and can lead to finding good-quality solutions for this problem. We proposed a memetic algorithm with novel components, including an intensification phase that exploits the Lin–Kernighan heuristic, an explicit diversity management component, and other novel genetic operators that have proven effective in approaching hard graph optimization problems. The proposal was validated through exhaustive computational experimentation and compared against classic approaches and proposals from the literature, including a general purpose open-source solver. The results show that evolutionary algorithms with diversity preservation outperform other techniques, which supports the stated hypothesis.

Still, there are gaps regarding the theoretical and practical aspects of optimization techniques that may be worked on for the UB-HpMP in the future. For instance, the methods proposed empirically demonstrated the ability to find feasible and near-optimal solutions that are at most 27% above the optimal solution on average. Still, these solutions may be closer to the optimal solutions since the lower bound used does not consider the upper-bound constraints of the cycles that we considered in the problem at hand. Thus, an outstanding issue is to demonstrate that these solutions are actually closer to the optimal solutions, or even propose better lower bounds for the HpMP that consider these constraints. A further avenue of future work is a better integration and a calibration methodology for the LKH (implementation of the Lin–Kernighan heuristic). This may accelerate and improve the performance and running time of evolutionary algorithms for the UB-HpMP and other routing problems. Also, the development of new genetic operators, such as mutation operators or local search methods for the UB-HpMP, would be useful. Finally, as noted in this research, the partition-distance computations do not affect the proposal’s computational cost due to the small values of p considered. However, significantly larger values of p would increase the computational cost. For this case, we consider the possible integration of faster algorithms for computing partition distances as future work. In particular, we believe the algorithms described in [49,50] offer a promising solution to this scalability issue.