A Multi-Phase Method for Euclidean Traveling Salesman Problems

Abstract

The Traveling Salesman Problem (TSP) aims to find the shortest tour for a salesman who starts and ends in the same city and visits the remaining $n-1$ cities exactly once. There are a number of common generalizations of the problem including the Multiple Traveling Salesman Problem (MTSP), where instead of one salesman, there are k salesmen and the same amount of individual tours are to be constructed. We consider the Euclidean version of the problem where the distances between the cities are calculated in two-dimensional Euclidean space. Both general the TSP and its Euclidean version are strongly NP-hard. Hence, approximation algorithms with a good practical behavior are of primary interest. We describe a general method for the solution of the Euclidean versions of the TSP (including MTSP) that yields approximation algorithms with a favorable practical behavior for large real-life instances. Our method creates special types of convex hulls, which serve as a basis for the constructions of our initial and intermediate partial solutions. Here, we overview three algorithms; one of them is for the bounded version of the MTSP. The proposed novel algorithm for the Euclidean TSP provides close-to-optimal solutions for some real-life instances.

1. Introduction

The Traveling Salesman Problem (TSP) is an NP-hard problem, as proven by Karp in 1972 [1]. It aims to construct a tour for a salesman who must visit n clients or cities, each of them exactly once, except that the first visited city is repeatedly visited at the end of the tour. The objective is to minimize the overall incurred distance. We shall rely on the following graph-theoretical formulation of the problem. We are given an undirected weighted complete graph $G=(V,E)$, where the vertices from set V are identified as the clients or cities and the edges from set E represent connections between these cities, so that their weights represent the corresponding distances; i.e., for every $(i,j)\in E$, the weight $\mathrm{w}(i,j)$ is the distance between cities i and j. We consider the Euclidean setting of the problem, where the distances between the cities are calculated in a two-dimensional plane, the cities being represented as points in that plane. Therefore, we treat the vertices from set V as points in the two-dimensional plane and edges as vectors in that plane. In this way, we deal with a kind of projection of graph G in the two-dimensional plane. Note that the Euclidean TSP is symmetric, i.e., for any edge $(i,j)$, $\mathrm{w}(i,j)=\mathrm{w}(j,i)$.

A permutation of the n points defines a feasible tour $T=(i_1,\cdots ,i_n,i_1)$ in the two-dimensional plane. The cost of tour T, $\mathrm{C}\left(T\right)$ is

$$\mathrm{C}\left(T\right)=\mathrm{w}(i_1,i_2)+\mathrm{w}(i_2,i_3)+\cdots +\mathrm{w}(i_{n-1},i_n)+\mathrm{w}(i_n,i_1)$$

(1)

The objective is to find a feasible solution $T^{*}$ whose cost $\mathrm{C}\left(T^{*}\right)$ is the minimum, i.e., $\mathrm{C}\left(T^{*}\right)={min}_T\mathrm{C}\left(T\right)$.

The Multiple Traveling Salesman Problem (MTSP) is a generalization of the TSP, which deals with $k\ge 1$ salesmen and a specific city d called the depot. Correspondingly, k different tours are to be constructed such that each tour starts and ends at the depot. The bounded version of the MTSP (BMTSP) imposes a restriction on the number of cities each tour has to include where a feasible solution consists of k tours $\{T^1,T^2,\cdots ,T^k\}$, where

$$T^j=(d,i_1^j,i_2^j,\cdots ,i_{m_j}^j,d)$$

(2)

An integer $m_j$ is the number of cities that tour $T^j$ has to include such that $m_1+m_2+\cdots +m_k=n$.

The cost of a feasible solution $\{T^1,T^2,\cdots ,T^k\}$ is

$$\mathrm{C}\left(\{T^1,T^2,\cdots ,T^k\}\right)=\mathrm{C}\left(T^1\right)+\mathrm{C}\left(T^2\right)+\cdots +\mathrm{C}\left(T^k\right)$$

(3)

The aim in studying the BMTSP with several salesmen and with upper and lower bounds on the number of clients for each salesman is not actually to attain a better total cost compared to the case when a single salesman is used. The  motivation here is to reduce the time needed to serve all the clients taking into account the limited capacity of each salesman (vehicle). Hence, an upper bound on the number of clients for every salesman is imposed, where a lower bound somehow “balances” the minimal load for each salesman. These considerations were first reported by Roerty [2] and later detailed by Necula [3].

In this study, we focus on the Euclidean version of the TSP, which remains strongly NP-hard [4]. Nevertheless, it is more “transparent” than the general version, in the sense that simple geometric considerations can be used in a solution process of the Euclidean version (see, e.g., [5]). Here, we describe our method, based on simple geometric observations, and three simple, fast, and easily implementable direct combinatorial algorithms yielded by the method.

Our method uses special types of convex hulls, which serve as a basis for the constructions of our initial and intermediate partial solutions. A basic type of convex hull that we employ is a girding polygon P [6], the minimal convex polygon that includes all points from set V, a convex hull for set V.

The method starts with a (partial) tour defined by the girding polygon P. If this tour is complete, i.e., contains all points from set V, then it is also an optimal tour. Otherwise, yet uncovered cities are iteratively added to the current partial solution until a feasible solution is constructed. This feasible solution is further improved using local search algorithms. This framework for the TSP is extended for the BMTSP using a preliminary stage that partitions the points from set V into k feasible subsets. The second proposed algorithm for the Euclidean TSP constructs convex hulls for the subsets of vertices from set V, convex polygons. These polygons may intersect each other. Every created polygon defines a partial tour. Iteratively, a partial tour defined by the polygon of a current iteration is unified with the partial tour of the previous iteration, resulting in the partial tour of the current iteration. In this way, the polygons and the tours are iteratively “inflated”.

We found a few algorithms that also use convex hulls in one way or another. For example, Macgregor and Ormerod in 1996 [7] tested the hypothesis that the difficulty of solving a TSP for humans is a function of the number of interior points of the corresponding girding polygon. They designed two experiments with instances of the TSP. The first experiment used instances with ten points, and the second one used instances with twenty points in total. These instances were solved by a group of people manually. These solutions were compared with the solutions obtained by three common heuristics, the nearest neighbor algorithm, the largest interior angle algorithm (Norback and Love in 1977 [8]), and a variation of a convex hull heuristic described by Golden et al. in 1980 [9] using the least expensive insertion criterion. Notably, the manually obtained solutions turned out to be better than the ones created by the heuristics. Sengupta and Fränti [10] continued this line of research, measuring the dependence of the complexity of the solutions obtained by the humans on the number of interior points of the polygon.

