Two new variants of Christofides heuristic for the Static TSP and a computational study of a nearest neighbor approach for the Dynamic TSP

Two new variants of Christofides heuristic for the Static TSP and a computational study of a nearest neighbor approach for the Dynamic TSP Orlis Christos Kartsiotis George Samaras Nikolaos Margaritis Konstantinos MSc student MSc student Assistant Professor Professor Department of Applied Informatics University of Macedonia 156 Egnatia Str., 54006 Thessaloniki, Greece Abstract The Traveling Salesman Problem (TSP) is a standard test-bed for algorithmic ideas. From this point of view we evaluate the computational behavior of two new variants of Christofides heuristic for the Symmetric TSP. Moreover, we compare these numerical results with those arose from known heuristics with same worst-case time complexity. As a further step, we consider the Symmetric Dynamic TSP in which the travel cost between specific pairs of nodes may change through time. In this case, we apply an algorithmic approach based on Nearest Neighbor heuristic in order to avoid a link which has affected negatively cause of a surcharge. Effective implementations were developed and tested on TSPLib 95 benchmark instances. KEYWORDS Traveling Salesman Problem, Heuristics, Static and Dynamic TSP, Computational Study 1. INTRODUCTION 1.1 The Traveling Salesman Problem The Traveling Salesman Problem (TSP) is one of the most well studied combinatorial optimization problems. E Given a complete graph G = ( N, E) on nodes with edge costs c R, the objective is to find a Hamiltonian cycle or tour in K n of minimum cost. This problem is known to be NP-hard [Garey & Johnson (1979)] even in the case where the corresponding costs satisfy the triangle inequality, i.e. when cij + cjk cik, i, j, k N [Laweler et al. (1985)]. There exist plenty of algorithms used to find optimal tours, but none of them is efficient when large instances are handled since they all grow exponentially [Flood (1956)]. This fact leaves the researchers with two major strategies; either look for heuristics that merely find quickly near-optimal solutions, or attempt to develop optimization algorithms that work well on 'real world' rather than worst-case instances. In practice, the TSP is usually solved by using heuristics that are able to find a locally optimal solution. In addition to the choice of the solution method, one would like to have some guarantee on the quality of the solutions found. Such a guarantee exists if a lower bound for the length of the shortest possible tour is known. In general, lower bounds are obtained by solving relaxations of the original problem. The optimal solution of the relaxed problem gives a valid lower bound for the optimal solution of the original problem. Using different relaxations, different lower bounds can be obtained. Hence, the main goal is to find appropriate relaxation problems for the TSP that can be solved efficiently and which give lower bounds as tight as possible. If the optimal solution of the relaxed problem is a valid tour, then the optimal solution of the

original TSP has been found. In this paper we are going to use lower bounds created by the Held-Karp algorithmic approach [Held & Karp (1970)]. 1.2 Applications and algorithmic approaches TSP has many real world applications. For example, it could be used from logistics and data clustering applications to genome sequencing and optimization of drilling in VLSI design. There have been proposed several heuristics (Table 1) with or without a worst-case ratio as far as their results [Papadimitriou & Steiglitz 3 (1977)] during the past decades but Christofides heuristic with worst-case time complexity On ( ) [Christofides (1976)] and worst-case ratio 3/2 [Vazirani (2003)] remains the best. Other solution approaches are neural networks, tabu search, simulated annealing and genetic learning. Table 1. Worst-case time complexity and worst-case ratio of the basic TSP heuristics Heuristic Nearest Neighbor Greedy Double MST Christofides Worst-case time complexity ~above Held-Karp lower bound Worst-case ratio 2 On ( ) 25% - 2 On ( log 2n ) 15%-20% - 2 On ( log 2n ) 30% 2 3 On ( ) 10% 1.5 Furthermore, apart from tour construction algorithms, there are also some tour improvement algorithms [Lin & Kernighan (1973)]. In tour improvement algorithms, a given initial solution is improved, if possible, by transposing two or more points in the initial tour. With regard to improvement algorithms, two strategies are possible. We may either consider all possible exchanges or choose the one that result in the greatest saving and continue this process until no further reduction is possible. 1.3 Proposed methods It is well-known that TSP is a difficult problem that can approximately be solved by a bunch of heuristics when it is static. But in real world applications we need good results in reasonable time in order to decide which tour should be followed. To this matter, we suggest two heuristics based totally on Christofides heuristic. Moreover, there are many applications in which the transitions costs between specific pairs of nodes may change dynamically through time, i.e. real time traffic routing and router packet scheduling. From this point of view, we are going to examine the computational behavior and the yielding results of an iterative step by step application of the Nearest Neighbor heuristic for the Dynamic TSP. We selected this heuristic due to its ability to adapt to dynamic changes and its efficient computational behavior. Following this section, in section 2, we describe the data set used in our experiments. In section 3, we describe briefly the proposed solution methods for the Static and the Dynamic TSP by presenting the pseudocodes and a destruction scheme. In section 4, we present the numerical results of our computational study and finally, our conclusions are presented in section 5. 2. DATA SET DESCRIPTION 2.1 The TSPLib 95 In order to test the computational behavior of the proposed algorithms we have used benchmark instances from TSPLib 95 [Reinelt (1991)]. TSPLib 95 is a well-known suite containing many hard to solve

