Initial commit

Author: Retsediv

christofides.py

@@ -0,0 +1,144 @@
+def tsp(data):
+    length = 0
+    visited = [False] * len(data)
+    paths = []
+
+    G = build_graph(data)
+    print("Graph: ", G)
+
+    MSTree = minimum_spanning_tree(G)
+    print("MSTree: ", MSTree)
+
+    # find odd vertexes
+    odd_vertexes = find_odd_vertexes(MSTree)
+    print("Odd vertexes in MSTree: ", odd_vertexes)
+
+    # add minimum weight matching edges to MST
+    minimum_weight_matching(MSTree, G, odd_vertexes)
+    print("Minimum weight matching: ", MSTree)
+
+
+def get_length(x1, y1, x2, y2):
+    return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1 / 2)
+
+
+def build_graph(data):
+    graph = {}
+    for this in range(len(data)):
+        for another_point in range(len(data)):
+            if this != another_point:
+                if this not in graph:
+                    graph[this] = {}
+
+                graph[this][another_point] = get_length(data[this][0], data[this][1], data[another_point][0],
+                                                        data[another_point][1])
+
+    return graph
+
+
+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
+            return object
+
+        # find path of objects leading to the root
+        path = [object]
+        root = self.parents[object]
+        while root != path[-1]:
+            path.append(root)
+            root = self.parents[root]
+
+        # compress the path and return
+        for ancestor in path:
+            self.parents[ancestor] = root
+        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:
+            if r != heaviest:
+                self.weights[heaviest] += self.weights[r]
+                self.parents[r] = heaviest
+
+
+def minimum_spanning_tree(G):
+    tree = []
+    subtrees = UnionFind()
+    for W, u, v in sorted((G[u][v], u, v) for u in G for v in G[u]):
+        if subtrees[u] != subtrees[v]:
+            tree.append((u, v, W))
+            subtrees.union(u, v)
+
+    return tree
+
+
+def find_odd_vertexes(MST):
+    tmp_g = {}
+    vertexes = []
+    for edge in MST:
+        if edge[0] not in tmp_g:
+            tmp_g[edge[0]] = 0
+
+        if edge[1] not in tmp_g:
+            tmp_g[edge[1]] = 0
+
+        tmp_g[edge[0]] += 1
+        tmp_g[edge[1]] += 1
+
+    for vertex in tmp_g:
+        if tmp_g[vertex] % 2 == 1:
+            vertexes.append(vertex)
+
+    return vertexes
+
+
+# utility function that adds minimum weight matching edges to MST
+def minimum_weight_matching(MST, G, 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:
+                length = G[v][u]
+                closest = u
+
+        MST.append((v, closest, length))
+        odd_vert.remove(closest)
+
+
+
+tsp([[1, 1], [2, 5], [8, 0]])