We also found several algorithms in the literature for the construction of a girding polygon. The algorithm from Andrew [11] reorders the set of vertices according to their x and y coordinates, which are used in the algorithm for the construction of the girding polygon. In [6,8,12,13,14], The girding polygon is constructed based angles of the girding polygon based on the calculation of specially determined angles. In [15,16,17], the set of vertices were iteratively partitioned into two subsets separated with a line, formed by the two specially determined points. The furthest from the constructed line vertex of one or the other subset was identified as the next point that was be included in the formed girding polygon. In [18,19,20], the construction algorithms that use “divide and conquer” techniques was presented, where a merge algorithm for two non-intersecting convex hulls was recursively applied.

Our algorithm for the construction of the girding polygon, can briefly be described as follows. It initially identifies four specially determined auxiliary points on the plane, one of which forms the partial polygon of the initial iteration 1. The girding polygon is formed in $\nu$ consecutive iterations, where $\nu \le n$ is the number of vertices of polygon P. At each iteration $h>1$, a subset of vertices from set V is associated with each of the auxiliary points. This division of the set V at iteration h is performed according to the coordinates of the four auxiliary points and the coordinates of the point added to the partial polygon at iteration $h-1$. At iteration h, a new point from one of the four subsets is added to the partial polygon of iteration $h-1$. This new point is chosen based on some geometric calculations. A brief description of this algorithm was originally given in [6], where MTSP is solved in two phases. In the first phase, after the construction of girding polygon P, set V is partitioned into k subsets using specially defined k auxiliary edges $(d,x)$, here $x\in P$ and k is the number of salesmen. An algorithm is proposed for the construction of a feasible tour for TSP, that is applied for each of the subsets at the second phase.

Next, we give a brief overview of some related work and applications. Jünger, Reinelt, and Rinaldi [21] published an overview in which they described applications of the TSP in real-life problems and exposed different heuristics and approximation algorithms. Possible applications occur in the drilling of printed circuit boards, in the analysis of the structure of crystals (Bland and Shallcross [22]), during material handling in a warehouse (Ratliff and Rosenthal [23]), in overhauling gas turbine engines (Plante, Lowe, and Chandrasekaran [24]), in the order-picking problem in warehouses (Ratliff and Rosenthal [23]), in  constructing computer boards to optimize the connections between different board components, and in scheduling problems where job process times are sequence-dependent (Lenstra and Rinnooy Kan [25]).

Bektas [26] described different existing variants of the MTSP and their relationship with other problems; he also mentioned some other practical applications. Cheikhrouhou and Khoufi [27] published a comprehensive survey in which they included the approaches applied to unmanned aerial vehicles and/or drones; they also classified some practical applications for the MTSP: monitoring and surveillance, network connectivity, search and rescue, precision agriculture, and disaster management. Other applications arise in scheduling a printing press (Gorenstein [28]), in mission planning (Brumitt and Stentz [29]), in interview scheduling (Gilbert and Hofstra [30]), in crew scheduling, in school bus routing [31], in cash distribution in banks, and in recollecting cash from telephone booths and their repair (see Svestka and Huckfeldt [32] and Lenstra and Rinnooy Kan [25]). Other applications occur in the planning of autonomous robots (Yu et al. [33]) and in planning of unmanned aerial vehicle applications (Ryan et al. [34]). An application of the MTSP arises in the optimal design of global navigation satellite systems (Saleh and Chelouah [35]). As for the bounded version BMTSP, there exist meta-heuristic algorithms for its solution (see, for example, [3,36,37,38,39,40]).

We conclude this section with a brief description of how this paper is organized. In Section 2, we describe our general method and three particular algorithms that we constructed so far using our method. In Section 2.1, we give a detailed description of our algorithm that generates the girding polygon P. In Section 2.2, the insertion algorithm from [5] is described. We describe our basic algorithm for the BMTSP in Section 2.3, and we present another novel inflammation algorithm in Section 2.4. Section 3 presents the results of our experimental study. The last Section 4 contains some concluding remarks.

Part of the material from this work was presented at the 1st International Online Conference on Algorithms (IOCA 2021) (see [41,42]).

2. Methods

2.1. Construction of Girding Polygon P

Our girding polygon P can be seen as a convex geometric figure in 2-dimensional Euclidean space with the edges from the projection of graph G enclosing all vertices of set V. Polygon P can also be seen as a sub-graph of graph G. Note that polygon P immediately defines an optimal tour $T_0$ for its $\nu$ vertices. Our construction algorithm iteratively extends this tour until it creates a complete feasible tour.

Figure 1 represents a small problem instance “tsp10” with 10 vertices, which we use for the illustration purposes throughout this paper.

Our algorithm for the construction of the girding polygon P works in a number of iterations, $P_h$ being the partial polygon (polygonal line) of iteration h. Iteratively, at iteration h, one vertex, denoted by $p_h$, is added to the partial polygon $P_{h-1}$ of iteration $h-1$, i.e., $P_h=P_{h-1}\cup \left\{p_h\right\}$ (abusing again the notation, we also use $P_h$ for the set of vertices in polygon $P_h$).

Let $i\in P_{h-1}$ and $j\in V\backslash P_{h-1}$, and let $(i,j)\in E$ be the corresponding vector (edge) in 2-dimensional Euclidean space. The algorithm for the construction of polygon P uses function $\theta (i,j)$ (Equation (4)), which returns the angle between axes $y=y_i$ and vector $(i,j)$; see Figure 2.