optimization problems for the TSP and related problems from various sources and of various types. In our paper, we took under consideration the Symmetric Traveling Salesman Problem in which the distance from node i to node j is the same as from node j to node i ( cij = cji, i, j = 1,2,..., n, i j ). These instances are all very different from each other, especially in the structure of the cost matrix. The entries of the cost matrix were computed using various geographical distances. These formats, in our occasion, were the Euclidean, the pseudo-euclidean, the Geographical and the full Matrix. Table 2 demonstrates four benchmark instances with all the different types of entries of the cost matrix used in this survey. Table 2. Four TSPLib 95 benchmark instances with all the different types of entries of the cost matrix Name #cities Type Optimal att48 48 ATT 10268 brazil58 58 MATRIX 25395 ch130 130 EUC_2D 6110 gr666 666 GEO 294358 3. ALGORITHMS DESCRIPTION 3.1 Algorithms for the Static TSP In this section we are going to describe the proposed solution methods for the Static TSP. More specifically, we are going to introduce two variations of Christofides heuristic with much better computational behavior and results, as we will see, comparable with those of the Nearest Neighbor and the Greedy heuristic ones. In the pseudocode that follows, we describe the main steps of Christofides heuristic. Christofides heuristic O(n 3 ) Require: G = ( N, E) STEP 0. Compute a minimum spanning tree T for G (every tree has an even number of nodes that are odd-degree). STEP 1. Let N* N be the set of nodes of odd degree in T. STEP 2. Compute a minimum perfect matching M on the complete graph G* = ( N*, E*). STEP 3. Add the edges from M to T, and find an Euler tour Γ, of the resulting (multi-)graph. STEP 4. For each node that occurs more than once in Γ, remove all but one of its occurrences. STEP 5. return Γ 3.1.1 Proposed methods for computing minimum perfect matching The problem of computing a minimum perfect matching is P (O(n 3 )) but many times doesn t suit well in real time applications. From this point of view we compute this by using the Nearest Neighbor and Greedy heuristic in a very simple way as we can see in Figure 1. More specifically, after the STEP 1 of Christofides heuristic, for the subset of nodes with odd degree, we apply the above heuristics in order to create a tour for these nodes. Then, we choose the cheaper perfect matching from the two available options. Below are presented the pseudocodes. ApproximatePerfectMatching1 O(n 2 ) Require: G = ( N, E), N * STEP 0. Create the complete graph G* = ( N*, E*) from the subset N * created in STEP 1 of Christofides heuristic. STEP 1. Find a tour C over G * by using the Nearest Neighbor heuristic. STEP 2. Start from node C (i = 1), compute the total of the perfect matching M 1 by adding the distance from node C (i) to C (i + 2) and then increase i by 2 in order to compute the second

