Add solution for challenge #32

Author: Mauricio Klein

Diff for: README.md

@@ -28,6 +28,7 @@
 - [x] [Challenge 26: Course Pre-requisites](challenge-26/)
 - [x] [Challenge 27: Witness of The Tall People](challenge-27/)
 - [x] [Challenge 28: Validate BST](challenge-28/)
- -[x] [Challenge 29: Flood fill](challenge-29/)
- -[x] [Challenge 30: Merge sort](challenge-30/)
+- [x] [Challenge 29: Flood fill](challenge-29/)
+- [x] [Challenge 30: Merge sort](challenge-30/)
 - [x] [Challenge 31: Find cycle in indirected graph](challenge-31/)
+- [x] [Challenge 32: Shortest path in a indirected acyclic graph](challenge-32/)

Diff for: challenge-32/Makefile

@@ -0,0 +1,4 @@
+test:
+	python test_*.py
+
+.PHONY: test

Diff for: challenge-32/README.md

@@ -0,0 +1,25 @@
+# Shortest path in a indirected acyclic graph
+
+## Description
+
+Given a weighted graph, a source node and a target node, find the shortest distance between these two nodes
+
+## Example
+
+```
+Input:
+  a, b, c, d, e = Node('a'), Node('b'), Node('c'), Node('d'), Node('e')
+
+  source, target = a, e
+
+  # First path (distance: 30)
+  a.add_edge(b, 10)
+  b.add_edge(c, 10)
+  c.add_edge(e, 10)
+
+  # Second path (distance: 35)
+  a.add_edge(d, 25)
+  d.add_edge(e, 10)
+
+  Graph([a,b,c,d,e]).shortest_path(a,e) # [a, b, c, e]
+```

Diff for: challenge-32/__init__.py

@@ -0,0 +1,79 @@
+class Node(object):
+  def __init__(self, V):
+    self.V = V
+    self.edges = {}
+
+  def add_edge(self, node, cost):
+    self.edges[node] = cost
+
+class Graph(object):
+  def __init__(self, vertices):
+    self.vertices = {
+      n: {
+        'distance': float('inf'),
+        'previous': None,
+        'visited' : False
+      } for n in vertices
+    }
+
+  def min_distance(self):
+    min_dist = float('inf')
+    node = None
+
+    for v in self.vertices:
+      if not self.is_visited(v) and self.get_distance(v) < min_dist:
+        min_dist = self.get_distance(v)
+        node = v
+
+    return node
+
+  def is_visited(self, node):
+    return self.vertices[node]['visited']
+
+  def mark_as_visited(self, node):
+    self.vertices[node]['visited'] = True
+
+  def get_distance(self, node):
+    return self.vertices[node]['distance']
+
+  def set_distance(self, node, distance):
+    self.vertices[node]['distance'] = distance
+
+  def set_previous(self, node, previous):
+    self.vertices[node]['previous'] = previous
+
+  def get_previous_from(self, node):
+    return self.vertices[node]['previous']
+
+  def dijkstra(self, source):
+    # Initialize source with zero distance
+    self.set_distance(source, 0)
+
+    node = self.min_distance()
+
+    while node:
+      for edge, edge_distance in node.edges.items():
+        if self.is_visited(edge):
+          continue
+
+        # Calculate the distance to the edge and, if shorter,
+        # updates the vertex distance and previous node
+        d = self.get_distance(node) + edge_distance
+        if d < self.get_distance(edge):
+          self.set_distance(edge, d)
+          self.set_previous(edge, node)
+
+      self.mark_as_visited(node)
+      node = self.min_distance()
+
+  def shortest_path(self, source, target):
+    self.dijkstra(source)
+
+    path, node = [], target
+    while node:
+      path.append(node)
+      node = self.get_previous_from(node)
+
+    path.reverse()
+
+    return path

Diff for: challenge-32/solver.py

@@ -0,0 +1,24 @@
+import unittest
+from solver import Graph, Node
+
+class TestSolver(unittest.TestCase):
+  def test_connected_graph(self):
+    a, b, c, d, e = Node('a'), Node('b'), Node('c'), Node('d'), Node('e')
+
+    source, target = a, e
+
+    # First path (distance: 30)
+    a.add_edge(b, 10); b.add_edge(a, 10);
+    b.add_edge(c, 10); c.add_edge(b, 10);
+    c.add_edge(e, 10); e.add_edge(c, 10);
+
+    # Second path (distance: 35)
+    a.add_edge(d, 25); d.add_edge(a, 25);
+    d.add_edge(e, 10); e.add_edge(d, 10);
+
+    g = Graph([a,b,c,d,e])
+
+    self.assertEqual(g.shortest_path(a, e), [a, b, c, e])
+
+if __name__ == "__main__":
+    unittest.main()