no message

Author: wuduhren

problems/populating-next-right-pointers-in-each-node-ii.py

@@ -0,0 +1,50 @@
+"""
+Time: O(N)
+Space: O(1)
+
+View each level as a link list.
+Traverse the tree level by level. For each level:
+Starting from the leftmost (the head of the link list), we establish the next pointer of the children.
+
+curr.left.next = curr.right or (curr.next.left or curr.next.right) or (curr.next.next.left or curr.next.next.right) or (...)
+curr.right.next = (curr.next.left or curr.next.right) or (curr.next.next.left or curr.next.next.right) or (...)
+"""
+class Solution(object):
+    def connect(self, root):
+        if not root: return root
+        
+        leftmost = root
+        
+        while leftmost:
+            curr = leftmost
+            
+            while curr:
+                if curr.left:
+                    if curr.right:
+                        curr.left.next = curr.right
+                    else:
+                        n = curr.next
+                        while n:
+                            curr.left.next = n.left or n.right
+                            if curr.left.next: break
+                            n = n.next
+                
+                if curr.right:
+                    n = curr.next
+                    while n:
+                        curr.right.next = n.left or n.right
+                        if curr.right.next: break
+                        n = n.next
+                
+                curr = curr.next
+            
+            nextLevelLeftmost = None
+            n = leftmost
+            while n:
+                if n.left or n.right:
+                    nextLevelLeftmost = n.left or n.right
+                    break
+                n = n.next
+            leftmost = nextLevelLeftmost
+            
+        return root

problems/populating-next-right-pointers-in-each-node.py

@@ -0,0 +1,56 @@
+"""
+Time: O(N)
+Space: O(N)
+
+Traverse the tree level by level.
+For each level connect the node to the "next node".
+"""
+class Solution(object):
+    def connect(self, root):
+        if not root: return root
+        level = collections.deque([root])
+        nextLevel = collections.deque()
+        
+        while level:
+            node = level.popleft()
+            
+            if node.left: nextLevel.append(node.left)
+            if node.right: nextLevel.append(node.right)
+            
+            if not level:
+                if not nextLevel: break
+                for i, c in enumerate(nextLevel):
+                    if i==len(nextLevel)-1: continue #skip last
+                    c.next = nextLevel[i+1]
+                level = nextLevel
+                nextLevel = collections.deque()
+                
+        return root
+
+
+"""
+Time: O(N)
+Space: O(1)
+
+View each level as a link list.
+Traverse the tree level by level. For each level:
+Starting from the leftmost (the head of the link list), we establish the next pointer of the children.
+curr.left.next = curr.right
+curr.right.next = curr.next.left
+"""
+class Solution(object):
+    def connect(self, root):
+        if not root: return root
+        
+        leftmost = root
+        while leftmost:
+            
+            curr = leftmost
+            while curr:
+                if curr.left: curr.left.next = curr.right
+                if curr.right and curr.next: curr.right.next = curr.next.left
+                curr = curr.next
+                
+            leftmost = leftmost.left
+        
+        return root

problems/unique-binary-search-trees.py

@@ -11,4 +11,36 @@ def numTrees(self, n):
             for root in xrange(1, i+1):
                 dp[i] += dp[root-1]*dp[i-root]
 
-        return dp[n]
+        return dp[n]
+
+"""
+dp[n] := the number of structurally unique BST's which has n nodes with val 1~n
+dp[n] = helper(n)
+
+Form 1~n nodes
+If we use 1 as root, the left subtree possible count will be dp[1-1] and right subtree be dp[n-1], the count will be dp[0]*dp[n-1].
+If we use 2 as root, the left subtree possible count will be dp[2-1] and right subtree be dp[n-2], the count will be dp[1]*dp[n-2].
+If we use 3 as root, the left subtree possible count will be dp[3-1] and right subtree be dp[n-3], the count will be dp[2]*dp[n-3].
+...
+If we use i as root, the left subtree possible count will be dp[i-1] and right subtree be dp[n-i], the count will be dp[i-1]*dp[n-i].
+
+So the number of structurally unique BST's which has n nodes with val 1~n, will be the sum above.
+
+Time: O(N^2)
+Space: O(N)
+"""
+class Solution(object):
+    def numTrees(self, N):
+        def helper(n):
+            count = 0
+            for i in xrange(1, n+1):
+                count += dp[i-1]*dp[n-i]
+            return count
+                
+        dp = [0]*(N+1)
+        dp[0] = 1
+        dp[1] = 1
+        
+        for n in xrange(2, N+1):
+            dp[n] = helper(n)
+        return dp[N]