pairing. Repeat N / 2 times. STEP 3. Start from node C (i = 2), repeat the above procedure N - 1 times in order to compute the perfect matching M 2 and then add to M 2 the C( N ) to C(1) distance. STEP 4. Choose the cheapest perfect matching from M 1 and M 2 and then continue with the STEP 3 of Christofides heuristic. ApproximatePerfectMatching2 O(n 2 log 2 n) Require: G = ( N, E), N * STEP 0. Create the complete graph G* = ( N*, E*) from the subset N * created in STEP 1 of Christofides heuristic. STEP 1. Find a tour C over G* = ( N*, E*) by using the Greedy heuristic. STEP 2. Start from node C(i = 1), compute the total of the perfect matching M 1 by adding the distance from node C(i) to C(i + 2) and then increase i by 2 in order to compute the second pairing. Repeat N / 2 times. STEP 3. Start from node C(i = 2), repeat the above procedure in order to compute the perfect matching M 2 and then add to M 2 the C( N ) to C(1) distance. STEP 4. Choose the cheapest perfect matching from M 1 and M 2 and continue with the STEP 3 of Christofides heuristic. Moreover, as we know from the basic principles of the asymptotic analysis, the proposed methods, i.e. Christofides1 (Christofides heuristic using ApproximatePerfectMatching1) and Christofides2 (Christofides heuristic using ApproximatePerfectMatching2) have worst-case time complexity O(n 2 ) and O(n 2 log 2 n) respectively. As a result, when applied to Christofides heuristic, they reduce its worst-case time complexity to the same values but unfortunately with no guarantee for the quality of the created tour. Figure 1. Visualization of the proposed methods for finding perfect matching N* STEP 0 STEP 1 3.2 Algorithm for the Dynamic TSP STEP 2 ( M 1 ) STEP 3 ( M 2 ) DynamicTSPNearestNeighbor Require: G = ( N, E) STEP 0. Select arbitrarily a starting node u. STEP 1. While you haven t visited all nodes Compute the subset N* N of nodes whose selection won t create a cycle. Let v N* be the node nearest to u. Apply the destruction scheme on G = ( N, E).

If a destruction has affected N * Let v N* be the node nearest to u. u v else u v End_If End_While STEP 2. Return the created tour. 3.2.1 Destructions scheme We examined five different types of destructions with different probabilities of occurrence and surcharge due to the fact that not all real phenomena happen and disrupt networks the same way, i.e. rain is more possible and causes fewer surcharges than a hurricane. For our experiments we consider five types of destruction (Table 3) with decreasing probability of occurrence and increasing surcharge: Table 3. The five different types of destruction with their surcharges Phenomenon Probability of Surcharge occurrence A 33.33% 50% B 26.66% 100% C 20.00% 150% D 13.33% 200% E 6.66% 250% Furthermore, we took into account two basic factors, first that there are periods of no destruction at all and second that not all nodes on a network are affected when destruction does occur, i.e. there are periods without snow and when it does it certainly doesn t snow everywhere. (These two factors where modeled with the parameters of the destruction probability and the percentage number of nodes affected from destruction). 4. COMPUTATIONAL STUDY 4.1 Computing environment All heuristics were implemented in the MathWorks MATLAB environment. MATLAB is a widely used tool in scientific computing community. The main reasons for this choice were the inherent capability of MATLAB for matrix operations and the support of sparse matrices. The reported CPU times were computed with the built-in function cputime. The given times are net times and do not include times for the input. The characteristics of the hardware and software can be a crucial factor for the performance of an algorithm. Our computational experiments ran in the computing environment described in Table 4. CPU RAM size L2 Cache size L2 Cache size Operating System MATLAB version Table 4. Description of the computing environment 4.2 Computational results for the Static TSP Intel(R) Core2Duo, 2.26 GHz (2 processors) 3096 MB 3 MB 128 KB Linux O/S Ubuntu, Kernel: 2.6.31 - generic 7.8.0.347 (R2009a)

