Full algorithm

Author: Retsediv

christofides.py

@@ -1,8 +1,4 @@
 def tsp(data):
-    length = 0
-    visited = [False] * len(data)
-    paths = []
-
     G = build_graph(data)
     print("Graph: ", G)
 
@@ -17,26 +13,31 @@ def tsp(data):
     minimum_weight_matching(MSTree, G, odd_vertexes)
     print("Minimum weight matching: ", MSTree)
 
-    eulerian_tour = find_eulerian_tour(MSTree)
-    visited = [False] * (len(eulerian_tour) - 1)
-
+    eulerian_tour = find_eulerian_tour(MSTree, G)
 
     print("Eulerian tour: ", eulerian_tour)
 
     current = eulerian_tour[0]
-    paths = [current]
-    for x in eulerian_tour[1:]:
-        if not visited[x]:
-            visited[x] = True
+    path = [current]
+    visited = [False] * len(eulerian_tour)
 
-            paths.append(x)
-            length += G[current][x]
+    length = 0
 
-            current = x
+    for v in eulerian_tour[1:]:
+        if not visited[v]:
+            path.append(v)
+            visited[v] = True
 
-    print("Result path: ", paths)
+            length += G[current][v]
+            current = v
+
+    path.append(path[0])
+
+    print("Result path: ", path)
     print("Result length of the path: ", length)
 
+    return length, path
+
 
 def get_length(x1, y1, x2, y2):
     return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1 / 2)
@@ -57,31 +58,11 @@ def build_graph(data):
 
 
 class UnionFind:
-    """Union-find data structure.
-
-    Each unionFind instance X maintains a family of disjoint sets of
-    hashable objects, supporting the following two methods:
-
-    - X[item] returns a name for the set containing the given item.
-      Each set is named by an arbitrarily-chosen one of its members; as
-      long as the set remains unchanged it will keep the same name. If
-      the item is not yet part of a set in X, a new singleton set is
-      created for it.
-
-    - X.union(item1, item2, ...) merges the sets containing each item
-      into a single larger set.  If any item is not yet part of a set
-      in X, it is added to X as one of the members of the merged set.
-    """
-
     def __init__(self):
-        """Create a new empty union-find structure."""
         self.weights = {}
         self.parents = {}
 
     def __getitem__(self, object):
-        """Find and return the name of the set containing the object."""
-
-        # check for previously unknown object
         if object not in self.parents:
             self.parents[object] = object
             self.weights[object] = 1
@@ -100,11 +81,9 @@ def __getitem__(self, object):
         return root
 
     def __iter__(self):
-        """Iterate through all items ever found or unioned by this structure."""
         return iter(self.parents)
 
     def union(self, *objects):
-        """Find the sets containing the objects and merge them all."""
         roots = [self[x] for x in objects]
         heaviest = max([(self.weights[r], r) for r in roots])[1]
         for r in roots:
@@ -145,44 +124,100 @@ def find_odd_vertexes(MST):
 
 
 def minimum_weight_matching(MST, G, odd_vert):
+    import random
+    odd_vert = random.shuffle(odd_vert)
+
     while odd_vert:
         v = odd_vert.pop()
         length = float("inf")
         u = 1
         closest = 0
         for u in odd_vert:
-            if G[v][u] < length:
+            if v != u and G[v][u] < length:
                 length = G[v][u]
                 closest = u
 
         MST.append((v, closest, length))
         odd_vert.remove(closest)
 
 
-def find_eulerian_tour(MatchedMSTree):
-    tour = []
+def find_eulerian_tour(MatchedMSTree, G):
+    # find neigbours
+    neighbours = {}
+    for edge in MatchedMSTree:
+        if edge[0] not in neighbours:
+            neighbours[edge[0]] = []
 
-    start_vertex = MatchedMSTree[0][0]
+        if edge[1] not in neighbours:
+            neighbours[edge[1]] = []
 