$$\theta (i,j)=\left\{\begin{array}{cc}\hfill arccos\frac{x_j-x_i}{\mathrm{w}(i,j)}& ifarcsin\frac{y_j-y_i}{\mathrm{w}(i,j)}\ge 0\hfill \\ \hfill -arccos\frac{x_j-x_i}{\mathrm{w}(i,j)}& ifarcsin\frac{y_j-y_i}{\mathrm{w}(i,j)}<0\hfill \end{array}\right.$$

(4)

Now, we turn to the description of the main algorithm that constructs polygon P. It works in four stages, each stage being associated with one of the specially determined auxiliary points in 2-dimensional Euclidean space. We denote these auxiliary points by $v^1$, $v^2$, $v^3$, and $v^4$ and will refer to them as the “uppermost”, the “leftmost”, the “lowermost”, and the “rightmost” points, respectively [6]; see Figure 3. More formally,

$$\begin{array}{cc}\hfill v^1& =j_1|x_{j_1}ismaximumand{j}_1\in \left\{i_1\right|y_{i_1}ismaximumand{i}_1\in V\}\hfill \\ \hfill v^2& =j_2|y_{j_2}ismaximumand{j}_2\in \left\{i_2\right|x_{i_2}isminimaland{i}_2\in V\}\hfill \\ \hfill v^3& =j_3|x_{j_3}isminimaland{j}_3\in \left\{i_3\right|y_{i_3}isminimaland{i}_3\in V\}\hfill \\ \hfill v^4& =j_4|y_{j_4}isminimaland{j}_4\in \left\{i_4\right|x_{i_4}ismaximumand{i}_4\in V\}\hfill \end{array}$$

Below, we illustrate how the four auxiliary points are determined for our problem instance “tsp10”.

Roughly, some points located in between points $v^1$ and $v^2$ are added at stage 1; some points located in between points $v^2$ and $v^3$ are added at stage 2; some points located in between points $v^3$ and $v^4$ are added at stage 3; some points located in between points $v^4$ and $v^1$ are added at stage 4. Correspondingly, the whole polygon area is divided into four subareas $V^l$, $l=1,\cdots ,4$, defined as follows:

$$\begin{array}{ccc}\hfill V^1& =\left\{k\right|x_k<x_{p_{h-1}}\wedge y_k\ge y_{v^2}\hfill & \hfill ;k\in V\}\\ \hfill V^2& =\left\{k\right|x_k\le x_{v^3}\wedge y_k<y_{p_{h-1}}\hfill & \hfill ;k\in V\}\\ \hfill V^3& =\left\{k\right|x_k>x_{p_{h-1}}\wedge y_k\le y_{v^4}\hfill & \hfill ;k\in V\}\\ \hfill V^4& =\left\{k\right|x_k\ge x_{v^1}\wedge y_k>y_{p_{h-1}}\hfill & \hfill ;k\in V\}\end{array}$$

The algorithm works in a number of iterations. Initially, $P_0=\left(v^1\right)$, i.e., the initial partial polygon (polygonal line) consists of the uppermost vertex $v^1$. At stage l, at iteration $h>0$, $p_h\in V^l$ is the vertex, added to the set $P_{h-1}$, resulting in an augmented polygonal line (set) $P_h$ of iteration h. In particular, vertex $p_h\in V^l$ is such that

$$\theta (p_{h-1},p_h)=\underset{j\in V^l}{min}\theta (p_{h-1},j).$$

Omitting some minor details, below, we give a formal description of the algorithm and its flowchart (Figure 4):

We illustrate the flowchart of Algorithm 1 ($GIRDIN{G}_{-}POLYGON$) for the problem instance “tsp10” in

Table 1. Iterations performed by the Algorithm 1 ($GIRDIN{G}_{-}POLYGON$) for the construction of the girding polygon P for the example instance “tsp10”.

h	l	${\mathit{p}}_{\mathit{h}-1}$	${\mathit{v}}^{\left(\mathit{l}\mathit{mod}4\right)+1}$	Condition	${\mathit{V}}^{\mathit{l}}$	${\mathit{p}}_{\mathit{h}}$	${\mathit{P}}_{\mathit{h}}:={\mathit{P}}_{\mathit{h}-1}\cup \left\{{\mathit{p}}_{\mathit{h}}\right\}$
0						6	$\left(6\right)$
1	1	6	4	$6\ne 4$?: True	$\{1,10,4\}$	10	$(6,10)$
2	1	10	4	$10\ne 4$?: True	$\left\{4\right\}$	4	$(6,10,4)$
3	1	4	4	$4\ne 4$?: False
3	2	4	8	$4\ne 8$?: True	$\{7,8,9\}$	7	$(6,10,4,7)$
4	2	7	8	$7\ne 8$?: True	$\left\{8\right\}$	8	$(6,10,4,7,8)$
5	2	8	8	$8\ne 8$?: False
5	3	8	5	$8\ne 5$?: True	$\{1,2,3,5\}$	3	$(6,10,4,7,8,3)$
6	3	3	5	$3\ne 5$?: True	$\{2,5\}$	2	$(6,10,4,7,8,3,2)$
7	3	2	5	$2\ne 5$?: True	$\left\{5\right\}$	5	$(6,10,4,7,8,3,2,5)$
8	3	5	5	$5\ne 5$?: False
8	4	5	6	$5\ne 6$?: True	$\left\{6\right\}$	5	$(6,10,4,7,8,3,2,5,6)$

. Column “h” is the current iteration, “l” is the current stage, and “condition” reflects the “while” condition.

In Figure 5, we illustrate the flowchart of Algorithm 1 ($GIRDIN{G}_{-}POLYGON$) in graphical form for the same problem instance.

Algorithm 1: $GIRDIN{G}_{-}POLYGON$ (V).

2.2. The Basic 3-Phase Insertion Algorithm for TSP

In this section, we overview a 3-phase algorithm from [5]. It starts with phase 1 by constructing girding polygon P as described in Section 2.1. Recall that this polygon defines an initial (partial) tour $T_0$. If that tour is complete, i.e., contains all vertices from set V, then nothing remains to be done; the algorithm halts with this optimal tour. Otherwise, this tour is iteratively extended at phase 2 by Algorithm 2 (see Figure 6).

Let $T_h$ be the partial tour constructed by iteration h. The algorithm iteratively, at iteration $h>0$, inserts a new, yet non-covered vertex $l^h\in V\backslash T_{h-1}$ into the current tour $T_{h-1}$, one that yields the minimal increase in the cost of the formed extended tour $T_h=T_{h-1}\cup \left\{l^h\right\}$ of iteration h (abusing slightly the notation, here and later, we may use $T_h$ for the set of vertices from tour $T_h$). The insertion algorithm stops when it constructs a complete feasible tour including all vertices from set V. In the figure below, we illustrate how the algorithm works for our problem instance.

Figure 7 illustrates the three iterations of the insertion algorithm for our problem instance “tsp10” with 10 vertices. Here, $T_0=(6,10,4,7,8,3,2,5,6)$. At iteration 1, the costs $C_9^1$ and $C_1^1$ are calculated, and the vertex 9 is inserted between the vertices 7 and 8 since $C_9^1<C_1^1$; see Figure 7b. At iteration 2, $C_1^2$ is (re)calculated and the vertex 1 is inserted between vertices 5 and 6; see Figure 7c. Hence, a feasible solution $(6,10,4,7,9,8,3,2,5,1,6)$ is delivered. The pseudo-code of the insertion algorithm and its flowchart are given below.

Algorithm 2: $INSERTION$(V).

    At phase 3, the algorithm iteratively improves the solution delivered by phase 2 using a specially constructed local improvement algorithm.

As is easy to verify, phase 1 runs in time $O\left(n\nu \right)$, where $\nu$ is the number of vertices of the polygon P. Phase 2 needs at most $n-3$ iterations, where the selection cost at each iteration is $O\left(n\right)$. The improvement phase has an amortized time complexity of $O\left(n^2\right)$.

2.3. Partition, Construction, and Improvement Algorithm for the BMTSP

This section contains a brief description of our algorithm for the bounded version of the MTSP, BMTSP [42], this algorithm, roughly, extends the insertion algorithm for the TSP from the previous section with an additional partition phase. Our partition method adopts and modifies one from [6].

At the partition phase, we partition set $V\backslash \left\{d\right\}$ in k subsets $V_1,V_2,\cdots ,V_k$ such that each subset respects the problem restriction, i.e.,  the number of vertices in each of them is within the range $[m_{min},m_{max}]$).

