multiple updates

Author: Chris Wu

course-schedule.py

@@ -1,22 +1,22 @@
 """
-we build a graph of adjacency list, like [0]
+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
+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
+0->2->0, which is imposible.
 
-now we iterate every course to see if it can loop back to itself in anyway [1]
+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), bc 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 prerequisites(Edges)
+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):
@@ -35,4 +35,48 @@ def canFinish(self, numCourses, prerequisites):
                 for ajc in graph[course]:
                     if ajc not in visited:
                         stack.append(ajc)
-        return True
+        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.
+
+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`.
+"""
+class Solution(object):
+    def canFinish(self, numCourses, prerequisites):
+        graph = collections.defaultdict(list)
+        inbound = collections.defaultdict(int)
+        q_next = collections.deque()
+        q = collections.deque()
+
+        for n1, n2 in prerequisites: #[1]
+            graph[n1].append(n2)
+            inbound[n2]+=1
+
+        for n in xrange(numCourses): #[2]
+            if inbound[n]==0:
+                q_next.append(n)
+
+        while q_next: #[3]
+            n = q_next.popleft()
+            for nei in graph[n]:
+                inbound[nei]-=1
+                if inbound[nei]==0:
+                    q_next.append(nei)
+            q.append(n)
+        return len(q)==numCourses
+
+

friend-circles.py

@@ -0,0 +1,75 @@
+"""
+For every person #[1]
+We use `dfs()` to traverse all its network and mark all the visited people. #[2]
+So if the someone is visited, this means that he/she is in other people's friend cicle already. #[3]
+So If Bob is never visited, `circles` adds 1 to represent all the people in the new network. #[4]
+
+Time Complexity is O(N^2), we at most travel every node in the 2D array.
+Space Complexity is O(N).
+"""
+class Solution(object):
+    def findCircleNum(self, M):
+        def dfs(i):
+            stack = [i]
+            while stack and len(stack)>0:
+                node = stack.pop()
+                visited.add(node) #[2]
+                for j in xrange(len(M)):
+                    if M[node][j]==1 and j not in visited:
+                        stack.append(j)
+
+        circles = 0
+        visited = set()
+        for i in xrange(len(M)): #[1]
+            if i in visited: continue #[3]
+            dfs(i)
+            circles+=1 #[4]
+
+        return circles
+"""
+We use the `roots` to store every node's root.
+So if at index 1 value is 5, means that node1's root is node5. #[1]
+
+We use `find()` to find a node's root by finding the node's parent and parent's parnet... #[2]
+Along the way, we also update all the node we encounter.
+This technique is also called path compression.
+
+So for every connection, we `union()`, making those two node and all of their parent point to the same root. #[3]
+All the children under the root is in the same friend circle.
+
+At last, we count how many unique root in `roots`. #[4]
+
+When we `find()`, we only update all the node's parents until we reach the root. #[5]
+We did not update the node's child.
+That is why we need to `find()` every node again.
+To make sure all nodes in the `roots` has the right value.
+
+Time Complexity is O(N^2) for `find()` is really close to O(1) in average.
+Space Complexity is O(N)
+"""
+class Solution(object):
+    def findCircleNum(self, M):
+        def find(x):
+            if x != roots[x]:
+                roots[x] = find(roots[x])
+            return roots[x]
+
+        def union(p1, p2): #[2]
+            p1_root = find(p1)
+            p2_root = find(p2)
+            roots[p1_root] = p2_root
+
+        roots = [i for i in xrange(len(M))] #[1]
+
+        for p1 in xrange(len(M)):
+            for p2 in xrange(len(M)):
+                if M[p1][p2] == 1:
+                    union(p1, p2) #[3]
+        
+        roots = [find(i) for i in roots] #[5]
+        return len(set(roots)) #[4]
+
+
+M = [[1,0,0,1],[0,1,1,0],[0,1,1,1],[1,0,1,1]]
+s = Solution()
+s.findCircleNum(M)

redundant-connection.py

@@ -0,0 +1,37 @@
+"""
+We use the `roots` to store the root of each node.
+For example, at index 1 value is 5, means that node1's root is node5.
+
+We use `find()` to find the node's root. In other words, the node's parent's parent's ...
+Every node we encounter along the way, we update their root value in `roots` to the up most root. (This technique is called path compression).
+
+So, for every edge, we unify `u` and `v` them. #[1]
+Which means u and v and all of their parents all lead to one root.
+
+If u's root (`ur`) and v's root (`vr`) are already the same before we unify them.
+This edge is redundant.
+
+This algorithm is called Union Find, often used in undirected graph cycle detect or grouping.
+If you wanted to detect cycles in directed graph, you need to use Topological sort.
+"""
+class Solution(object):
+    def findRedundantConnection(self, edges):
+        def find(x):
+            if x != roots[x]:
+                roots[x] = find(roots[x])
+            return roots[x]
+
+        opt = []
+        roots = range(len(edges))
+
+        for u, v in edges:
+            # union
+            ur = find(u)
+            vr = find(v)
+
+            if ur == vr: #[2]
+                opt = [u, v]
+            else:
+                roots[vr] = ur #[1]
+
+        return opt

remove-duplicates-from-sorted-list.py

@@ -0,0 +1,32 @@
+"""
+The key is to use a set to remember if we seen the node or not.
+Next, think about how we are going to *remove* the duplicate node?
+The answer is to simply link the previous node to the next node.
+So we need to keep a pointer `prev` on the previous node as we iterate the linked list.
+
+So, the solution.
+Create a set `seen`. #[1]
+Point pointer `prev` on the first node. `cuur` on the second.
+Now we iterate trough the linked list.
+    * For every node, we add its value to `seen`. Move `prev` and `curr` forward. #[2]
+    * If we seen the node, we *remove* the `curr` node. Then move the curr forward. #[3]
+Return the `head`
+"""
+class Solution(object):
+    def deleteDuplicates(self, head):
+        if head is None or head.next is None: return head
+
+        prev = head
+        curr = head.next
+        seen = set() #[1]
+
+        seen.add(prev.val)
+        while curr:
+            if curr.val not in seen: #[2]
+                seen.add(curr.val)
+                curr = curr.next
+                prev = prev.next
+            else: #[3]
+                prev.next = curr.next #remove
+                curr = curr.next
+        return head

reverse-linked-list.py

@@ -1,5 +1,6 @@
 #https://leetcode.com/problems/reverse-linked-list/
 class Solution(object):
+    #iterative
     def reverseList(self, head):
         prev = None
         current = head
@@ -8,6 +9,16 @@ def reverseList(self, head):
             current.next = prev
             prev = current
             current = temp
-            
+
         return prev
 
+    #recursive
+    def reverseList(self, head):
+        if head is None or head.next is None:
+            return head
+
+        new_head = self.reverseList(head.next)
+        n = head.next
+        n.next = head
+        head.next = None
+        return new_head