Added

Author: shichao-an

product_of_array_except_self/solution2.py

@@ -27,8 +27,7 @@ def productExceptSelf(self, nums):
         for i in range(1, n):
             for j in range(i):
                 res[j] *= nums[i]
-            if i > 0:
-                product *= nums[i - 1]
+            product *= nums[i - 1]
             res[i] = product
         return res
 

product_of_array_except_self/solution4.py

@@ -23,6 +23,8 @@ def productExceptSelf(self, nums):
         res = [1 for i in range(n)]
         # Scan from left to right
         for i in range(1, n):
+            # i is from 1 to n - 1
+            # res[i] is the product accumulated to the left
             res[i] = res[i - 1] * nums[i - 1]
 
         # right_product is the product accumulated to the right

search_insert_position/solution2.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+"""
+Given a sorted array and a target value, return the index if the target is
+found. If not, return the index where it would be if it were inserted in
+order.
+
+You may assume no duplicates in the array.
+
+Here are few examples.
+[1,3,5,6], 5 → 2
+[1,3,5,6], 2 → 1
+[1,3,5,6], 7 → 4
+[1,3,5,6], 0 → 0
+
+"""
+
+class Solution(object):
+    def searchInsert(self, nums, target):
+        n = len(nums)
+        left = 0
+        right = n - 1
+        while left + 1 < right:
+            mid = left + (right - left) / 2
+            if mid > 0 and nums[mid - 1] < target < nums[mid]:
+                return mid
+            elif target <= nums[mid]:
+                right = mid
+            else:
+                left = mid
+        if nums[left] < target < nums[right]:
+            return left + 1
+        elif nums[left] == target:
+            return left
+        elif nums[right] == target:
+            return right
+        elif nums[left] > target:
+            return min(0, left)
+        elif nums[right] < target:
+            return max(n, right)
+
+
+a1 = [1, 3]
+s = Solution()
+print s.searchInsert(a1, 2)

unique_binary_search_trees/solution.py

@@ -0,0 +1,35 @@
+"""
+Given n, how many structurally unique BST's (binary search trees) that store
+values 1...n?
+
+For example,
+Given n = 3, there are a total of 5 unique BST's.
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+"""
+
+class Solution(object):
+    def numTrees(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        t = [-1 for _ in range(n + 1)]
+        return self.num_trees_aux(n, t)
+
+    def num_trees_aux(self, n, t):
+        if n == 0 or n == 1:
+            return 1
+        elif t[n] != -1:
+            return t[n]
+        else:
+            res = 0
+            for i in range(n):
+                res += self.num_trees_aux(i, t) * \
+                    self.num_trees_aux(n - 1 - i, t)
+            t[n] = res
+            return res

unique_binary_search_trees/solution2.py

@@ -0,0 +1,28 @@
+"""
+Given n, how many structurally unique BST's (binary search trees) that store
+values 1...n?
+
+For example,
+Given n = 3, there are a total of 5 unique BST's.
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+"""
+
+class Solution(object):
+    def numTrees(self, n):
+        t = [-1 for _ in range(n + 1)]
+        t[0] = 1
+        t[1] = 1
+        if n <= 1:
+            return t[n]
+        else:
+            for i in range(2, n + 1):
+                res = 0
+                for j in range(i):
+                    res += t[j] * t[i - 1 - j]
+                t[i] = res
+        return t[n]