Our partition algorithm first defines an auxiliary point c with the coordinate $x_c$ ($y_c$, respectively) being the average of the x-coordinates (y-coordinates, respectively) of the vertices from set V:

$$x_c=\frac{{\sum }_{i\in V\backslash \left\{d\right\}}{x}_i}{|V\backslash \{d\left\}\right|},$$

and

$$y_c=\frac{{\sum }_{i\in V\backslash \left\{d\right\}}{y}_i}{|V\backslash \{d\left\}\right|}.$$

Then, k additional auxiliary points $i_1^{\prime },\cdots ,i_k^{\prime }$ are defined. The first of them, $i_1^{\prime }\in V\backslash \left\{d\right\}$ is the farthest point from the depot. The remaining $k-1$ auxiliary points $i_2^{\prime },\cdots ,i_k^{\prime }$ are determined in such a way that the angle between two adjacent vectors $(c,i_j^{\prime })$ and $(c,i_{j+1}^{\prime })$ is the same and equals $\frac{2\pi }{k}$ and that all vectors $(c,i_j^{\prime })$ have the same length $\mathrm{w}(c,i_1^{\prime })$ (see Figure 8).

The partition of the set $V\backslash \left\{d\right\}$ is now carried out in two stages. In stage 1, each subset $V_j$, $j=1,\cdots ,k$, contains a single vertex $l_j\in V\backslash \{\left\{V_j\right\}\cup \left\{d\right\}\}$ such that the distance between $l_j$ and the auxiliary point $i_j^{\prime }$ is the minimal possible among all yet non-selected vertices of set $V\backslash \left\{d\right\}$.

Once the initial sets $V_j$, $j=1,\cdots ,k$ are so formed, repeatedly, for each subset $V_j$, a new vertex v with the minimum distance between that vertex and a vertex from the current set $V_j$ are added to that subset, i.e.,  $V_j:=V_j\cup \left\{v\right\}$. This operation is repeated until the current set $V_j$ contains $m_{min}$ elements (see Figure 9).

In stage 2, the subsets of stage 2 are augmented. For every yet non-selected vertex v, a “closest” subset $V_j$ is looked for, i.e., a subset such that the distance between vertex v and a point from set $V_j$ is the minimal possible among all subsets from the current partition. This operation is repeated until there remains a non-selected vertex (see Figure 10).

Once the above partition process is complete, a feasible tour $T_j$ for each of the subsets $V_j\cup \left\{d\right\}$ is constructed by merely invoking the insertion algorithm from Section 2.2 (see Figure 11). This solution is iteratively improved by a local interchange algorithm, which iteratively selects a vertex from tour $T^j$ and alters its position within that tour or this vertex is relocated to another tour $T^{j^{\prime }}$. The exchange is accomplished if it yields the decrease of the total cost; among all such exchanges, one which yields the maximum decrease is accomplished so that the resultant solution remains feasible.

Figure 12 illustrates the algorithm applied to our sample problem instance with 10 vertices. Here, we let $k=3$ salesmen, $m_{min}=2$, and $m_{max}=4$. In Figure 12a, the auxiliary point $i_1^{\prime }$ is 7. Then, the coordinates of auxiliary points $i_2^{\prime }$ and $i_3^{\prime }$ are calculated. Figure 12b represents the created partition of set $V\backslash \left\{d\right\}$ with $V_1=\{3,7,8,9\}$, $V_2=\{2,5\}$ and $V_3=\{4,6,10\}$. In Figure 12c, tours $T^1=(d,9,7,8,3,d)$, $T^2=(d,2,5,d)$, and $T^3=(d,6,10,4)$ are represented.

As is easy to verify, phase 1 runs in time $O\left(nk{m}_{max}^2\right)$; phase 2 has the same time complexity as the improvement phase of the previous algorithm; phase 3 runs in time $O\left(k^2{m}_{max}^2\right)$; see [42].

2.4. The Inflammation Algorithm

In this section, we describe our novel algorithm for the basic TSP that we call an inflammation algorithm. The name comes from the general approach used in the algorithm that iteratively constructs specially defined polygons delineating larger and larger areas in the plane with more and more points from set V. Each of these polygons defines a partial tour including a progressively increasing number of vertices.

Unlike the insertion algorithm, the first polygon $P_0$ that the inflammation algorithm constructs is the “smallest” one that is extended to “larger” polygons at consecutive iterations (in particular, it is not a girding polygon). The polygon constructed at iteration h, $P_h$, is an inner convex hull, i.e., it does not contain vertices from set V in its interval area, except that it may contain vertices in its internal area that belong to the earlier-constructed polygons $P_0,\cdots ,P_{h-1}$ (if polygon $P_h$ contains a vertex from set V in its internal area, then this vertex belongs to the polygon of an earlier iteration). Note that each polygon $P_h$ defines an optimal partial tour for the set of vertices that it contains, similarly to how the girding polygon P from Section 2.1 defines an optimal tour $T_0$. As we know, if $V\backslash T_0=\varnothing$, then $T_0$ from Section 2.1 defines an optimal tour. Hence, in the inflammation algorithm, we assume that this condition is not satisfied.

The inflammation algorithm iteratively, at every iteration h, constructs the polygon $P_h$ containing (some) vertices from set $V\backslash T_{h-1}$ (see Algorithm 3), where we denote again by $T_h$ the partial tour constructed by iteration h. Initially, we let $T_0=\varnothing$, and $T_1$ is formed by the partial tour of polygon $P_1$. At iteration $h\ge 2$, Algorithm 4 ($JOINP$) constructs partial tour $T_h$ by joining the vertices of polygon $P_h$ and the partial tour $T_{h-1}$ as described later in Section 2.4.2.

This completes an aggregated description of the inflammation algorithm. Abusing again the notation, we may use $P_h$ for the set of vertices of polygon $P_h$.

We shall refer to a specially defined point $c=(x_c,y_c)$ in the two-dimensional plane as a centroid.

