Adding Weighted Path CoderByte solution

Author: rlishtaba

README.md

@@ -464,7 +464,7 @@ Solutions to various challenges published at www.hackerrank.com
 
 * Binary Search Tree LCA
 * Shortest Path in Unweighted Graph with cycles
-
+* Weighted Path
 
 ## Contributing
 

py_algorithms/challenges/coderbyte/weighted_path.py

@@ -0,0 +1,76 @@
+from typing import List
+from typing import Tuple
+from typing import Union
+
+
+class WeightedPath:
+    INF = float('infinity')
+
+    @staticmethod
+    def make_lists(vertices: List[str],
+                   triplets: List[Tuple[str, str, int]]) -> Tuple[dict, dict]:
+        adj = {}
+        edges = {}
+        for v in vertices:
+            adj[v] = {}
+            edges[v] = {}
+            for w in vertices:
+                adj[v][w] = WeightedPath.INF
+                edges[v][w] = {}
+        for t in triplets:
+            adj[t[0]][t[1]] = int(t[2])
+            adj[t[1]][t[0]] = int(t[2])
+            # graph will have cycles.
+            edges[t[0]][t[1]] = [t[0], t[1], int(t[2])]
+            edges[t[1]][t[0]] = [t[1], t[0], int(t[2])]
+        return adj, edges
+
+    @classmethod
+    def path(cls, s: str, t: str, edge_to: dict,
+             distances: dict) -> List[str]:
+        if not (distances[s][t] < cls.INF):
+            return []
+        paths = []
+        e = edge_to[s][t]
+        while e:
+            paths.append(e)
+            # graph is cyclic, should stop on cycle
+            if e[0] == s:
+                break
+            e = edge_to[s][e[0]]
+        return paths
+
+    @classmethod
+    def fw_traverse(cls, vertices: List[str],
+                    triplets: List[Tuple[str, str, int]]) -> Tuple[dict, dict]:
+        """
+        Floyd-Warshall traversal. Can handle negative weights,
+        Dijkstra's algorithm works only with positive weights.
+        """
+        distances, edge_to = cls.make_lists(vertices, triplets)
+        nodes = distances.keys()
+        for i in nodes:
+            for v in nodes:
+                if not edge_to[v][i]:
+                    continue
+                for w in nodes:
+                    if distances[v][w] > distances[v][i] + distances[i][w]:
+                        distances[v][w] = distances[v][i] + distances[i][w]
+                        edge_to[v][w] = edge_to[i][w]
+        return edge_to, distances
+
+    def __call__(self, str_arr: List[str]) -> Union[str, int]:
+        node_len = int(str_arr[0])
+        vertices = str_arr[1:node_len + 1]
+        triplets = [x.split('|') for x in str_arr[node_len + 1:]]
+        edges, distances = self.fw_traverse(vertices, triplets)
+        # compute shortest paths using Floyd - Warshall algorithm.
+        sp = self.path(vertices[0], vertices[node_len - 1], edges, distances)
+        # if list is empty - no path
+        if len(sp) == 0:
+            return -1
+        else:
+            xs = [vertices[node_len - 1]]
+            xs += [x[0] for x in sp]
+            xs.reverse()
+            return "-".join(xs)

tests/py_algorithms/challenges/coderbyte/weighted_path_test.py

@@ -0,0 +1,32 @@
+from py_algorithms.challenges.coderbyte.weighted_path import WeightedPath
+
+
+class TestWeightedPath:
+    def test_impl(self):
+        inputs = {
+            "A-B-C-D-F-G": ["7", "A", "B", "C", "D", "E", "F", "G",
+                            "A|B|1", "A|E|9", "B|C|2", "C|D|1", "D|F|2",
+                            "E|D|6", "F|G|2"],
+            "A-B-C-D": ["4", "A", "B", "C", "D", "A|B|1", "B|D|9", "B|C|3",
+                        "C|D|4"],
+            -1: ["4", "x", "y", "z", "w", "x|y|2", "y|z|14", "z|y|31"],
+            "A-B-D": ["4", "A", "B", "C", "D", "A|B|2", "C|B|11", "C|D|3",
+                      "B|D|2"],
+            "A-B-D-E-F": ["6", "A", "B", "C", "D", "E", "F", "B|A|2",
+                          "A|F|12", "A|C|4", "B|D|1", "D|E|1", "C|D|4",
+                          "F|E|1"],
+            "D-B-A-F": ["6", "D", "B", "C", "A", "E", "F", "B|A|2",
+                        "A|F|3", "A|C|4", "B|D|1", "D|E|12", "C|D|4",
+                        "F|E|1"],
+            "C-D-F-G-E-B-H": ["8", "C", "B", "A", "D", "E", "F", "G",
+                              "H", "C|D|1", "D|F|2", "G|F|2", "G|E|1", "E|B|1",
+                              "H|B|1", "C|A|13", "B|A|2", "C|E|9"],
+            "GG-HH-JJ": ["3", "GG", "HH", "JJ", "GG|JJ|6", "GG|HH|2", "JJ|HH|2"],
+            "C-E-B-H": ["8", "C", "B", "A", "D", "E", "F", "G", "H", "C|D|1",
+                        "D|F|2", "G|F|2", "G|E|1", "E|B|1", "H|B|1",
+                        "C|A|13", "B|A|2", "C|E|1"]
+        }
+
+        f = WeightedPath()
+        for key in inputs:
+            assert f(inputs[key]) == key