Round 1: Maniac Moving - partial 3

2017.1-RoundOne/c.ManiacMoving.py

@@ -1,26 +1,53 @@
 import numpy as np
 
-def shortest(i, j, ABG):
+def directDist(i, j, ABG):
+    dist = -1
+    for A, B, G in ABG:
+        if ((A == i and B == j) or (A == j and B == i)) and (dist == -1 or G < dist):
+            dist = G
+    return dist
+
+# From http://stackoverflow.com/a/22899400
+def shortest(i, j, ABG, nodes):
+    # print("i={0}, j={1}, ABG={2}, nodes={3}".format(i, j, ABG, nodes))
+    distances = {}
+    for A, B, G in ABG:
+        # print(distances)
+        if A not in distances or B not in distances:
+            distances[A] = {B: G}
+            distances[B] = {A: G}
+            continue
+        if B not in distances[A]:
+            distances[A][B] = G
+            distances[B][A] = G
+            continue
+        if G < distances[A][B]:
+            distances[A][B] = G
+            distances[B][A] = G
+
+    unvisited = {node: None for node in nodes} #using None as +inf
     visited = {}
-    level = 0
+    current = i
+    currentDistance = 0
+    unvisited[current] = currentDistance
+
     while True:
-        L[level] = {}
-        for A, B, G in ABG:
-            if A != i and B != i:
-                continue
-            if A == i:
-                x = B
-            else:
-                x = A
-            if x not in L[level] or L[level][x] > G:
-                L[level][x] = G
-    direct = -1
-    if j in minis:
-        direct = minis[j]
-    for x, dist in enumerate(minis):
-        if direct > dist:
-            distToJ = shortest(x, j, ABG)
-        if distToJ < ...
+        for neighbour, distance in distances[current].items():
+            if neighbour not in unvisited: continue
+            newDistance = currentDistance + distance
+            if unvisited[neighbour] is None or unvisited[neighbour] > newDistance:
+                unvisited[neighbour] = newDistance
+        visited[current] = currentDistance
+        if current == j:
+            return visited
+        del unvisited[current]
+        if not unvisited: break
+        candidates = [node for node in unvisited.items() if node[1]]
+        # print("unvisited", unvisited)
+        # print("candidates", candidates)
+        current, currentDistance = sorted(candidates, key = lambda x: x[1])[0]
+
+    return visited
 
 def routes(ABG, SD):
     r = {}
@@ -35,16 +62,20 @@ def routes(ABG, SD):
         # print("A={0}, B={1}, G={2}".format(A, B, G))
         townsInABG.add(A)
         townsInABG.add(B)
-    print(townsInSD)
-    print(townsInABG)
+    # print(townsInSD)
+    # print(townsInABG)
     if len(townsInABG) < len(townsInSD):
         return {}
     allTowns = townsInSD | townsInABG
+
+    # print("Shortest:", shortest(1, 2, ABG, allTowns))
     for i in townsInSD:
         for j in townsInSD:
             if (i,j) in r:
                 continue
-            dist = shortest(i, j, ABG)
+            shortst = shortest(i, j, ABG, allTowns)
+            print("Shortest:", shortst)
+            dist = shortst[j]
             r[(i,j)] = dist
             r[(j,i)] = dist
     return r
@@ -54,6 +85,7 @@ def solve(N, M, K, ABG, SD):
     if K <= 0:
         return 0
     r = routes(ABG, SD)
+    print(r)
     if r == {}:
         return -1
     return 'gnagna'