In the following two subsections, we describe Algorithm 5, ($INNE{R}_{-}CONVE{X}_{-}HULL$), which constructs inner convex hull $P_h$, and Algorithm 4 ($JOINP$), which creates partial tour $T_h$ from the polygon $P_h$ and the previous tour $T_{h-1}$, at every iteration h.

Algorithm 3: $INFLAMMATION$(V).

Algorithm 4: $JOINP$($T_{h-1},P_h$).

Algorithm 5: $INNE{R}_{-}CONVE{X}_{-}HULL$($V,T_{h-1},c_h$).

2.4.1. Algorithm 5, ($INNE{R}_{-}CONVE{X}_{-}HULL$) for the Construction of Polygon $P_h$

Given an external iteration h in Algorithm 3 ($INFLAMMATION$), we denote by $L_h^l$ a polygonal line of the iteration l in Algorithm 5 (Figure 13), ($INNE{R}_{-}CONVE{X}_{-}HULL$), that is a broken line of a finite number of edges formed by some vertices from set $V\backslash T_{h-1}$. Polygonal line $T_h$ serves an auxiliary purpose at every iteration h with $|V\backslash T_{h-1}|\ge 3$ in Algorithm 3.

Consider an iteration h with $|V\backslash T_{h-1}|\ge 3$ in Algorithm 3. Initially, at iteration 0 in Algorithm 5, a polygonal line $L_h^0$ consists of all vertices of set $V\backslash T_{h-1}$ sorted in non-increasing order of their angles $\theta (c_h,v_i)$ (see Equation (4)) (i.e., $L_h^0=(v_1,v_2,\cdots ,v_{|V\backslash T_{h-1}|})$ where $\theta (c_h,v_1)\ge \theta (c_h,v_2)\ge \cdots \ge \theta (c_h,b_{|V\backslash T_{h-1}|})$) (see Figure 14).

Consider the polygonal line with an additional edge $(v_1,v_{|V\backslash T_{h-1}|})$ joining the two extremal vertices $v_1$ and $v_{|V\backslash T_{h-1}|})$ of the polygonal line $L_h^0$. In case the polygonal line obtained in this way forms a convex polygon, then the algorithm delivers this polygon $P_h$.

Otherwise, at iteration $l>0$, the polygon $P_h$ is obtained from the polygonal line $L_h^{l-1}$ by eliminating some of its vertices and the two edges associated with every eliminated vertex. Instead of the two eliminated edges, one additional edge is created. This is accomplished by an iterative analysis of three consecutive vertices $(v_{j-1},v_j,v_{j+1})$ from the polygonal line $L_h^{l-1}$ at once, where $v_{j-1}=v_{|L_h^{l-1}|}$ if $v_j=v_1$ and $v_{j+1}=v_1$ if $v_j=v_{|L_h^{l-1}|}$), for every $j=1,\cdots ,|L_h^{l-1}|$. For such a trio of consecutive points, we define a new angle-related function $\varphi (v_{j-1},v_j,v_{j+1},c_h)$; see Equation (5) below. It returns the angle between the edges $(v_{j-1},v_j)$ and $(v_j,v_{j+1})$ in the range $[-\pi ,\pi ]$; see Figure 15.

$$\begin{array}{cc}\hfill {\varphi }_1(v_{j-1},v_j,c_h)& =arccos\left({\displaystyle \frac{\mathrm{w}{(c_h,v_{j-1})}^2-\mathrm{w}{(c_h,v_j)}^2-\mathrm{w}{(v_{j-1},v_j)}^2}{-2\mathrm{w}(c_h,v_j)\mathrm{w}(v_{j-1},v_j)}}\right)\hfill \\ \hfill {\varphi }_2(v_j,v_{j+1},c_h)& =arccos\left({\displaystyle \frac{\mathrm{w}{(c_h,v_{j+1})}^2-\mathrm{w}{(c_h,v_j)}^2-\mathrm{w}{(v_j,v_{j+1})}^2}{-2\mathrm{w}(c_h,v_j)\mathrm{w}(v_j,v_{j+1})}}\right)\hfill \\ \hfill \varphi (v_{j-1},v_j,v_{j+1},c_h)& ={\varphi }_1(v_{j-1},v_j,c_h)+{\varphi }_2(v_j,v_{j+1},c_h)\hfill \end{array}$$

(5)

Given a trio $(v_{j-1},v_j,v_{j+1})$ of iteration l, the algorithm verifies if the internal angle between the edges $(v_{j-1},v_j)$ and $(v_j,v_{j+1})$, $\varphi ((v_{j-1},v_j,v_{j+1}),c_h)$, is no larger than $\pi$ radians. If this holds, then all three points $(v_{j-1},v_j,v_{j+1})$ are kept in polygon $P_h$, i.e., $P_h:=L_h^{l-1}$. Otherwise, the polygonal path is non-convex; hence, one of the points is to be removed: If $\mathrm{w}(c_h,v_{j-1})>\mathrm{w}(c_h,v_{j+1})$, then the vertex $v_{j-1}$ is removed, i.e., $L_h^l:=L_h^{l-1}\backslash \left\{v_{j-1}\right\}$. Otherwise, the vertex $v_{j+1}$ is removed, i.e., $L_h^l:=L_h^{l-1}\backslash \left\{v_{j+1}\right\}$. Let l be the last iteration.

We illustrate the construction process of the polygon line $L_1^0$ for problem instance “tsp10”. In Figure 14, $T_{h-1}=\varnothing$ and the centroid $c_h=c_1$ with coordinates $(52.8,55)$ is depicted in red color. Figure 14a illustrates how the $\theta$ angles are calculated so that $\theta (c_1,4)\ge \theta (c_1,10)\ge \theta (c_1,6)\ge \theta (c_1,10)\ge \theta (c_1,1)\ge \theta (c_1,5)\ge \theta (c_1,2)\ge \theta (c_1,3)\ge \theta (c_1,8)\ge \theta (c_1,9)\ge \theta (c_1,7)$. Figure 14b shows the resultant polygonal line $L_1^0=(4,10,6,1,5,2,3,8,9,7)$.

Table 2. Iterations performed by Algorithm 5 ($INNE{R}_{-}CONVE{X}_{-}HULL$) for the construction of the inner convex polygon P for the example instance “tsp10”.