Analyzing the numerical results, it is worth mentioning that our proposed methods in order to solve the Static TSP returned tours with very good results. More specifically, the Christofides1 (Christofides using the ApproximatePerfectMatching1) with worst-case time complexity O(n 2 ) returned tours with less for the 65 of the 87 TSPLib 95 instances (~74.70%) and Christofides2 (Christofides using the ApproximatePerfectMatching2) with worst-case time complexity O(n 2 log 2 n) returned better tours in 36 out of our 87 instances (~41.40%). Table 5 demonstrates the yielding results for 20 out of our 87 TSPLib 95 instances whose selection based on their returned s which belong to a comparable scale. Figure 2 shows the total of all TSPLib 95 instances used in this survey using various heuristics and Figure 3 the total of all TSPLib 95 instances in contrast with the Double Minimum Spanning Tree heuristic (worst-case ratio: 2) and the optimal results. Nearest Neighbor Nearest Neighbor time (secs) Table 5. Numerical results for our proposed methods Christofides1 Christofides1 Greedy Greedy Christofides2 Christofides2 Optimal Name n time (secs) time (secs) time (secs) att532 532 35516 0.18 35647 0.95 34002 1.29 32626 1.36 27686 brazil58 58 30774 0.01 27950 0.03 30458 0.05 27623 0.05 25395 d493 493 41665 0.15 42063 0.97 41361 1.37 41077 1.37 35002 d657 657 61627 0.21 57944 1.19 56612 1.33 58682 1.90 48912 d1291 1291 60214 0.40 62735 4.32 61253 7.84 63691 6.02 50801 gr96 96 75065 0.03 68364 0.06 66197 0.07 63597 0.08 55209 gr202 202 47080 0.06 47683 0.18 47130 0.23 45670 0.26 40160 kroa100 100 27807 0.03 27127 0.07 24287 0.07 25387 0.08 21282 kroa150 150 33633 0.04 31440 0.13 31892 0.16 30834 0.17 26524 kroa200 200 35859 0.04 35794 0.18 34554 0.15 35948 0.25 29368 krob200 200 36980 0.05 36123 0.19 35975 0.20 35975 0.24 29437 lin318 318 54019 0.10 52288 0.39 49898 0.33 51062 0.44 42029 nrw1379 1379 68964 0.52 68545 7.24 66106 7.18 67600 9.04 56638 P654 654 43457 0.19 41224 1.11 40278 0.99 39911 1.45 34643 pcb442 442 61979 0.13 56851 0.71 61076 0.66 56343 0.85 50778 pcb1173 1173 71978 0.47 67946 4.82 70060 6.45 66203 5.31 56892 pr124 124 69297 0.03 65379 0.07 64998 0.08 70714 0.10 59030 pr299 299 59890 0.08 58546 0.40 63333 0.53 59649 0.50 48191 u159 159 54675 0.03 49248 0.13 49589 0.11 47108 0.16 42080 u574 574 50549 0.20 44357 1.21 45043 1.15 46214 1.42 36905 Total - 1021028 2.95 977254 24.35 974102 30.24 965914 31.05 816962 Figure 2. Computational results of our proposed methods Total from 87 TSPLib 95 benchmark instances Total 9200000 9100000 9000000 8900000 8800000 8700000 8600000 8500000 8400000 8300000 8200000 Nearest Neighbor Christofides1 Greedy Christofides2 Heuristic

Figure 3. Computational results of our proposed methods in contrast with the DMST and optimal ones Total from 87 TSPLib 95 benchmark instances 12000000 10000000 Total 8000000 6000000 4000000 2000000 0 DMST (worstcase ratio: 2) Nearest Neighbor Christofides1 Greedy Christofides2 Optimal solution Heuristic 4.3 Computational results for the Dynamic TSP In Table 6 we present our results each of which correspond to 10 iterations on each test set and we provide 20 out of the 87 sets which were totally tested, in order to have a coherent outcome (returned ) scale from approximately 30000 up to 80000. Column n corresponds to the number of cities on the set, column Average without corresponds to the found without changing course despite of destruction and columns Average and Average time with correspond to the average and time in cpu seconds for the 10 iterations. Column Average extra with is the mean out of 10 iterations when we allow the destruction to be taken accounted for and column Best with corresponds to the best route found with making changes due to destruction. Column #of avoided destructions / #of total destructions show the times we choose a different node instead of the originally chosen out of the total choices we made to complete the rout. Columns Weight without destructions and Time without destructions correspond to the and time when no destruction took place. Finally, column Optimal corresponds to the best known solution. Two visualized examples of the performance of the algorithms are presented in Figure 4 and 5 by demonstrating the yielding results corresponding to pcb442 TSPLib 95 instance. Table 6. Numerical results (possibility of destruction: 50%, percentage of affected nodes in each destruction: 10%) Average without Average with Average time (sec) with Average extra with Best with #of avoided destructions/ # of total destructions Weight without destructions Time (sec) without destructions Optimal Name n att532 532 37171.05 36002.40 0.28 260.10 34350 22/29 35516 0.19 27686 brazil58 58 32383.45 32779.45 0.03 632.75 30286 2/3 30774 0.03 25395 d493 493 43387.70 43859.80 0.26 302.10 41428 27/31 41665 0.18 35002 d657 657 65609.65 62933.45 0.36 296.85 59272 14/24 61627 0.26 48912 d1291 1291 63691.70 64207.50 0.71 570.20 60674 36/62 60214 0.41 50801 gr96 96 78241.85 75161.45 0.04 884.65 72353 1/5 75065 0.02 55209 gr202 202 49331.40 50833.80 0.10 719.80 47346 2/3 47080 0.05 40160 kroa100 100 29565.20 27305.50 0.04 174.50 24554 6/10 27807 0.02 21282 kroa150 150 36020.75 33652.20 0.06 205.30 31942 7/7 33633 0.02 26524 kroa200 200 37974.35 39159.00 0.08 514.80 36739.50 5/6 35859 0.03 29368

