no message

Author: Chris Wu

problems/course-schedule-ii.py

@@ -0,0 +1,50 @@
+from collections import defaultdict, deque
+
+class Solution(object):
+    def findOrder(self, numCourses, prerequisites):
+        graph = defaultdict(list)
+        inbound = defaultdict(int)
+        q = deque()
+        order = deque()
+        
+		#building graph as adjacency list
+        for c1, c2 in prerequisites:
+            graph[c2].append(c1)
+            inbound[c1] += 1
+        
+		#find the starting point
+        for c in xrange(numCourses):
+            if inbound[c]==0:
+                q.append(c)
+        
+		#traverse the directed graph
+        while q:
+            c = q.popleft()
+            
+            for nei in graph[c]:
+                inbound[nei] -= 1
+                if inbound[nei]==0:
+                    q.append(nei)
+                    
+            order.append(c)
+        
+        return order if len(order)==numCourses else []
+
+"""
+Topological sort works only in directed graph.
+We can use it to know which node comes after which or detect cycles.
+The algorithm is easy to understand.
+First, we build the adjacent list (`graph`) and count all the inbound of the node.
+Then we start from the node whose inbound count is 0, adding it in to the `q`.
+For every node we pop out from `q`
+    * We remove the node's outbound by decrease 1 on all its neighbor's inbound.
+    * Put the node's neighbor to `q` if it has no inbound
+    * Put the node into the `order`
+Repeat the process until there is no more node.
+The order in the `order` is the order we are going to encounter when we run through the directed graph.
+If we cannot sort all the nodes in the graph, it means that there are some nodes we couldn't find its starting point, in other words, there are cycles in the graph.
+
+Time: O(E+2V) ~= O(E+V)
+we used O(E) to build the graph #[1], O(V) to find the starting point #[2], then traverse all the nodes again #[3].
+Space: O(E+3V) ~= O(E+V), O(E+V) for the adjacent list. O(V) for the `q`, O(V) for the `q_next`.
+"""

problems/course-schedule.py

@@ -1,23 +1,3 @@
-"""
-First, we build a graph of adjacency list #[0]
-0->[2,4,5]
-1->[3,4]
-Meaning before taking 2,4,5 we need to take 0, before taking 3,4 we need to take 1
-if we find a loop back to itself then it is impossible, for example
-0->[2,4,5]
-1->[3,4]
-2->[0,3]
-0->2->0, which is imposible.
-
-Now we iterate every course to see if it can loop back to itself in anyway #[1]
-we do this by dfs and search for it self
-if we find itself we find loop
-
-The time efficiency is O(V^2+VE), because each dfs in adjacency list is O(V+E) and we do it V times
-Space efficiency is O(E).
-V is the numCourses (Vertices).
-E is the number of prerequisites (Edges).
-"""
 class Solution(object):
     def canFinish(self, numCourses, prerequisites):
         graph = {n:[] for n in xrange(numCourses)} #[0]
@@ -36,25 +16,27 @@ def canFinish(self, numCourses, prerequisites):
                     if ajc not in visited:
                         stack.append(ajc)
         return True
-
 """
-Topological sort works only in directed graph.
-We can use it to know which node comes after which or detect cycles.
-The algorithm is easy to understand.
-First, we build the adjacent list and count all the inbound of the node.
-Then we start from the node whose inbound count is 0, adding it in to the `q_next`.
-For every node we pop out from q_next
-    * We remove the node's outbound by decrease 1 on all its neighbor's inbound.
-    * Put the node's neighbor to `q_next` if it has no inbound
-    * Put the node into the `q`
-Repeat the process until there is no more node.
-The order in the `q` is the order we are going to encounter when we run through the directed graph.
-If we cannot sort all the nodes in the graph, it means that there are some nodes we couldn't find its starting point, in other words, there are cycles in the graph.
+First, we build a graph of adjacency list #[0]
+0->[2,4,5]
+1->[3,4]
+Meaning before taking 2,4,5 we need to take 0, before taking 3,4 we need to take 1
+if we find a loop back to itself then it is impossible, for example
+0->[2,4,5]
+1->[3,4]
+2->[0,3]
+0->2->0, which is imposible.
 
-Time: O(E+2V) ~= O(E+V)
-we used O(E) to build the graph #[1], O(V) to find the starting point #[2], then traverse all the nodes again #[3].
-Space: O(E+3V) ~= O(E+V), O(E+V) for the adjacent list. O(V) for the `q`, O(V) for the `q_next`.
+Now we iterate every course to see if it can loop back to itself in anyway #[1]
+we do this by dfs and search for it self
+if we find itself we find loop
+
+The time efficiency is O(V^2+VE), because each dfs in adjacency list is O(V+E) and we do it V times
+Space efficiency is O(E).
+V is the numCourses (Vertices).
+E is the number of prerequisites (Edges).
 """
+
 class Solution(object):
     def canFinish(self, numCourses, prerequisites):
         graph = collections.defaultdict(list)
@@ -78,5 +60,22 @@ def canFinish(self, numCourses, prerequisites):
                     q_next.append(nei)
             q.append(n)
         return len(q)==numCourses
+        
+"""
+Topological sort works only in directed graph.
+We can use it to know which node comes after which or detect cycles.
+The algorithm is easy to understand.
+First, we build the adjacent list and count all the inbound of the node.
+Then we start from the node whose inbound count is 0, adding it in to the `q_next`.
+For every node we pop out from q_next
+    * We remove the node's outbound by decrease 1 on all its neighbor's inbound.
+    * Put the node's neighbor to `q_next` if it has no inbound
+    * Put the node into the `q`
+Repeat the process until there is no more node.
+The order in the `q` is the order we are going to encounter when we run through the directed graph.
+If we cannot sort all the nodes in the graph, it means that there are some nodes we couldn't find its starting point, in other words, there are cycles in the graph.
 
-
+Time: O(E+2V) ~= O(E+V)
+we used O(E) to build the graph #[1], O(V) to find the starting point #[2], then traverse all the nodes again #[3].
+Space: O(E+3V) ~= O(E+V), O(E+V) for the adjacent list. O(V) for the `q`, O(V) for the `q_next`.
+"""

problems/find-mode-in-binary-search-tree.py

@@ -66,7 +66,7 @@ def findMode(self, root):
 With the help of `prev_val` we can know that `curr_node` is the same to the previous or not.
 If not, its a new element, we need to reset the `curr_count`.
 
-Time: O(N). Space: O(1)
+Time: O(N). Space: O(LogN)
 
 For better understanding, below is a template for inorder traverse.
 """