Updated DFS questions. Added tree helper

Author: Yan Cao

Interviews/BFS_DFS.py

@@ -8,11 +8,7 @@
   * Postorder(Recursive, Iterative)
 """
 
-class TreeNode:
-    def __init__(self, x):
-        self.val = x
-        self.left = None
-        self.right = None
+from Tree_Helper.tree_helper import *
 
 def BFS_level_order_traversal(root):
     if not root:
@@ -144,23 +140,6 @@ def DFS_postorder(root):
     return result
 
 
-def create_bst_from_array(A, start=None, end=None):
-    if start is None and end is None:
-        start = 0
-        end = len(A) - 1
-
-    if start > end:
-        return None
-
-    mid = (start + end) / 2
-    root = TreeNode(A[mid])
-
-    root.left = create_bst_from_array(A, start, mid - 1)
-    root.right = create_bst_from_array(A, mid + 1, end)
-
-    return root
-
-
 A = [ i for i in range(10) ]
 new_tree = create_bst_from_array(A)
 """
@@ -248,15 +227,5 @@ def preorder_doubly_flatten(root):
 
 print BFS_level_order_traversal(new_tree)
 
-def print_tree(head):
-    while head:
-        print head.val,
-        if head.left:
-            print 'left', head.left.val,
-        if head.right:
-            print 'right', head.right.val,
-        print ''
-        head = head.right
-
-print_tree(head)
+print_tree_as_list(head)
 """

Interviews/Binary_Tree_Level_K_Nodes.py

@@ -0,0 +1,26 @@
+"""
+#####From [blog](http://blog.csdn.net/luckyxiaoqiang/article/details/7518888#topic6)
+
+Not sure if this is usefull but the code seems pretty important
+"""
+
+def get_kth_level_nodes(root, k):
+    if not root:
+        return 0
+    if k == 1:
+        return k
+
+    left_count = get_kth_level_nodes(root.left, k-1)
+    right_count = get_kth_level_nodes(root.right, k-1)
+
+    return left_count + right_count
+
+"""
+from Tree_Helper.tree_helper import *
+A = [ i for i in range(20)]
+root = create_bst_from_array(A)
+
+DFS_level_order_traversal(root)
+
+print get_kth_level_nodes(root, 5)
+"""

Interviews/BlockingQueue.py renamed to Interviews/Blocking_Queue.py

@@ -0,0 +1,29 @@
+"""
+#####From [Geeksforgeeks](http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/)
+
+Similar to CC150, just allow coin with 1, 3, 5 right now
+
+Several ways to ask
+1. How many ways?
+2. What are the ways?
+3. Minimum coin number?
+"""
+
+# This is same to Combination Sum I
+def coin_change(value):
+    res = [0, 0, 0]                     # [num_5, num_3, num_1]
+    ret = []
+    coin_change_helper(value, res, ret, 0)
+    return ret
+
+def coin_change_helper(value, res, ret, cur_face_value):
+    if value == 0:
+        ret.append(res[:])
+    if value <= 0:
+        return
+    for i in range(cur_face_value, 3):
+        res[i] += 1
+        coin_change_helper(value - [5, 3, 1][i], res, ret, i)
+        res[i] -= 1
+
+print coin_change(5)

Interviews/Coin_Change.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+def DFS_level_order_traversal(root):
+    ret = {}
+    DFS_helper(ret, 1, root)
+    for level in sorted(ret.keys()):
+        print ret[level]
+
+def DFS_helper(ret, level, root):
+    if not root:
+        return
+
+    ret.setdefault(level, []).append(root.val)
+    DFS_helper(ret, level + 1, root.left)
+    DFS_helper(ret, level + 1, root.right)
+
+def create_bst_from_array(A, start=None, end=None):
+    if start is None and end is None:
+        start = 0
+        end = len(A) - 1
+
+    if start > end:
+        return None
+
+    mid = (start + end) / 2
+    root = TreeNode(A[mid])
+
+    root.left = create_bst_from_array(A, start, mid - 1)
+    root.right = create_bst_from_array(A, mid + 1, end)
+
+    return root
+
+def print_tree_as_list(head):
+    while head:
+        print head.val,
+        if head.left:
+            print 'left', head.left.val,
+        if head.right:
+            print 'right', head.right.val,
+        print ''
+        head = head.right

Interviews/Tree_Helper/__init__.py

@@ -27,9 +27,10 @@ def combinationSum_helper(self, candidates, target, res, ret):
             ret.append(res[:])
             return
         for i, num in enumerate(candidates):
-            if target >= num:
-                res.append(num)
-                self.combinationSum_helper(candidates[i:], target - num, res, ret)
-                res.pop()
+            if target - num < 0:
+                continue
+            res.append(num)
+            self.combinationSum_helper(candidates[i:], target - num, res, ret)
+            res.pop()
 
-    # Improvements: only continue when target > num ,else stop
+    # Continue when target < num

Interviews/Tree_Helper/tree_helper.py

@@ -29,7 +29,7 @@ def combinationSum_helper(self, candidates, target, res, ret):
             ret.append(res[:])
             return
         for i, num in enumerate(candidates):
-            if target < num or (i > 0 and num == candidates[i-1]):
+            if target < num or (i > 0 and candidates[i] == candidates[i-1]):
                 continue
             res.append(num)
             self.combinationSum_helper(candidates[i+1:], target - num, res, ret)

Leetcode/Combination_Sum.py

@@ -14,17 +14,17 @@ def permute(self, num):
 
     def permute_1(self, num):
         ret = []
-        self.permute_helper([], num, ret)
+        self.permute_helper(num, [], ret)
         return ret
 
-    def permute_helper(self, res, num, ret):
+    def permute_helper(self, num, res, ret):
         if len(num) == 0:
             ret.append(res[:])
             return
 
         for i, n in enumerate(num):
             res.append(n)
-            self.permute_helper(res, num[:i] + num[i+1:], ret)
+            self.permute_helper(num[:i] + num[i+1:], res, ret)
             res.pop()
 
     # Do this "inplace"

Leetcode/Combination_Sum_II.py

@@ -22,7 +22,7 @@ def permuteUnique_helper(self, num, res, ret):
             ret.append(res[:])
             return
         for i, n in enumerate(num):
-            if i > 0 and n == num[i-1]:
+            if i > 0 and num[i] == num[i-1]:
                 continue
             res.append(n)
             self.permuteUnique_helper(num[:i] + num[i+1:], res, ret)

Leetcode/Permutations.py

@@ -23,7 +23,22 @@ class Solution:
     # @param S, a list of integer
     # @return a list of lists of integer
     def subsets(self, S):
-        return self.subsets_1(S)
+        return self.subsets_2(S)
+
+    # Recursion method
+    def subsets_2(self, S):
+        ret = []
+        self.subsets_helper(sorted(S), [], ret)
+        return ret
+
+    def subsets_helper(self, S, res, ret):
+        ret.append(res[:])
+
+        for i, el in enumerate(S):
+            res.append(el)
+            self.subsets_helper(S[i+1:], res, ret)
+            res.pop()
+    # Keep in mind the sorted
 
     # Iteration method
     def subsets_1(self, S):
@@ -36,20 +51,3 @@ def subsets_1(self, S):
                 res.append(el[:])
             ret = res[:]
         return ret
-
-    # Recursion method
-    def subsets_2(self, S):
-        ret = []
-        self.subsets_helper(0, sorted(S), [], ret)
-        return ret
-
-    def subsets_helper(self, i, S, res, ret):
-        if i == len(S):
-            ret.append(res[:])
-            return
-        self.subsets_helper(i+1, S, res, ret) # No element i
-        res.append(S[i])
-        self.subsets_helper(i+1, S, res, ret) # With element i
-        res.pop()
-
-    # Keep in mind the sorted

Leetcode/Permutations_II.py

@@ -39,15 +39,15 @@ def subsetsWithDup_1(self, S):
     # Recursion way
     def subsetsWithDup_2(self, S):
         ret = []
-        self.subsetsWithDup_rec(0, sorted(S), [], ret)
+        self.subsetsWithDup_rec(sorted(S), [], ret)
         return ret
 
-    def subsetsWithDup_rec(self, i, S, res, ret):
-        if i == len(S):
-            ret.append(res[:])
-            return
-        if len(res)==0 or S[i] != res[-1]: # This is tricky, but I should be careful, it's checking against
-            self.subsetsWithDup_rec(i+1, S, res, ret) # last res char, but not S[i-1]
-        res.append(S[i])
-        self.subsetsWithDup_rec(i+1, S, res, ret)
-        res.pop()
+    def subsetsWithDup_rec(self, S, res, ret):
+        ret.append(res[:])
+
+        for i, el in enumerate(S):
+            if i > 0 and S[i] == S[i-1]:
+                continue
+            res.append(el)
+            subsetsWithDup_rec(S[i+1:], res, ret)
+            res.pop()

Leetcode/Subsets.py

@@ -12,7 +12,7 @@
 * [x] Combination Sum
 * [x] Combination Sum II
 * [x] Letter Combination of a Phone Number
-* [ ] 找零钱
+* [x] 找零钱 == Combination Sum I
 
 -----
 
@@ -21,19 +21,32 @@
 
 -----
 
-######Note:
-做Permutation, Combination和Subset的感觉非常像，注意
-
-1. 结束条件都是用完所有可用的char, 也就是i == len(n). 然后在ret.append(res[:]), 这里千万别忘了要return cancel函数
-2. 做for循环的时recursion函数的输入会有差别(记得这里用enumerate会方便好多)
-  1. Permutation传入剩余num_list 是 num[:i] + num[i+1], 因为只是除去当前数字, permute剩余
-  2. Combination传入剩余num_list 是 num[i+1:],  因为除去比当前数字之前的数, combine剩余
-  3. Subsets其实也应该是S[i+1:],除去之前可能的set. 但是与前两者不同的是循环的内容不同， Subset只有存在和不存在两种情况，所以等于是loop一个恒为2的循环，而第一种情况还有特殊条件，这个一定要仔细看好。
-  4. Permutation&Combination两者相同的地方都是
-    1. res.append(n)
-    2. do combine_rec/permute_rec
-    3. res.pop()
-3. 仔细观察这三道题就会发现, 其实I都是输入没有重复, 而II都是输入有重复,但输出不能有重复的题目.
+#####总结
+Permutations II,
+Combinations,
+Combinations Sum II
+和Subset II都是DFS， 区别在于
+1. 将```res```放入```ret```的条件不一样  
+   * Permu - ```len(res) = len(S)```
+   * Combin - ```len(res) == k```
+   * Combin Sum - ```target == 0```
+   * Subsets - 只要生成新的res就要存一次  
+   前三种题存过结果只后程序应该return
+2. 循环内call recursion时的输入变量不一样  
+   * Permu - ```permu_helper(num[:i] + num[i+i:], res, ret)```(除了S[i])
+   * Combin - ```comb_helper(i+1, n, k, res, ret)```(S[i+1:])
+   * Combin Sum - ```comb_sum_helper(num[i:], target - n, res, ret)```(S[i:])
+   * Subsets - ```sub_helper(S[i+1:], res, ret)```(S[i+1:])  
+   S[i+1:]决定了res内是不会有重复项的(除非S本身就有重复), S[i:]让当前元素可以重复使用
+* II类去重题相比较I类题唯一的差别就是在循环的第一行需要check```if i > 0 and S[i] == S[i-1]: continue```
+* 注意II类题都需要先```sort```, 因为去重是判断前项相等否
+* 普通题目看情况如果要求输入时```res```内的元素有序那也需要```sort```
+* Comb Sum题有一点点特殊在于在循环内需要判断```target - num < 0: continue```
+* Comb Sum II和I比题目有点点变化在于，数字不能无限重取，只能有限重取,  
+  所以是```comb_sum_II_helper(num[i+1:], target - n, res, ret)```
+* 记得尽量用```enumerate```
+
+复杂度O(n)??
 
 -----
 

Leetcode/Subsets_II.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python
 
-file_name = 'Count_and_Say'
-func_name = 'countAndSay'
+file_name = 'Subsets'
+func_name = 'subsets'
 
 import importlib
 module = importlib.import_module('Leetcode.%s' % file_name)
 instance = module.Solution()
 
-print getattr(instance, func_name)(6)
+print getattr(instance, func_name)([1,2,3])