l	${\mathit{L}}_{\mathit{h}}^{\mathit{l}}$	j	${\mathit{v}}_{\mathit{j}}$	Condition	Decision
0	Polygonal line is constructed $L_1^0:=(4,10,6,1,5,2,3,8,9,7)$
1	$(4,10,6,1,5,2,3,8,9,7)$	1	4	$\varphi (7,4,10,c)\le \pi :True$	$L_1^1:=L_1^0$, $j:=j+1$
2	$(4,10,6,1,5,2,3,8,9,7)$	2	10	$\varphi (4,10,6,c)\le \pi :True$	$L_1^2:=L_1^1$, $j:=j+1$
3	$(4,10,6,1,5,2,3,8,9,7)$	3	6	$\varphi (10,6,1,c)\le \pi :True$	$L_1^3:=L_1^2$, $j:=j+1$
4	$(4,10,6,1,5,2,3,8,9,7)$	4	1	$\varphi (6,1,5,c)\le \pi :False$	$L_1^4:=L_1^3\backslash \left\{5\right\}$
5	$(4,10,6,1,2,3,8,9,7)$	4	1	$\varphi (6,1,2,c)\le \pi :False$	$L_1^5:=L_1^4\backslash \left\{6\right\}$, $j:=j-1$
6	$(4,10,1,2,3,8,9,7)$	3	1	$\varphi (10,1,2,c)\le \pi :False$	$L_1^6:=L_1^5\backslash \left\{10\right\}$, $j:=j-1$
7	$(4,1,2,3,8,9,7)$	2	1	$\varphi (4,1,2,c)\le \pi :True$	$L_1^7:=L_1^6$, $j:=j+1$
8	$(4,1,2,3,8,9,7)$	3	2	$\varphi (1,2,3,c)\le \pi :True$	$L_1^8:=L_1^7$, $j:=j+1$
9	$(4,1,2,3,8,9,7)$	4	3	$\varphi (2,3,8,c)\le \pi :True$	$L_1^9:=L_1^8$, $j:=j+1$
10	$(4,1,2,3,8,9,7)$	5	8	$\varphi (3,8,9,c)\le \pi :True$	$L_1^{10}:=L_1^9$, $j:=j+1$
11	$(4,1,2,3,8,9,7)$	6	9	$\varphi (8,9,7,c)\le \pi :False$	$L_1^{11}:=L_1^{10}\backslash \left\{7\right\}$
12	$(4,1,2,3,8,9)$	6	9	$\varphi (8,9,4,c)\le \pi :False$	$L_1^{12}:=L_1^{11}\backslash \left\{8\right\}$, $j:=j-1$
13	$(4,1,2,3,9)$	5	9	$\varphi (3,9,4,c)\le \pi :True$	$L_1^{13}:=L_1^{12}$, $j:=j+1$
14	Inner convex hull $P_1:=L_1^{13}=(4,1,2,3,9)$ is constructed.

and Figure 16 show how Algorithm 5 ($INNE{R}_{-}$$CONVE{X}_{-}HULL$) constructs the polygon $P_1$ for problem instance “tsp10”. Figure 16a illustrates the initial polygonal line $L_1^1=(4,10,6,1,5,2,3,8,9,7)$. The first internal angle found in $L_1^3$ that is greater than $\pi$ radians is between the edges $(6,1)$ and $(1,5)$. Since $\mathrm{w}(c_1,6)<\mathrm{w}(c_1,5)$, vertex 5 is removed from $L_1^3$. In Figure 16b, the angle between the edges $(6,1)$ and $(1,2)$ is greater than $\pi$ radians. Since $\mathrm{w}(c_1,6)>\mathrm{w}(c_1,2)$, vertex 2 is removed from $L_1^4$. In Figure 16c, the angle between the edges $(10,1)$ and $(1,2)$ is greater than $\pi$ radians. Since $\mathrm{w}(c_1,10)>\mathrm{w}(c_1,2)$, vertex 10 is removed from $L_1^5$. In Figure 16d, the angle between the edges $(8,9)$ and $(9,7)$ is greater than $\pi$ radians. Since $\mathrm{w}(c_1,8)<\mathrm{w}(c_1,7)$, vertex 7 is removed from $L_1^{10}$. In Figure 16e, the angle between the edges $(8,9)$ and $(9,4)$ is greater than $\pi$ radians. Since $\mathrm{w}(c_1,8)>\mathrm{w}(c_1,4)$, vertex 8 is removed from $L_1^{11}$. Figure 16f shows that the resultant inner convex hull $P=(4,1,2,3,9)$ is delivered.

2.4.2. Algorithm JOINP

Algorithm 4 (Figure 17) ($JOINP$) is invoked at every iteration h from Algorithm 3 (INFLAMMATION), where Algorithm 5 ($INNE{R}_{-}$$CONVE{X}_{-}HULL$) is invoked before returning polygon $P_h$. Algorithm 4 constructs tour $T_h$ based on an earlier-constructed tour $T_{h-1}=(i_1,\cdots ,i_{|T_{h-1}|})$ and polygon $P_h=(v_1,\cdots ,v_{|P_h|})$. The construction is carried out in a number of iterations, where we denote by $T_{h-1}^l$ a partial tour constructed at iteration l; we let $T_{h-1}^0:=T_{h-1}$.

At iteration $l\ge 1$, vertex $v_l$ from polygon $P_h$ is inserted in between two adjacent pairs of vertices from tour $T_{h-1}^l$. These two vertices $i_j$ and $i_{j+1}$ are determined so that the cost of inserting vertex $v_l\in P_h$ in between these vertices is the minimum possible, i.e.,

$$\mathrm{w}(i_j,v_l)+\mathrm{w}(v_l,i_{j+1})-\mathrm{w}(i_j,i_{j+1})$$

is the minimum possible (the triangle inequality). Below is a formal description of the algorithm.

Figure 18 shows tour $T_1$ and polygon $P_2$ for the problem instance “tsp10”.

Table 3. Iterations performed by Algorithm 4 ($JOINP$) for the construction of tour $T_2$.

l	${\mathit{v}}_{\mathit{l}}$	$({\mathit{i}}_{\mathit{j}},{\mathit{i}}_{\mathit{j}+1})$	${\mathit{T}}_{\mathit{h}-1}^{\mathit{l}}$
0			$(4,1,2,3,9,4)$
1	10	$(4,1)$	$(4,10,1,2,3,9,4)$
2	6	$(10,1)$	$(4,10,6,1,2,3,9,4)$
3	5	$(1,2)$	$(4,10,6,1,5,2,3,9,4)$
4	8	$(3,9)$	$(4,10,6,1,5,2,3,8,9,4)$
5	7	$(9,4)$	$(4,10,6,1,5,2,3,8,9,7,4)$

and Figure 19 show the five iterations performed by Algorithm 4 ($JOINP$) for the construction of tour $T_2$.

2.4.3. Algorithm INFLAMMATION

The Algorithm 3 (Figure 20) initially lets $T_0:=\varnothing$. While $|V\backslash T_h|>2$, in the iteration $h>0$, the coordinates $x_{c_h}$ and $y_{c_h}$ of the centroid $c_h$ are calculated as follows:

