# The Traveling-salesman Problem

**The traveling-salesman problem**: In the ** traveling-salesman problem**, which is closely related to the hamiltonian-cycle problem, a salesman must visit

*n*cities. Modeling the problem as a complete graph with

*n*vertices, we can say that the salesman wishes to make a

**, or hamiltonian cycle, visiting each city exactly once and finishing at the city he starts from. There is an integer cost**

*tour**c*(

*i*,

*j*) to travel from city

*i*to city

*j*, and the salesman wishes to make the tour whose total cost is minimum, where the total cost is the sum of the individual costs along the edges of the tour. For example, in Figure 34.18, a minimum-cost tour is 〈

*u*,

*w*,

*v*,

*x*,

*u*〉, with cost 7. The formal language for the corresponding decision problem is

TSP = {〈*G*, *c*, *k*〉 : *G* = (*V*, *E*) is a complete graph, *c* is a function from *V* × *V* → **Z**, *k* ∈ **Z**, and *G* has a traveling-salesman tour with cost at most *k*}.

Figure 34.18: An instance of the traveling-salesman problem. Shaded edges represent a minimum-cost tour, with cost 7.

The following theorem shows that a fast algorithm for the traveling-salesman problem is unlikely to exist.

**Theorem 34.14**: The traveling-salesman problem is NP-complete.

** Proof** We first show that TSP belongs to NP. Given an instance of the problem, we use as a certificate the sequence of

*n*vertices in the tour. The verification algorithm checks that this sequence contains each vertex exactly once, sums up the edge costs, and checks whether the sum is at most

*k*. This process can certainly be done in polynomial time.

To prove that TSP is NP-hard, we show that HAM-CYCLE ≤_{P} TSP. Let *G* = (*V*, *E*) be an instance of HAM-CYCLE. We construct an instance of TSP as follows. We form the complete graph *G*' = (*V*, *E*'), where *E*' = {(*i*, *j*) : *i*, *j* ∈ *V* and *i* ≠ *j*}, and we define the cost function *c* by

(Note that because *G* is undirected, it has no self-loops, and so *c*(*v*, *v*) = 1 for all vertices *v* ∈ *V*.) The instance of TSP is then (*G*', *c*, 0), which is easily formed in polynomial time.

We now show that graph *G* has a hamiltonian cycle if and only if graph *G*' has a tour of cost at most 0. Suppose that graph *G* has a hamiltonian cycle *h*. Each edge in *h* belongs to *E* and thus has cost 0 in *G*'. Thus, *h* is a tour in *G*' with cost 0. Conversely, suppose that graph *G*' has a tour *h*' of cost at most 0. Since the costs of the edges in *E*' are 0 and 1, the cost of tour *h*' is exactly 0 and each edge on the tour must have cost 0. Therefore, *h*' contains only edges in *E*. We conclude that *h*' is a hamiltonian cycle in graph *G*.

The following algorithm implements this approach, calling the minimum-spanning-tree algorithm MST-PRIM from algorithms of Kruskal and Prim as a subroutine.

APPROX-TSP-TOUR(G,c"> 1 select a vertexr∈V[G] to be a "root" vertex 2 compute a minimum spanning treeTforGfrom rootrusing MST-PRIM(G,c,r) 3 letLbe the list of vertices visited in a preorder tree walk ofT4returnthe hamiltonian cycleHthat visits the vertices in the orderL

Recall from binary search tree that a preorder tree walk recursively visits every vertex in the tree, listing a vertex when it is first encountered, before any of its children are visited.

**Example: **

Figure 35.2: The operation of APPROX-TSP-TOUR. *(a)* The given set of points, which lie on vertices of an integer grid. For example, *f* is one unit to the right and two units up from *h*. The ordinary euclidean distance is used as the cost function between two points. *(b)* A minimum spanning tree *T* of these points, as computed by MST-PRIM. Vertex a is the root vertex. The vertices happen to be labeled in such a way that they are added to the main tree by MST-PRIM in alphabetical order. *(c)* A walk of *T* , starting at *a*. A full walk of the tree visits the vertices in the order *a, b, c, b, h, b, a, d, e, f, e, g, e, d, a*. A preorder walk of *T* lists a vertex just when it is first encountered, as indicated by the dot next to each vertex, yielding the ordering *a, b, c, h, d, e, f, g. (d)* A tour of the vertices obtained by visiting the vertices in the order given by the preorder walk. This is the tour *H* returned by APPROX-TSP-TOUR. Its total cost is approximately 19.074. *(e)* An optimal tour *H** for the given set of vertices. Its total cost is approximately 14.715.