The **traveling salesman problem** (TSP), also known as the **traveling salesperson problem**, is a problem in discrete or combinatorial optimization. It is a prominent illustration of a class of problems in computational complexity theory.

The problem can be stated as: Given a number of cities and the costs of travelling from one to the other, what is the cheapest roundtrip route that visits each city and then returns to the starting city?

An equivalent formulation in terms of graph theory is: Find the shortest Hamiltonian cycle in a weighted graph.

A related problem is the **Bottleneck traveling salesman problem** (bottleneck TSP): Find the Hamiltonian cycle in a weighted graph with the minimal length of the longest edge.

Table of contents |

2 Algorithms 3 External Links |

The most direct solution would be to try all the combinations and see which one is cheapest, but given that the number of combinations is N! (the factorial of the number of cities), this solution rapidly becomes impractical.

The problem has been shown to be NP-hard, and the decision version of it ("given the costs and a number *x*, decide whether there is a roundtrip route cheaper than *x*") is NP-complete.

The bottleneck TSP is also NP-hard.

The problem is of considerable practical importance, for example in printed circuit assembly automation, where holes or component locations play the part of cities. Various approximation algorithms, which "quickly" yield "good" solutions with "high" probability, have been devised. An approximative solution for 15,112 cities in Germany was found in 2001 by Princeton University scholars.

The traditional lines of attack of the NP-hard problems are the following:

- Devising algorithms for finding exact solutions (they will work reasonably fact only for relatively small problem sizes)
- Devising "suboptimal" or heuristic algorithms, i.e., algorithms that deliver seemingly or provably good solutions, but which could not proved to be optimal.
- Finding special cases for the problem ("subproblems") for which either exact or better heuristics are posible.

- Various branch-and-bound algorithms, which can be used to process TSPs containing 40-60 cities.
- Progressive improvement algorithms which use techniques reminiscent of linear programming works well up to 120-200 cities.

- The nearest neighbour algorithm, which is normally fairly close to the optimal route, and doesn't take too long to execute. Unfortunately it is can be provably reliable only for special cases of the TSP. In general case, however there exists an example for which the nearest neighbour algorithm gives the
**worst**possible route. -
**Pairwise exchange**, or**Kernighan-Lin**heuristics. - Optimised Markov chain algorithms which utilise local searching heuristical sub-algorithms can find a route extremely close to the optimal route for 700-800 cities.

**Euclidean TSP**, or **planar TSP**, is the TSP with the distance being the ordinary Euclidean distance. The problem stii remains NP-hard, however many heuristics work better. It turns out that the instrumental property in this case is the triangle inequality.

The length of the minimum spanning tree of the network is a natural lower bound for the length of the optimal route. In the TSP with triangle inequality case it as possible to prove upper bounds in terms of the minimum spanning tree and design an algorithm that has provable upper bound on the length of the route. The first published (and the simplest) example follows.

- Step 1: Construct the minimal spanning tree.
- Step 2: Duplicate all its edges. This gives us an Eulerian graph.
- Step 3: Find an Eulerian cycle in it. Clearly, its length is twice the length of the tree.
- Step 4: Convert the Eulerian cycle into the Hamiltonian one in the following way: walk along the Eulerian cycle, and each time you are about to come into an already visited vertex, skip it and try to go to the next one (along the Eulerian cycle).

Better implementations of this heuristic are known, as well as other heuristics with better worst case estimates.

See also:

- http://www.math.princeton.edu/tsp/index.html (Princeton University TSP page)
- http://www.pcug.org.au/~dakin/tsp.htm (private web page with 2 algorithms & demo program to download)
- http://cs.felk.cvut.cz/~xobitko/ga/tspexample.html (Example of finding approximate solution of TSP problem using Genetic algorithm)