$$x_{c_h}=\frac{{\sum }_{i\in V\backslash T_{h-1}}{x}_i}{|V\backslash T_{h-1}|}$$

and

$$y_{c_h}=\frac{{\sum }_{i\in V\backslash T_{h-1}}{y}_i}{|V\backslash T_{h-1}|}.$$

Once the centroid is so defined, Algorithm 5 ($INNE{R}_{-}CONVE{X}_{-}$$HULL$) is invoked to obtain the inner convex hull $P_h$. Then, the tour $T_h$ is constructed by the invoking of Algorithm 4 ($JOINP(T_{h-1},c_h)$).

If $|V\backslash T_h|=0$, then the algorithm halts. Else, if $1\le |V\backslash T_h|\le 2$, instead of invoking Algorithm 5 (no inner convex hull can be constructed), the $|V\backslash T_h|$ vertices from set $V\backslash T_h$ are inserted in between two consecutive vertices of tour $T_{h-1}$ in $|V\backslash T_h|$ iterations, one vertex at each iteration, similar to as in Algorithm 4 (so that the increase in the total cost at each iteration is the minimum possible).

Table 4. Iterations performed by Algorithm 3 ($INFLAMMATION$) for the construction of tour T for example instance “tsp10”.

h	${\mathit{P}}_{\mathit{h}}$	${\mathit{T}}_{\mathit{h}}$
0		$\varnothing$
1	$(4,1,2,3,9)$	$(4,1,2,3,9,4)$
2	$(10,6,5,8,7)$	$(4,10,6,1,5,2,3,8,9,7,4)$
		$T=(4,10,6,1,5,2,3,8,9,7,4)$

and Figure 21 illustrate Algorithm 3 for problem instance “tsp10” with 10 vertices. In Figure 21a, inner convex polygon $P_1=(4,1,2,3,9)$ is constructed, considering the vertices of $V\backslash T_0=V$. In Figure 21b, $T_1=(4,1,2,3,9,4)$ is constructed with the vertices included in $P_1$ and $P_2=(7,10,6,5,8)$ is constructed with the vertices included in $V\backslash T_1$. In Figure 21c, $T_2=(4,10,6,1,5,2,3,8,9,7,4)$ is constructed by inserting the vertices from $P_2$ in tour $T_1$. The resultant feasible solution $T=T_2$.

We applied an improvement algorithm to a complete tour obtained as above. Two heuristics were used in a loop for this purpose. First, a local search algorithm proposed by Croes (“2-Opt”) [43] was applied. Then, iteratively, a vertex from the current tour was relocated to an alternative position if this yielded further reduction in the total cost. The algorithm halts when no such rearrangement exists.

As is easy to see, algorithm $INNE{R}_{-}CONVE{X}_{-}HULL$ has time complexity $O(nlogn)$; algorithm JOINP has time complexity $O\left(n^2\right)$; the improvement phase has the same time complexity as the improvement phase of the INSERTION algorithm.

3. Implementation and Results

In this section, we report our experimental study. Our algorithms were coded in C++ and compiled on a Debian GNU/Linux operating system.

According to our earlier experimental results from [5], the insertion algorithm from Section 2.2 proved to be very fast. It was tested for 218 problem instances with sizes between 32 and 744,710 from the TSPLIB [44], NATIONAL [45], ART GALLERY [45], and VLSI [45] group of instances. On average, the cost of the approximation obtained by this method with respect to the cost of the best-known solution had a margin of error of 7.2%.

