The Traveling Salesman Problem
David S. JohnsonVisiting Professor
[email protected]://davidsjohnson.net
Seeley Mudd 523, Tuesdays and Fridays
The Traveling Salesman Problem
Given:Set of cities {c1,c2,…,cN }.
For each pair of cities {ci,cj}, a distance d(ci,cj).
Find: Permutation that
minimizes
)c,d(c)c,d(c π(1)π(N)
1N
1i1)π(iπ(i)
N}{1,2,...,N}{1,2,...,:π
N = 10
N = 10
N = 100
N = 1,000
N = 10,000
N = 100,000
Application #1
• Cities:
– Holes to be drilled in printed circuit boards
N = 2392
Application #2
• Cities:
– Wires to be cut in a “Laser Logic” programmable circuit
N = 7397
N = 33,810
N = 85,900
Other Types of Instances
• X-ray crystallography – Cities: orientations of a crystal– Distances: time for motors to rotate the crystal
from one orientation to the other
• High-definition video compression– Cities: binary vectors of length 64 identifying
the summands for a particular function– Distances: Hamming distance (the number of
terms that need to be added/subtracted to get the next sum)
Key Fact about the TSP
It is NP-Complete.
P = Set of Decision problems (ones with yes-no answers) that can be solved in polynomial time.
– O(N), O(NlogN), O(N2), O(N3), …, O(N100), …
NP = Set of Decision problems such that, if the answer is yes, there exists a proof of that fact that can be verified in polynomial time.
Example: Decision problem version of the TSP.
• Given an integer k and a TSP instance with integer distances, is there a tour of length k or less?
Definitions
Still an Open Question:
Does P = NP?
Note: If you can provide a valid proof of the answer, you will win fame and fortune ($1,000,000 from the Clay Institute)
To learn more about NP-Completeness:
Obstacle to Getting Close• Theorem [Karp, 1972]: Given a graph G = (V,E), it is
NP-hard to determine whether G contains a Hamiltonian circuit (collections of edges that make up a tour).
• Given a graph, construct a TSP instance in which
d(c,c’) =
• If Hamiltonian circuit exists, OPT = N, if not, OPT > N2N.
• A polynomial-time approximation algorithm that guaranteed a tour of length no more than 2NOPT would imply P = NP.
1 if {c,c’} is in EN2N if {c,c’} is not in E{
Saving Grace from the Real World
The Triangle Inequality
For any three cities c1, c2, and c3,
d(c1,c2) ≤ d(c1,c3) + d(c3,c2).
c1
c3
c2
Nearest Neighbor (NN):1. Start with some city.
2. Repeatedly go next to the nearest unvisited neighbor of the last city added.
3. When all cities have been added, go from the last back to the first.
NN Running Time
• To find the kth vertex, k > 1, find the shortest distance among N-k-1 candidates.
• Total time = Θ( ) = Θ(N2)
• Theorem 1 [Rosenkrantz, Stearns, & Lewis,
1977]:
There exists a constant c, such that for all N > 3, there are N-city instances I obeying the triangle inequality for which we have
NN(I) > clog(N)Opt(I).
Lower Bound Examples(Unspecified distances determined by shortest paths)
F1
:
F2:
Number N1 of vertices = 3
OPT(F1) = 3+ε
NN(F1) = 3+ε1+ε
1
1
1+ε 1 1+ε 1+ε 1
1
1+ε 1
2 2
1
1
N2 = 2N1 + 3 = 9
OPT(F1) = N2+5ε = 9+5ε
NN(F2) = 14+2ε
1+ε4+2ε
Fk: 1+ε
1 1+ε
1
2k-1
1+ε
Fk-1 without shortcut between left and right endpoints
2k-1
• Theorem 2 [Rosenkrantz, Stearns, & Lewis,
1977]:
There exists a constant c, such that if instance I obeys the triangle inequality, then we have
NN(I) ≤ clog(N)Opt(I).
Corollary. For any algorithm A, let
RN(A) = max{A(I)/OPT(I): I is an N-city instance}
Then RN(NN) = Θ(log(N)) (worst-case ratio)
Nearest Insertion (NI):1. Start with 2-city tour consisting of some city and its
nearest neighbor.
2. Repeatedly insert the non-tour city u that is closest to a tour city v into the tour edge yields the smallest increase in tour length.
• Theorem 3 [Rosenkrantz, Stearns, & Lewis,
1977]:
For all instances I that obey the triangle inequality, we have
NI(I) ≤ 2Opt(I).
and R(NI) = 2.
Exploiting Triangle Inequality Directly
• Observation 1: Any connected graph in which every vertex has even degree contains an “Euler Tour” – a cycle that traverses each edge exactly once, which can be found in linear time.
• Observation 2: If the Δ-inequality holds, then traversing an Euler tour but skipping past previously-visited vertices yields a Traveling Salesman tour of no greater length.
Obtaining the Initial Graph
• Double MST algorithm (DMST):– Combine two copies of a Minimum Spanning
Tree.
– Theorem [Folklore]: DMST(I) ≤ 2Opt(I).
• Christofides algorithm (CH):– Combine one copy of an MST with a minimum-
length matching on its odd-degree vertices (there must be an even number of them since the total sum of degrees for any graph is even).
– Theorem [Christofides, 1976]: CH(I) ≤ 1.5Opt(I).
Optimal Tour on Odd-Degree Vertices(No longer than overall Optimal Tour
by the triangle inequality)
Matching M1 Matching M2+ = Optimal Tour
Hence Optimal Matching ≤ min(M1,M2) ≤ OPT(I)/2
Results for Random Euclidean Instances
Nearest Neighbor
2-Opt
3-Opt
Smart-Shortcut Christofides
Local Optimization: 2-Opt
Determining the existence of an Improving 2-Opt move
• Naïve approach: Try all N(N-3)/2 possibilities.• More sophisticated: Observe that one of the following must
be true: d(a,b) > d(b,c) or d(c,d) > d(d,a).
Suppose we consider each ordered pair (t1,t2) of adjacent tour vertices as candidates for the first deleted edge in an improving 2-opt move. Then we may restrict our attention to candidates for the new neighbor t3 of t2 that satisfy d(t2,t3) < d(t1,t2).
If the improving move to the left is not caught when (t1,t2) = (a,b), it will be caught when (t1,t2) = (c,d).
The Neighbor-List Implementation
• Basic idea: Precompute, for each city, a list of the k ≤ N-1 closest other cities, ordered by increasing distance, and also store the corresponding distances.
• Then, when looking for 2-opt moves that break the ordered tour
edge (t1,t2), we can restrict attention to the first part of the list, up
to the last city t with d(t2,t) < d(t2,t1).
• If we set k < N-1, we save space and time at the cost of no longer guaranteeing that we end up with a solution that is 2-optimal.
• Takes Θ(N2log(k)) time and O(kN) space.
• For geometric instances, we can speed this up to O(N(logN +
logk)) using kd-trees.
• My Default: Take k = 20.
Basic SchemeFor the current choice of t1, try both possible choices for t2.
If no improving move is found, go on to the next choice of t1.
If an improving move is found, make it, and then go on to the next choice for t1.
• We go for speed, even though this is not necessarily best (or fastest) in the long run.
• Results: Averages roughly 5% above Held-Karp Bound (which itself is typically 0.5% below the optimal tour length)
N 103 104 105 106
Seconds 0.17 2.2 47.5 2754
Running Time on a 150Mhz Machine from 1994.
Tour Representations
Must maintain a consistent ordering of the tour so that the following operations can be correctly performed.
1. Next(a) and Prev(a): Return the successor/predecessor of city a in the current ordering of the tour.
Tour Representations
Must maintain a consistent ordering of the tour so that the following operations can be correctly performed.
1. Next(a) and Prev(a): Return the successor/predecessor of city a in the current ordering of the tour.
2. Flip(a,b,c,d): If b = Next(a) and c = Next(d), update the tour to reflect the 2-opt move in which the tour edges (a,b) and (c,d) are replaced by (b,c) and (a,d). Otherwise, report “Invalid Move”.
Array Representation
a b c d e f g h i j k l m n o p q r s t u v w x y zTour
Array of City Indices
City
Array of Tour Indices
Next(ci) = Tour[City[i]+1(mod N)]
Prev(ci) = Tour[City[i]-1(mod N)] (analogous)
Array Representation: Flip
a b c d e f g h i j k l m n o p q r s t u v w x y zTour
Flip(f,g,p,q)
a b c d e f p o n m l k j i h g q r s t u v w x y z
Flip(x,y,c,d)
a z y d e f p o n m l k j i h g q r s t u v w x c b
Array Representation: Costs
• Next, Prev: O(1)
• Flip:θ(N)
Speed-up trick: If the segment to be flipped is greater than N/2, flip its complement.
Problem for Arrays• For random Euclidean instances, 2-opt performs θ(N) moves and, even
if we always flip the shorter segment, the average length of the segment being flipped, grows roughly as θ(N0.7) [Bentley, 1992].
• Doubly-linked lists suffer from the same problems. Can we do better with other tour representations?
• We can in fact do much better (theoretically).
• By representing the tour using a balanced binary tree, we can reduce the (amortized) time for Between and Flip to θ(log(N)) per operation, although the times for Next and Prev increase from constant to that amount. “Splay Trees” are especially useful in this context (and will be described in the next few slides).
• Significant further improvements are unlikely, however:
• Theorem [Fredman et al., 1995]. In the cell-probe model of computation, any tour representation must, in the worst case, take amortized time Ω(log(N)/loglog(N)) per operation.
Binary Tree Representation• Cities are contained in a binary tree, with a bit at each internal node to tell
whether the subtree rooted at that node should be reversed. (Bits lower down in the tree will locally undo the effect of bits at their ancestors.)
• To determine the tour represented by such a tree, simply push the reversal bits down the tree until they all disappear. An inorder traversal of the tree will then yield the tour.
• (To push a reversal bit at node x down one level, interchange the two children of x, complement their reversal bits, and turn off the reversal bit at x.)
Splay Trees[Sleator & Tarjan, “Self-adjusting binary search trees,” J. ACM 32
(1985), 652-686]
• Every time a vertex is accessed, it is brought to the root (splayed) by a sequence of rotations (local alterations of the tree that preserve the inorder traversal).
• Each rotation causes the vertex that is accessed to move upward in the tree, until eventually it reaches the root.
• The precise operation of a rotation depends on whether the vertex is the right or left child of its parent and whether the parent is the right or left child of its own parent. The change does not depend on any global properties of the subtrees involved, such as depth, etc.
• All the standard binary tree operations can be implemented to run in amortized worst-case time O(log(N)) using splays.
• In our Splay Tree tour representation, the process of splaying is made slightly more difficult by the reversal bits. We handle these by preceding each rotation by a step that pushes the reversal bits down out of the affected area. Neither the presence of the reversal bits nor the time needed to clear them affects the amortized time bound for splaying by more than a constant factor.
Splay Tree Tour Operations
Next(a):
1. Splay a to the root of the tree.
2. Traverse down the tree (taking account of reversal bits) to find the successor of a.
3. Splay the successor to the root.
Prev(a): Handled analogously.
Splay Tree Flip(a,b,c,d)
• Splay d to the root, then splay b to the root, and push all reversal bits down out of the top three levels.
• There are two possiblities:
b
d b
d
d
d
b
b
x
x
T2R denotes subtree T2 with a reversal bit applied to its
root.
Speedups(Lose theoretical guarantees for better performance in practice)
• No splays for Next and Prev – simply do tree traversals, taking into account the reversal bits.
• Operation of Flip unchanged.
• Yields about a 30% speedup.
Advantages of Splay Trees
• Ease of implementing Flip compared to other balanced binary tree implementations.
• “Self-Organizing” properties: Cities most involved in the action stay relatively close to the root. And since typically most cities drop out of the action fairly early, this can significantly reduce the time per operation.
• Splay trees start beating arrays for random Euclidean instances on modern computers somewhere between N = 100,000 and N = 316,000. They are 40% faster when N = 1,000,000.
• For more sophisticated algorithms, like Lin-Kernighan (to be discussed later), the transition point is much earlier: Splay trees are 13 times faster when N = 100,000.
ResultsN = 103 104 105 106
2-Opt [20] % Excess over HK 4.9 5.0 4.9 4.9
150 Mhz Secs 0.34 3.8 59 940
3-Opt [20] % Excess 2.5 3.1 3.0 3.0
150 Mhz Secs 0.41 4.7 69 1080
Lin-Kernighan % Excess 2.0 2.0 2.0 2.0
150 Mhz Secs 0.77 9.8 141 2650
Iterated LK (N/10) % Excess 1.3 1.3 1.3 -
150 Mhz Secs 5.1 189 10,200 -
Iterated LK (N/3) % Excess 1.0 1.0 1.1 -
150 Mhz Secs 13.6 524 30,700 -
Iterated LK (N) % Excess 0.9 0.9 - -
150 Mhz Secs 39.7 1,570 - -
Time on 3.6 Ghz Intel Core i3 processor at N = 106:
25.4 sec (2-opt), 29.5 sec (3-opt)
Optimization: Most Under-rated Algorithm
Exhaustive Search!
Obstacle: Number of Tours
(N-1)! = 12345 … (N-2)(N-1)
(Can assume that City 1 is the first city.)
N 2 3 4 5 6 7 8 9 10 15 20 30
(N-1)! 2 6 24 120 720 5,040 40,320 362,880 3.6*106 1.3*1012 2.4*1018 2.7*1032
Program for Evaluating (N-1)! Tours
for (i = 0; i < N; i++) tour[i] = i; permute(N-1, 2*MAXDIST);
void permute(int k){ int i, len;
if (k == 1) {len = tour_length();if (len < bestlen) {
bestlen = len;for (i = 0; i < N; i++) besttour[i] =
tour[i];}}else {
for (i = 0; i < k; i++) {tour_swap(i, k-1)permute(k-1);
tour_swap(i, k-1);}
}}
standard routines for
• reading instances,
• printing output,
• computing tour lengths,
• swapping elements.
We enumerate tours as follows:
Lines of Code = 86
How this works
9
Fix City N-1 = 9 in last slot
0
1
2
3
4
5
6
7
8
0
1
2
3
4
5
6
7
8
0
1
2
3
4
5
6
7
8
0
1
2
3
4
5
6
7
8
For all as yet unfixed cities
Suppose we have 10 cities: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
How this works
3 9
Suppose we have 10 cities: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
Temporarily Fix City
For all as yet unfixed cities
0
1
2
4
5
6
7
8
0
1
2
4
5
6
7
8
0
1
2
4
5
6
7
8
0
1
2
4
5
6
7
8
And so on …
Results for Basic Program
Methodology:1. Construct lower triangular distance matrix M for a 100-city
random Euclidean instance.2. Instance IN consists of the first N rows of M.
Advantages:• Somewhat better correlation between results for different N
so running time growth rates are less noisy.• Fewer instances to keep track of.
Disadvantages:• Results may be too dependent on M, so should try different
M’s
Results for Basic Program
N 10 11 12 13 14 15
(N-1)! 362,880 3,628,800 39,916,800
4.8 x 108 6.2 x 109 8.7 x 1010
Seconds 0.02 0.30 2.80 42.1 624 9,353
-O2 Secs 0.00 0.09 1.08 13.5 188 2,970
Suggestions for Speedups?
Compiler Optimization: cc –O2 exhaust.c
Lines of Code, still = 86
(Running times on 3.6 Ghz Core i7 processors in an iMac with 32 Gb RAM)
Next Speedup
Don’t need to consider both tour orientations.• Only consider the orientation in which city 1 precedes city
0.• Implement this by adding an input flag to permute(), which
equals 0 unless city 0 has already been fixed.• Lines of Code = 97, an increase of 11.
N 10 11 12 13 14 15Base Secs 0.02 0.30 2.80 42.1 624 9,353-O2 Secs 0.00 0.09 1.08 13.5 188 2,970
1 before 0 0.00 0.05 0.65 8.1 110 1,604
Next SpeedupMore efficient distance calculations
void permute(int k){ int i, len;
if (k == 1) {len = tour_length();if (len < bestlen) {
bestlen = len;for (i = 0; i < N; i++) besttour[i]
= tour[i];}}else {
for (i = 0; i < k; i++) {tour_swap(i, k-1)permute(k-1);
tour_swap(i, k-1);}
}}
void permute(int k, int tourlen){ int i, len;
if (k == 1) {tourlen += dist(tour[0],tour[1]) + dist(tour[ncount-
1],tour[0]);if (tourlen < bestlen) {
bestlen = tourlen;for (i = 0; i < N; i++) besttour[i] =
tour[i];}}else {
for (i = 0; i < k; i++) {tour_swap(i, k-1)permute(k-1,
tourlen+dist(tour[k-1],tour[k])); tour_swap(i, k-1);
}}
}
if (tourlen >= bestlen) return;
O(N) factor of improvement – probably worth one additional city.
More valuable idea: Prune!
Lines of code increases from 97 to 99
Results
N 15 16 17 18 19 20 211 before 0 1604 -- -- -- -- -- --
Tourlen 0.50 1.25 3.81 40.3 280 824 4560
Next Speeduptourlen only includes the costs of edges linking the city in slot k through the city in slot N-1.
We would get more effective pruning if we could take into account the edges linking the cities that haven’t yet been fixed.
More precisely we could use a lower bound on the minimum length path involving these cities and linking the city in slot k to city N-1.
An obvious first choice is the length of a minimum spanning tree connecting all these cities.
void permute(int k, int tourlen){ int i, len;
if (k == 1) {tourlen += dist(tour[0],tour[1]) + dist(tour[ncount-
1],tour[0]);if (tourlen < bestlen) {
bestlen = tourlen;for (i = 0; i < N; i++) besttour[i] =
tour[i];}}else {
for (i = 0; i < k; i++) {tour_swap(i, k-1)permute(k-1,
tourlen+dist(tour[k-1],tour[k])); tour_swap(i, k-1);
}}
}
if (tourlen >= bestlen) return;if (tourlen + mst(k+1) >= bestlen) return
Lines of code increases from 99 to 134
Results
N 20 21 22 23 24 25 26 27 28 29 30 31Tourlen 824 4560 -- -- -- -- -- -- -- -- -- --
mst 0.15 0.20 0.54 1.44 0.76 2.79 29.5 14.0 17.1 12.3 103.5 84.1
N 32 33 34 35 36 37 38 39 40 41 42 43mst 29.3 43.2 84.6 157 290 232 824 316 225 987 2297 5866
Next Speedupbestlen isn’t so hot either, at least initially.
If we start by simply setting bestlen to the Nearest Neighbor tour length, it would seem likely to have a benefit, and it doesn’t take much coding effort --
Lines of code goes from 134 to 155.
void permute(int k, int tourlen){ int i, len;
if (k == 1) {tourlen += dist(tour[0],tour[1]) + dist(tour[ncount-
1],tour[0]);if (tourlen < bestlen) {
bestlen = tourlen;for (i = 0; i < N; i++) besttour[i] =
tour[i];}}else {
for (i = 0; i < k; i++) {tour_swap(i, k-1)permute(k-1,
tourlen+dist(tour[k-1],tour[k])); tour_swap(i, k-1);
}}
}
if (tourlen + mst(k+1) >= bestlen) return
Results
N 32 33 34 35 36 37 38 39 40 41 42 43mst 29.3 43.2 84.6 157 290 232 824 316 225 987 2297 5866
nn 2.9 8.0 24.6 1.3 4.3 4.9 26.8 101 55 407 1357 3653
Next Speedup• As we know from our earlier discussions of tour-construction
heuristics, Nearest Neighbor is a pretty lousy bound, typically 24% above optimal for random Euclidean instances.
• Question: How can we get a better bound cheaply?
• Answer: Guess low – say at (3/4)NN.
– The algorithm will presumably run faster if our initial value of bestlen is less than the optimal tour length.
– If no solution is found, we can rerun the algorithm with an incrementally increased initial value for bestlen, say 5% above the previous value.
– When our initial value eventually exceeds optimal, it will not exceed it by more than 5% (much better than 24%).
– Lines of code increases from 155 to 165.
Results
N 37 38 39 40 41 42 43 44 45 46 47 48nn 232 824 316 225 987 2297 5866 -- -- -- -- --
Iterative 19 71 12 15 33 121 149 2223 756 684 3185 4304
Next Speedup
• A large amount of our time goes into computing MST’s, and much of it may be repeated for different permutations of the same set of cities.
• Could we save time by hashing the results so as to avoid this duplication?
Results
N 46 47 48 49 50 51 52 53 54 55 56 57Iterative 684 3185 4304 -- -- -- -- -- -- -- -- --hashing 45 183 254 860 1602 3397 1402 8360 2815 589 680 4699
With more sophisticated ideas (involving more-than-elementary TSP ideas), we can be under 3600 seconds for all
N ≤ 100.But we are clearly running out of gas, and an entirely
different approach is needed.
Fortunately, one exists.
Integer Programming formulation of the TSP
Variable x{u,v} for each pair of cities {u,v} ⊆ C, with x{u,v} = 1 meaning the edge {u,v} is in the tour.
Goal: Minimize ∑{u,v}d(u,v)x{u,v}
Subject to:
1) x{u,v} ∈ {0,1} for all pairs {u,v},
2) ∑u∈C x{u,v} = 2 for all fixed cities v, and
3) ∑{u,v}: u ∈ S and v ∉ S x{u,v} ≥ 2 for all proper subsets S ⊂ C.
Linear Programming Relaxation of the TSP
Variable x{u,v} for each pair of cities {u,v} ⊆ C, with x{u,v} = 1 meaning the edge {u,v} is in the tour.
Goal: Minimize ∑{u,v}d(u,v)x{u,v}
Subject to:
1) x{u,v} ∈ [0,1] for all pairs {u,v},
2) ∑u∈C x{u,v} = 2 for all fixed cities v, and
3) ∑{u,v}: u ∈ S and v ∉ S x{u,v} ≥ 2 for all proper subsets S ⊂ C.
Solvable in polynomial time.
The solution is the “Held-Karp Lower Bound” mentioned earlier.
The Cutting Plane Approach, Illustrated
-- Points in RN(N-1)/2 corresponding to a tour.
Hyperplane perpendicular to the vector of edge lengths
Optimal Tour
Optimal Tour is a point on the convex hull of all tours.
Unfortunately, the LP relaxation of the TSP can be a very poor approximation to the convex hull of tours.
Facet
To improve it, add more constraints (“cuts”)
Note: Subtour constraints are all facets.
Branch & Cut
• Use the Cutting Plane approach, but when you get stuck or hit a point of diminishing returns, divide into subcases, such as– Edge {u,v} must be in the tour or cannot be in the tour– The total weight on edges out of a particular S ⊂ C is
either less than or equal to 2, or greater than 4.
Initial LP, UB = 100, LB = 90
LB = 92 LB = 93
X{a,b} = 0 X{a,b} = 1
LB = 92 LB = 100 LB = 98 LB = 97
X{a,c} = 0X{c,d} = 0 X{c,d} = 1 X{a,c} = 1
LB = 101 LB = 100
X{e,a} = 0 X{e,a} = 1
New Opt = 97
UB = 97
Opt = 97
N = 85,900
Current World Record (2006)
Using a parallelized version of the Concorde code, Helsgaun’s sophisticated variant on Iterated Lin-Kernighan, and 2719.5 cpu-days
Concorde • “Branch-and-Cut” approach exploiting linear programming
to determine lower bounds on optimal tour length.
• Based on 30+ years of theoretical developments in the “Mathematical Programming” community, plus some very good data structures and heuristics work from computer science.
• For surprisingly large instances, it finds an optimal tour and proves its optimality (unless it runs out of time/space).
• Executables and source code can be downloaded from http://www.math.uwaterloo.ca/tsp/
Running times (in seconds) for 10,000 Concorde runs on random 1000-city planar Euclidean instances (2.66 Ghz Intel Xeon processor in dual-processor PC, purchased late 2002).
Range: 7.1 seconds to 38.3 hours
Concorde Asymptotics[Hoos and Stϋtzle, to appear in Eur. J. Op. Res., 2014]
• Estimated median running time for random Euclidean instances.
• Based on– 1000 samples each for N = 500,600,…,2000– 100 samples each for N = 2500, 3000,3500,4000,4500– 2.4 Ghz AMD Opteron 2216 processors with 1MB L2
cache and 4 GB main memory, running Cluster Rocks Linux v4.2.1.
0.21 · 1.24194 √N
Actual median for N = 2000: ~57 minutes, for N = 4,500: ~96 hours
Where to Learn More: Books
The Traveling Salesman Problem, Lawler, Lenstra, Rinnooy Kan, and Shmoys (Editors), Wiley (1985). $377.47 (current amazon.com price, new)
The Traveling Salesman Problem and Its Variations, Gutin and Punnen (Editors), Kluwer (2002). $152.10
The Traveling Salesman Problem: A Computational Study, Applegate, Bixby, Chvatal, and Cook, Princeton University Press (2006). $57.99/$44.99 (Kindle)
In Pursuit of the Traveling Salesman, Cook, Princeton University Press (2012). $20.64/$15.37 (Kindle)
Web Resourceshttp://davidsjohnson.net/papers.html
(David Johnson’s downloadable papers on the TSP and other topics, plus slides for lectures in this year’s course on “The Traveling Salesman Problem in Theory and Practice”)
http://www.math.uwaterloo.ca/tsp/
“The Traveling Salesman Problem” (Bill Cook)
http://dimacs.rutgers.edu/Challenges/TSP/
“The 8th DIMACS Implementation Challenge: The Traveling Salesman Problem” (DSJ)
http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/
“TSPLIB” (Testbed of Instances, Gerd Reinelt)
http://en.wikipedia.org/wiki/Travelling_salesman_problem
(Wikipedia Entry -- Much Improved)
Clay Institute $1,000,000 Prize for P versus NP
http://www.claymath.org/millenium-problems/p-vs-np-problem
http://www.math.uwaterloo.ca/tsp/
Standard Shortcuts
Smart Shortcuts
Assume we have an algorithm ALB that computes a lower bound on the TSP length when
certain edges are fixed (forced to be in the tour, or forced not to be in the tour), and which, for some subproblems, may produce a tour as well.
• Start with an initial heuristic-created “champion” tour TUB, an upper bound UB =
length(TUB) on the optimal tour length, and a single “live” subproblem in which no
edge is fixed.
• While there is a live subproblem, pick one, say subproblem P, and apply algorithm ALB
to it.
– If LB < UB
1. Pick an edge e that is unfixed in P and create two new subproblems as its children, one with e forced to be in the tour, and one with e forced not to be in the tour.
2. If algorithm ALB produced a tour T, and length(T) < UB
1. Set UB = length(T) and TUB = T.
2. Delete all subproblems with current LB ≥ UB, as well as their children and their ancestors that no longer have any live children.
– Otherwise (LB ≥ UB), delete subproblem P and all its ancestors that no longer have live children.
• Halt. Our current champion is an optimal tour.
Branch & Bound for the TSP
Set Hashing• Start by creating random unsigned ints hashkey[i], 0 ≤ i < N.
• Create an initial empty hashtable MstTable, say of size hashsize = 524288 = 219. (We will double the size of MstTable whenever half of its entries become full.)
• The hash value hval(C) for a set C of cities is obtained by computing the exclusive-or of the |C| values {hashkey[i]: i ∈ C}. (The ith bit of the hash value is 1 if and only if an odd number of the ith bits of the keys equal 1.)
• Because MstTable can grow, hval(C) will actually refer to the entry with index hval(C)%hashsize (the remainder when hval(c) is divided by hashsize).
• An entry in the table will consist of two items:
– The length Bnd of the minimum spanning tree for the cities in C.
– A bitmap B of length N, with B[i] = 1 if and only if i ∈ C.
• We will handle the possibility of collisions by using “linear probing”.
Linear Probing• To add the MST value for a new set C to the hashtable, we first try
MstTable[i] for i = hval(C)%hashsize. If that location already has an entry, set i = i+1(mod hashsize) and perform the following loop to find a suitable location:
– While {MstTbl[i] is full, set i = i+1(mod hashsize)}
• In the worst case, this could take time proportional to hashsize, but there are simple tabulation-based schemes that can be shown to take amortized constant time per search [Patrascu & Thorup].
• To check to see if we have already computed the MST for C, we follow a similar scheme, where we start by setting i = hval(C)%hashsize.
– While MstTbl[i] is not empty
• If MstTbl[i].bitmap equals the bitmap for C, return MstTable[i].Bnd.
• Set i = i+1(mod hashsize).
– Return “Not Cached”.(Lines of code increases from 165 to
274)