-    tour.append(start_vertex)
+        neighbours[edge[0]].append(edge[1])
+        neighbours[edge[1]].append(edge[0])
+
+    # print("Neighbours: ", neighbours)
+
+    # finds the hamiltonian circuit
+    start_vertex = MatchedMSTree[0][0]
+    EP = [neighbours[start_vertex][0]]
 
     while len(MatchedMSTree) > 0:
-        current_vertex = tour[len(tour) - 1]
-        for edge in MatchedMSTree:
-            if current_vertex in edge:
-                if edge[0] == current_vertex:
-                    current_vertex = edge[1]
-                elif edge[1] == current_vertex:
-                    current_vertex = edge[0]
-                else:
-                    # Edit to account for case no tour is possible
-                    return False
-
-                MatchedMSTree.remove(edge)
-                tour.append(current_vertex)
+        for i, v in enumerate(EP):
+            if len(neighbours[v]) > 0:
                 break
 
-    return tour
+        while len(neighbours[v]) > 0:
+            w = neighbours[v][0]
+
+            remove_edge_from_matchedMST(MatchedMSTree, v, w)
+
+            del neighbours[v][(neighbours[v].index(w))]
+            del neighbours[w][(neighbours[w].index(v))]
+
+            i += 1
+            EP.insert(i, w)
+
+            v = w
+
+    return EP
+
+
+def remove_edge_from_matchedMST(MatchedMST, v1, v2):
+
+    for i, item in enumerate(MatchedMST):
+        if (item[0] == v2 and item[1] == v1) or (item[0] == v1 and item[1] == v2):
+            del MatchedMST[i]
+
+    return MatchedMST
+
+
+tsp([[1380, 939], [2848, 96], [3510, 1671], [457, 334], [3888, 666], [984, 965], [2721, 1482], [1286, 525],
+             [2716, 1432], [738, 1325], [1251, 1832], [2728, 1698], [3815, 169], [3683, 1533], [1247, 1945], [123, 862],
+             [1234, 1946], [252, 1240], [611, 673], [2576, 1676], [928, 1700], [53, 857], [1807, 1711], [274, 1420],
+             [2574, 946], [178, 24], [2678, 1825], [1795, 962], [3384, 1498], [3520, 1079], [1256, 61], [1424, 1728],
+             [3913, 192], [3085, 1528], [2573, 1969], [463, 1670], [3875, 598], [298, 1513], [3479, 821], [2542, 236],
+             [3955, 1743], [1323, 280], [3447, 1830], [2936, 337], [1621, 1830], [3373, 1646], [1393, 1368],
+             [3874, 1318], [938, 955], [3022, 474], [2482, 1183], [3854, 923], [376, 825], [2519, 135], [2945, 1622],
+             [953, 268], [2628, 1479], [2097, 981], [890, 1846], [2139, 1806], [2421, 1007], [2290, 1810], [1115, 1052],
+             [2588, 302], [327, 265], [241, 341], [1917, 687], [2991, 792], [2573, 599], [19, 674], [3911, 1673],
+             [872, 1559], [2863, 558], [929, 1766], [839, 620], [3893, 102], [2178, 1619], [3822, 899], [378, 1048],
+             [1178, 100], [2599, 901], [3416, 143], [2961, 1605], [611, 1384], [3113, 885], [2597, 1830], [2586, 1286],
+             [161, 906], [1429, 134], [742, 1025], [1625, 1651], [1187, 706], [1787, 1009], [22, 987], [3640, 43],
+             [3756, 882], [776, 392], [1724, 1642], [198, 1810], [3950, 1558]])
 
+# tsp([[1, 1], [2, 5], [8, 0]])
 
-tsp([[1, 1], [2, 5], [8, 0]])
+#
+# tsp([
+#     [0, 0],
+#     [3, 0],
+#     [6, 0],
+#
+#     [0, 3],
+#     [3, 3],
+#     [6, 3],
+#
+#     [0, 6],
+#     [3, 6],
+#     [6, 6],
+#
+# ])