The inflammation method was designed to provide solutions of good quality for some typical real-life instances. A few such sample instances were created based on the existing tourist tours and network convenience stores from different parts of the world (Asia, Europe, South America, United States of America, and Mexico. We describe these instances in the following subsections.

The algorithm for the BMTSP from Section 2.3 was tested for 22 benchmark instances. For one of them, $pr1002.tsp$ (with $k=5$, $m_{min}=1$, and $m_{max}=5$), we obtained the best-known result $\mathrm{C}\left(T\right)=329,128$, improving the earlier-known best cost $\mathrm{C}\left(BKS\right)=334.351$ Lo et al. [38]. The remaining 16 instances were solved with an approximation gap less than or equal to 7%. We refer the reader to Table 1 from [42] for the details.

3.1. Ring Roads

Many towns throughout the world have an important principal avenue, often referred to as ring (circular) roads or peripheral avenues. They typically surround the populated areas. They can be seen as circle-type curves or multiple-sided polygons that contain a given populated area in the interior area. Peripheral avenues contain different important locations such as military barracks, supermarkets, malls with cinemas, restaurants, gas stations, etc. The remaining interior destinations such as market places, bus terminals, teacher training colleges, fields for physical and sports activities, houses, etc., can also be reached through peripheral avenues. Peripheral avenues have also exits to highways that connect a given city with neighboring towns. In Figure 22, the peripheral roads of some major cities are illustrated (these images were taken from the Internet). Based on these images, we created our first sample problem instance for an abstract peripheral avenue and tested the inflammation algorithm for this instance.

Figure 23a illustrates this sample instance, and Figure 23b represents the solution created by the algorithm. The optimality of the created tour is easily verified. For the real-life instances, strictly optimal solutions may not be obtained, but one would normally expect the algorithm to deliver close to the optimal solutions. In the following subsections, we give the results for six other real-life instances.

3.2. Convenience Stores in Iguala

Our next instance was taken from a map of the city of Iguala, located in the state of Guerrero, Mexico (See Appendix A.1). Different important spots including a chain of convenience stores are located around the peripheral avenue of this city. This peripheral avenue is shaped as an eight-sided polygon, as we can see from Figure 24. In Iguala, an important chain of convenience stores, Oxxo, has 21 stores and an administrative office in this city; 11 of these stores are located on the peripheral avenue or one block from it; eight stores are in the city center; two stores are at one of the city exits. Among the employees who work in those offices, there are those who must visit all the stores, and there are also a couple of supervisors who only visit between 10 and 13 stores that they are in charge of.

We tested both the inflammation and BMTSP algorithms for this instance. Figure 25 shows the iterations carried out by the inflammation method for the construction of the tour for an employee to visit all the stores in the city. The vertex d represents the administrative office from which that employee starts and ends his/her trip.

In Figure 25a, the polygon $P_0=(d,6,20,8,16)$ is constructed. In Figure 25b, $T_0=(d,6,20,8,16,d)$ is constructed from the vertices of $P_0$, and the polygon $P_1=(7,2,14,19,9,10)$ is constructed. In Figure 25c, $T_1=(d,6,7,2,20,14,8,19,9,16,10,d)$ is constructed from the vertices of $P_1$ inserted in $T_0$, and the polygon $P_2=(4,21,17,18,5,12)$ is constructed. In Figure 25d, $T_2=(d,6,7,4,2,21,17,20,14,8,19,18,5,9,16,12,10,d)$ is constructed from the vertices of $P_2$ inserted in $T_1$, and the polygon $P_3=(1,13,15)$ is constructed. In Figure 25e, $T_3=(d,6,7,4,15,1,2,21,17,20,13,14,8,19,18,5,9,16,12,10,d)$ is constructed from the vertices of $P_3$ inserted in $T_2$, and the polygon $P_4=(3,11)$ is constructed. In Figure 25f, $T_4=(d,6,7,4,15,3,11,1,2,21,17,20,13,14,8,19,18,5,9,16,12,10,d)$ is constructed from the vertices of $P_4$ inserted in $T_3$, and the method completes the construction of the tour.

Figure 26 shows the phases carried out by the bounded multiprocessor TSP method for the construction of a tour for each of the two supervisors (with $k=2$, $m_{min}=10$ and $m_{max}=13$). In Figure 26a, the partition of set $V\backslash \left\{d\right\}$ into two feasible subsets $V_1=\{5,8,9,13,14,16,17,18,19,20,21\}$ and $V_2=\{1,2,3,4,6,7,10,11,12,15\}$ is shown, whose number of vertices included in each of them is between 10 and 13 vertices. In Figure 26b, tours $T^1=(d,21,17,20,13,14,8,8,5,18,19,16,d)$ and $T^2=(d,6,2,7,4,1,11,3,15,12,10,d)$ are constructed for the subsets $V_1\cup \left\{d\right\}$ and $V_2\cup \left\{d\right\}$, respectively. In Figure 26c, the feasible solution constructed is improved.

3.2.1. Instance Asia

Instance “Asia.tsp” was built based on two tourist circuits: “Japan, China and South Korea in 15 days” by [47] and “17 days—Travel to Japan, South Korea and China” by [48].

The instance includes 22 tourist places: Tokyo, Hakone, Guilin, Xi’an, Shanghai, Seoul, Beijing, Linfen, Pingyao, Wutai, Jiming Mountain, Datong, Itsukushima Shrine, Iwakuni, Xinzhou, Shimonoseki, Hiroshima, Busan, Daegu, Tripitaka, Jeonju, and Suwon (see Figure 27).

3.2.2. Instance Europe

Instance “Europe.tsp” was taken from the circuit called “Fantastic Europe Circuit” from [50].

The instance includes 24 tourist places: Madrid, San Sebastian, Bordeaux, Blois, Paris, Luxembourg, Frankfurt, Heidelberg, Freiburg, Zurich, Lucerne, Vaduz, Innsbruck, Padova, Venice, Bologna, Florence, Assisi, Rome, Pisa, Nice, Montpellier, Barcelona, and Zaragoza (see Figure 28).

3.2.3. Instance South America

Instance “SouthAmerica.tsp” was built based on two tourist circuits: “Peru, Bolivia and Chile” and “Argentina-Chile” of [52].

The instance includes 15 tourist places: Lima, San Pedro Atacama, Ollantaytambo, Cusco, Machu Picchu, Sacred Valley of the Incas, Lake Titicaca, Copacabana, Torres de Paine, El Calafate, Viña del Mar, Buenos Aires, Santiago de Chile, Valparaíso, and Montevideo (See Figure 29).

3.2.4. Instance East of USA

Instance “EastUSA.tsp” was taken from the circuit called “The Grand East” of [54].

The instance includes 19 tourist places: New York, Boston, Quebec, Montreal, Ottawa, Toronto, Niagara Falls, Amish Country, Washington D.C., Wiliamsburg, Roanoke, Gatlingburg, Nashville, Memphis, New Orleans, Pensacola, Orlando, and Miami (See Figure 30).

3.2.5. Instance Mexico

The instance “Mexico.tsp” was built based on three tourist circuits: “Mayan Civilizations” and “Yucatán” from [56] and “The essentials of Mexico to Cancun ” from [57].

The instance includes 22 tourist places: Mexico City, Teotihuacan, Villahermosa, Palenque, Campeche, Uxmal, Mérida, Chichen Itzá, Cancún, Tulum, Cobá, Kabah, Izamal, Valladolid, Puebla, Mitla, Oaxaca-MonteAlbán, Tehuantepec, Tuxtla Gutierrez, San Cristobal de las Casas, and Agua Azul Waterfalls (see Figure 31).

3.3. Summary of the Results at the Improvement Stage

In

Table 5. A summary of the improvements accomplished at the last improvement stage of the inflammation algorithm.

Instance	${\mathit{C}}_{\mathit{Inf}}\left(\mathbf{T}\right)$	${\mathit{C}}_{\mathit{Imp}}\left(\mathbf{T}\right)$	% Improvement
FNV40.tsp	304.10	304.10	0%
Iguala.tsp	1490.78	1452.21	2.66 %
Asia.tsp	1878.60	1848.94	1.60%
Europe.tsp	2964.18	2578.17	14.97%
SouthAmerica.tsp	1690.70	1686.56	0.25%
EastUSA.tsp	1977.06	1761.28	12.25 %
Mexico.tsp	1389.89	1381.58	0.60 %

, we give a summary of the improvements accomplished at the last improvement stage of the inflammation algorithm. Column “$C_{Inf}\left(T\right)$” represents the cost of the tour delivered by the inflammation algorithm, and Column “$C_{Imp}\left(T\right)$” represents the cost of the tour delivered by the improvement stage. Column “% Improvement” presents the percentage of the improvement.

4. Conclusions and Future Work

Using convex polygons in our approach provided good-quality solutions for Euclidean traveling salesman problems. In particular, the inflammation algorithm provided optimal and near-optimal solutions for the “ring-type” instances of the Euclidean TSP. Ring-type instances with a symmetric geometric structure were solved optimally, whereas for the real-life ring-type instances, close to optimum solutions were created. As for the future work, it would be interesting to compare the practical behavior of the earlier-mentioned algorithms (including our algorithm) for the construction of a girding polygon. Indeed, the worst-case time complexity does not always reflect the practical performance. We also intend to extend the inflammation algorithm with a decomposition stage, which would partition a given problem instance into sub-instances with a nearly symmetric geometric structure. Then, we can apply the proposed algorithm to each of the derived substances and unify the created partial solutions into an overall complete solution. Likewise, our algorithm for the BMTSP can be extended with different alternative algorithms for partitioning the given set of points. Our method can also be adapted for more general settings including different versions of the multiprocessor traveling salesman problem.