Edit filter log

'[[File:2-opt wiki.svg|thumb|2-opt]] In [[Optimization (mathematics)|optimization]], '''2-opt''' is a simple local search algorithm for solving the [[traveling salesman problem]]. The 2-opt algorithm was first proposed by Croes in 1958,<ref>G. A. Croes, A method for solving traveling salesman problems. Operations Res. 6 (1958) , pp., 791-812. </ref> although the basic move had already been suggested by Flood.<ref>M. M. Flood, The traveling-salesman problem. Operations Res. 4 (1956) , pp., 61-75.</ref> The main idea behind it is to take a route that crosses over itself and reorder it so that it does not. - A B - - A - B - × ==> - C D - - C - D - A complete 2-opt local search will compare every possible valid combination of the swapping mechanism. This technique can be applied to the traveling salesman problem as well as many related problems. These include the [[vehicle routing problem]] (VRP) as well as the capacitated VRP, which require minor modification of the algorithm. This is the mechanism by which the 2-opt swap manipulates a given route. Here v1 and v2 are the first vertices of the edges you wish to swap when traversing through the route: '''procedure''' 2optSwap(route, v1, v2) { 1. take route[0] to route[v1] and add them in order to new_route 2. take route[v1+1] to route[v2] and add them in reverse order to new_route 3. take route[v2+1] to route[end] and add them in order to new_route '''return''' new_route; } Here is an example of the above with arbitrary input: * Example route: A → B → E → D → C → F → G → H → A * Example parameters: v1=1, v2=4 (starting index 0) * Contents of new_route by step: *# '''(A → B)''' *# A → B → '''(C → D → E)''' *# A → B → C → D → E → '''(F → G → H → A)''' This is the complete 2-opt swap making use of the above mechanism: '''repeat until''' no improvement is made { best_distance = calculateTotalDistance(existing_route) start_again: '''for''' (i = 0; i <= number of nodes eligible to be swapped - 1; i++) { '''for''' (j = i + 1; j <= number of nodes eligible to be swapped; j++) { new_route = 2optSwap(existing_route, i, j) new_distance = calculateTotalDistance(new_route) '''if''' (new_distance < best_distance) { existing_route = new_route best_distance = new_distance goto start_again } } } } Note: If you start/end at a particular node or depot, then you must remove this from the search as an eligible candidate for swapping, as reversing the order will cause an invalid path. For example, with depot at A: A → B → C → D → A Swapping using node[0] and node[2] would yield C → B → A → D → A which is not valid (does not leave from A, the depot). == Efficient Implementation == Building the new route and calculating the distance of the new route can be a very expensive operation, usually <math>O(n)</math> where '''n''' is the number of vertices in the route. This can be converted into an <math>O(1)</math> operation. Since a 2-opt operation involves removing 2 edges and adding 2 different edges we can subtract and add the distances of only those edges. lengthDelta = - dist(route[v1], route[v1+1]) - dist(route[v2], route[v2+1]) + dist(route[v1+1], route[v2+1]) If <code>lengthDelta</code> is negative that would mean that the new distance after the swap would be smaller. Once it is known that <code>lengthDelta</code> is negative, then we perform a 2-opt swap. This saves us a lot of computation. Also using squared distances there helps reduce the computation by skipping a square root function call. Since we only care about comparing two distances and not the exact distance, this will help speed things up. Its not much, but it helps with large problems that have small time constraints. <syntaxhighlight lang="c++"> void do2Opt(vector<Point> &path, int i, int j) { reverse(begin(path) + i + 1, begin(path) + j + 1); } vector<Point> path = ...a vector of x,y points...; // The starting vertex is not included at the end int curLength = pathLengthSq(path); // Squared length of the entire path, including the distance from last vertex to the first int n = path.size(); bool foundImprovement = true; while (foundImprovement) { foundImprovement = false; for(int i=0; i <= n - 2; i++) { for(int j=i+1; j <= n - 1; j++) { int lengthDelta = - path[i].dist2(path[i + 1 % n]) - path[j].dist2(path[(j + 1) % n]) + path[i].dist2(path[j]) + path[i + 1 % n].dist2(path[(j + 1) % n]); // If the length of the path is reduced, do a 2-opt swap if (lengthDelta < 0) { do2Opt(path, i, j); curLength += lengthDelta; foundImprovement = true; } } } } </syntaxhighlight> ==See also== *[[3-opt]] *[[local search (optimization)]] *[[Lin–Kernighan heuristic]] ==References== {{Reflist}} * {{cite book|author = G. A. CROES | year = 1958 | title = A method for solving traveling salesman problems | publisher = Operations Res. 6 (1958) , pp., 791-812.}} * {{cite book|author = M. M. FLOOD | year = 1956 | title = The traveling-salesman problem | publisher = Operations Res. 4 (1956) , pp., 61-75.}} ==External links== *[https://www.cs.ubc.ca/~hutter/previous-earg/EmpAlgReadingGroup/TSP-JohMcg97.pdf The Traveling Salesman Problem: A Case Study in Local Optimization] *[http://www-e.uni-magdeburg.de/mertens/TSP/node3.html Improving Solutions: 2-opt Exchanges] [[Category:Heuristic algorithms]] [[Category:Travelling salesman problem]]'