Finished graph chapter, on case studies of algo chapter

Author: linkel

6-graphs/EulerianHamiltonian.md

@@ -0,0 +1,17 @@
+### Eulerian and Hamiltonian Paths and Cycles
+
+The lecturer sort of switched back and forth between saying paths and cycles and didn't emphasize vertices vs edges hard enough, which was kind of annoying and confusingly inconsistent. 
+
+Basically, a Eulerian (pronounced Oilerian) path visits every EDGE exactly one time, starting and ending anywhere. A Eulerian cycle visits every EDGE exactly one time, starting and ending at the same node.
+
+A Hamiltonian path visits every NODE (VERTEX) exactly one time, starting and ending anywhere. A Hamiltonian cycle visits every NODE exactly one time, starting and ending at the same node.
+
+### Algo for Eulerian
+
+Possible algo for finding Eulerian paths is:
+
+1. Start at any vertex and follow edges until you return back to that vertex.
+2. If you haven't yet seen every edge, then do an unseen edge connected to the node you already visited. Do the same thing.
+3. Once you have seen every edge, combine the paths at the nodes that they have in common.
+
+O(# of edges)

6-graphs/GraphTraversalQuizAnswers.py

@@ -0,0 +1,47 @@
+class Graph(object):
+
+    def dfs_helper(self, start_node):
+        """The helper function for a recursive implementation
+        of Depth First Search iterating through a node's edges. The
+        output should be a list of numbers corresponding to the
+        values of the traversed nodes.
+        ARGUMENTS: start_node is the starting Node
+        REQUIRES: self._clear_visited() to be called before
+        MODIFIES: the value of the visited property of nodes in self.nodes 
+        RETURN: a list of the traversed node values (integers).
+        """
+        ret_list = [start_node.value]
+        start_node.visited = True
+        edges_out = [e for e in start_node.edges
+                     if e.node_to.value != start_node.value]
+        for edge in edges_out:
+            if not edge.node_to.visited:
+                ret_list.extend(self.dfs_helper(edge.node_to))
+        return ret_list
+
+    def bfs(self, start_node_num):
+        """An iterative implementation of Breadth First Search
+        iterating through a node's edges. The output should be a list of
+        numbers corresponding to the traversed nodes.
+        ARGUMENTS: start_node_num is the node number (integer)
+        MODIFIES: the value of the visited property of nodes in self.nodes
+        RETURN: a list of the node values (integers)."""
+        node = self.find_node(start_node_num)
+        self._clear_visited()
+        ret_list = []
+        # Your code here
+        queue = [node]
+        node.visited = True
+        def enqueue(n, q=queue):
+            n.visited = True
+            q.append(n)
+        def unvisited_outgoing_edge(n, e):
+            return ((e.node_from.value == n.value) and
+                    (not e.node_to.visited))
+        while queue:
+            node = queue.pop(0)
+            ret_list.append(node.value)
+            for e in node.edges:
+                if unvisited_outgoing_edge(node, e):
+                    enqueue(e.node_to)
+        return ret_list

7-case-studies/Dijkstra.md

@@ -0,0 +1,33 @@
+### Shortest Path Problem
+
+The shortest path in an unweighted graph is just the path with the fewest number of edges. This is a breadth first search, and whichever one you find first is the shortest one. 
+
+### Dijkstra's Algorithm
+
+Example is for a weighted graph. 
+
+Greedy algorithm that uses a min priority queue to extract the minimum, queue up paths to other nodes with info on how long they take. Node info gets updated with the lowest path if another lower one is found. 
+
+Adjacency matrix representation of this weighted graph example:
+
+  U D A C I T Y
+U 0 3 4 6 0 0 0
+D 3 0 0 4 0 0 0 
+A 4 0 0 0 7 0 0 
+C 6 4 0 0 4 0 0 
+I 0 4 7 4 0 0 4
+T 0 0 0 0 0 0 5
+Y 0 0 0 0 4 5 0
+
+Dijkstra's algo calculation by step
+
+U D A C I T Y
+0 inf -------->
+x 3 4 6 inf---->
+x x 4 6 inf ---->
+x x x 6 11 inf -->
+x x x x 10 11 inf
+x x x x x 11 14
+x x x x x x 14
+
+