krob200 200 39487.85 38774.15 0.09 513.95 37221 5/6 36980 0.04 29437 lin318 318 57293.15 53704.05 0.14 411.85 50084 12/16 54019 0.11 42029 nrw1379 1379 72880.85 72607.60 0.92 705.40 70526.50 45/52 68964 0.54 56638 P654 654 45458.50 43773.50 0.32 104.50 39562 13/14 43457 0.20 34643 pcb442 442 65371.45 63055.30 0.20 441.40 60320 20/24 61979 0.13 50778 pcb1173 1173 75662.90 75140.20 0.76 391.40 73456 43/58 71978 0.48 56892 pr124 124 72884.95 73548.80 0.05 745.10 70967 5/6 69297 0.04 59030 pr299 299 63698.05 62850.15 0.13 245.80 57712.50 10/14 59890 0.08 48191 u159 159 58078.20 54885.00 0.06 720.70 47614 7/9 54675 0.04 42080 u574 574 52961.35 49350.90 0.30 702.50 46788 13/17 50459 0.23 36905 Total - ~1077154 ~1053584 4.93 ~9544 ~993196 295/396 1020938 3.10 816962 Figure 4. Numerical results for the pcb442 instance when the probability of destruction was 70% Probability of destruction: 70% Average 90000 80000 70000 60000 50000 40000 30000 20000 10000 0 10% 20% 30% 40% 50% Percentage of affected nodes in each destruction Without With Without destructions Figure 5. Numerical results for the pcb442 instance when the probability of destruction was 100% Probability of destruction: 100% Average 100000 90000 80000 70000 60000 50000 40000 30000 20000 10000 0 10% 20% 30% 40% 50% Percentage of nodes affected in each destruction Without With Without destructions

5. CONCLUSION In this paper we tried to evaluate the computational behavior of several proposed heuristics for the Static and the Dynamic Symmetric Traveling Salesman Problem while in parallel we suggested some algorithmic approaches for solving much different instances not only effectively but also in real time. As our experiments have shown, Christofides1 and Christofides2 heuristics behave very well in general. More specifically, Christofides1 heuristic returned less ed tours than Nearest Neighbor for the 74.70% of our instances. However, this heuristic seemed to behave in the most of the cases in his worst-case time complexity. On the other hand, Christofides2 heuristic returned less ed tours than Greedy for the 41.40% of our instances in reasonable time. In our opinion, these results indicate that our proposed heuristics may easily apply in real applications in which the time responses play a crucial role. It is worth mentioning here that a random selection between the perfect matching M 1 and M 2 during the STEP 4 of our proposed methods (ApproximatePerfectMatching1 and ApproximatePerfectMatching2) doesn t work effectively as we clearly understood through experimentation. Ending, DynamicTSPNearestNeighbor heuristic seemed to behave very well in general as our hundreds of experiments have shown. Moreover, the yielding results of this heuristic were far better for all of our experiments and the time responses were closely related to those of Nearest Neighbor without the property of avoiding a surcharged link cause of a destruction. REFERENCES Christofides, N. 1976. Worst Case analysis of a New Heuristic for the Traveling Salesman Problem, Report 388, Graduate School of Industrial Administration, Carnegie Mellon University, Pittsburgh, PA. Flood, M.M. 1956. The travelling salesman problem. Operations Research 4, pp. 61-75. Garey, M. R., Johnson, D.S. 1979. Computers and Intractability: A Guide to the theory of NP-Completeness, Freeman, San Francisco. Held, M., Karp, R.M. 1970. The travelling-salesman problem and minimum spanning trees: Part II. Mathematical Programming 1, pp. 6-25. Lawler, L.E., Lenstra, J.K., Rinnooy Kan, A.H.G. and Shmoys, D.B. 1985. eds., The Traveling Salesman Problem. John Wiley & Sons, Chichester, pp. 37-85. Lin, S., Kernighan, B. W. 1973. An effective heuristic algorithm for the traveling- salesman problem. Operations Research 21, pp. 498-516. Papadimitriou, C.H., Steiglitz, K. 1977. On the complexity of local search for the travelling salesman problem. SIAM J. Comput. 6, pp. 76-83. Reinelt, G. 1991. TSPLib a traveling salesman problem library. ORSA J. Comput. 3, pp. 376 384. Vazirani, V.V. 2003. Approximation algorithms. Springer, pp. 30-33.