Traveling Sales Person  Family of functions¶
pgr_TSP  When input is given as matrix cell information.
pgr_TSPeuclidean  When input are coordinates.
Table of Contents
General Information¶
Problem Definition¶
The travelling salesman problem (TSP) or travelling salesperson problem asks the following question:
Given a list of cities and the distances between each pair of cities, which is the shortest possible route that visits each city exactly once and returns to the origin city?
Origin¶
 The traveling sales person problem was studied in the 18th century by mathematicians
Sir William Rowam Hamilton and Thomas Penyngton Kirkman.
A discussion about the work of Hamilton & Kirkman can be found in the book Graph Theory (Biggs et al. 1976).
ISBN13: 9780198539162
ISBN10: 0198539169
It is believed that the general form of the TSP have been first studied by Kalr Menger in Vienna and Harvard. The problem was later promoted by Hassler, Whitney & Merrill at Princeton. A detailed description about the connection between Menger & Whitney, and the development of the TSP can be found in On the history of combinatorial optimization (till 1960)
Characteristics¶
The travel costs are symmetric:
traveling costs from city A to city B are just as much as traveling from B to A.
This problem is an NPhard optimization problem.
To calculate the number of different tours through \(n\) cities:
Given a starting city,
There are \(n1\) choices for the second city,
And \(n2\) choices for the third city, etc.
Multiplying these together we get \((n1)! = (n1) (n2) . . 1\).
Now since our travel costs do not depend on the direction we take around the tour:
this number by 2
\((n1)!/2\).
Simulated Annealing Algorithm¶
The simulated annealing algorithm was originally inspired from the process of annealing in metal work.
Annealing involves heating and cooling a material to alter its physical properties due to the changes in its internal structure. As the metal cools its new structure becomes fixed, consequently causing the metal to retain its newly obtained properties.
Pseudocode
Given an initial solution, the simulated annealing process, will start with a high temperature and gradually cool down until the desired temperature is reached.
For each temperature, a neighbouring new solution newSolution is calculated. The higher the temperature the higher the probability of accepting the new solution as a possible bester solution.
Once the desired temperature is reached, the best solution found is returned
Solution = initial_solution;
temperature = initial_temperature;
while (temperature > final_temperature) {
do tries_per_temperature times {
newSolution = neighbour(solution);
If P(E(solution), E(newSolution), T) >= random(0, 1)
solution = newSolution;
}
temperature = temperature * cooling factor;
}
Output: the best solution
pgRouting Implementation¶
pgRouting’s implementation adds some extra parameters to allow some exit controls within the simulated annealing process.
max_changes_per_temperature
:Limits the number of changes in the solution per temperature
Count is reset to \(0\) when temperature changes
Count is increased by :math: 1 when solution changes
max_consecutive_non_changes
:Limits the number of consecutive non changes per temperature
Count is reset to \(0\) when solution changes
Count is increased by :math: 1 when solution changes
max_processing_time
:Limits the time the simulated annealing is performed.
Solution = initial_solution;
temperature = initial_temperature;
WHILE (temperature > final_temperature) {
DO tries_per_temperature times {
newSolution = neighbour(solution);
If Probability(E(solution), E(newSolution), T) >= random(0, 1)
solution = newSolution;
BREAK DO WHEN:
max_changes_per_temperature is reached
OR max_consecutive_non_changes is reached
}
temperature = temperature * cooling factor;
BREAK WHILE WHEN:
no changes were done in the current temperature
OR max_processing_time has being reached
}
Output: the best solution found
Choosing parameters¶
There is no exact rule on how the parameters have to be chose, it will depend on the special characteristics of the problem.
If the computational time is crucial, then limit execution time with max_processing_time.
Make the tries_per_temperture depending on the number of cities (\(n\)), for example:
Useful to estimate the time it takes to do one cycle: use 1
this will help to set a reasonable max_processing_time
\(n * (n1)\)
\(500 * n\)
For a faster decreasing the temperature set cooling_factor to a smaller number, and set to a higher number for a slower decrease.
When for the same given data the same results are needed, set randomize to false.
When estimating how long it takes to do one cycle: use false
A recommendation is to play with the values and see what fits to the particular data.
Description of the Control Parameters¶
The control parameters are optional, and have a default value.
Parameter 
Type 
Default 
Description 

start_vid 

0 
The greedy part of the implementation will use this identifier. 
end_vid 

0 
Last visiting vertex before returning to start_vid. 
max_processing_time 

+infinity 
Stop the annealing processing when the value is reached. 
tries_per_temperature 

500 
Maximum number of times a neighbor(s) is searched in each temperature. 
max_changes_per_temperature 

60 
Maximum number of times the solution is changed in each temperature. 
max_consecutive_non_changes 

100 
Maximum number of consecutive times the solution is not changed in each temperature. 
initial_temperature 

100 
Starting temperature. 
final_temperature 

0.1 
Ending temperature. 
cooling_factor 

0.9 
Value between between 0 and 1 (not including) used to calculate the next temperature. 
randomize 

true 
Choose the random seed

Description of the return columns¶
Returns SET OF (seq, node, cost, agg_cost)
Column 
Type 
Description 

seq 

Row sequence. 
node 

Identifier of the node/coordinate/point. 
cost 


agg_cost 

