no message

Author: Chris Wu

problems/combination-sum-ii.py

@@ -0,0 +1,38 @@
+"""
+If you haven't see the [first problem](https://leetcode.com/problems/combination-sum/) and [explanation](https://leetcode.com/problems/combination-sum/discuss/386093/) already, I suggest you check it out first.
+
+This Problem is similar to the [first one](https://leetcode.com/problems/combination-sum/).
+Except that we can only select each element in the `candidates` once.
+In the first problem, we can choose the same element in the `candidates` for many times as we like.
+In this problem, we can't.
+So we need to
+```
+helper(combination+[num], i+1, target_remain-num)
+```
+Instead of
+```
+helper(combination+[num], i, target_remain-num)
+```
+
+Another problem is duplicates. For example,
+```
+candidates = [10,1,2,7,6,1,5]
+target = 8
+```
+We might end up choosing the fist 1 or second 1 and make the same combination `[1, 2, 5]`
+So I use a hash set to prevent duplicate.
+"""
+class Solution(object):
+    def combinationSum2(self, candidates, target):
+        def helper(combination, start, target_remain):
+            if target_remain==0:
+                answer.add(tuple(combination))
+            for i in xrange(start, len(candidates)):
+                num = candidates[i]
+                if num>target_remain: break
+                helper(combination+[num], i+1, target_remain-num)
+
+        answer = set()
+        candidates.sort()
+        helper([], 0, target)
+        return [list(combination) for combination in answer]

problems/combination-sum.py

@@ -42,7 +42,6 @@
         .
 
     helper([7], 3, 0) --> bingo
-
 ```
 """
 class Solution(object):
@@ -51,9 +50,9 @@ def helper(combination, start, target_remain):
             if target_remain==0:
                 answer.append(combination)
             for i in xrange(start, len(candidates)):
-                n = candidates[i]
-                if n>target_remain: break
-                helper(combination+[n], i, target_remain-n)
+                num = candidates[i] #try out if with num adding into combination can make target_remain 0
+                if num>target_remain: break
+                helper(combination+[num], i, target_remain-num)
 
         candidates.sort()
         answer = []

problems/combinations.py

@@ -0,0 +1,73 @@
+class Solution(object):
+    def combine(self, N, K):
+        def helper(first, combination):
+            if len(combination)==K:
+                answer.append(combination)
+            else:
+                for num in xrange(first, N+1):
+                    helper(num+1, combination+[num])
+        answer = []
+        helper(1, [])
+        return answer
+"""
+`helper()` helps append `combination` to the `answer` if there are already K element in the `combination`.
+
+The parameter `first` means we are only going to use number fisrt~N.
+Because we used the smaller number already, or we will have duplicates.
+
+If there are not enough element in the `combination`, it will run through fisrt~N and append all the element `num` to the `combination`, and set the `first` to num+1.
+In other words, if we use 3, we will not use 3 and the number below 3 anymore.
+
+The call stack will be
+```
+N = 4, K = 2.
+
+helper(1, [])
+    helper(2, [1])
+        helper(3, [1, 2])
+        helper(4, [1, 3])
+        helper(5, [1, 4])
+
+    helper(3, [2])
+        helper(4, [2, 3])
+        helper(5, [2, 4])
+
+    helper(4, [3])
+        helper(5, [3, 4])
+
+    helper(5, [4])
+```
+"""
+
+class Solution(object):
+    def combine(self, N, K):
+        answer = []
+        combination = []
+        first = 1
+        while True:
+            if len(combination)==K:
+                answer.append(combination[:])
+
+            if len(combination)==K or first>N:
+                if not combination: return answer
+                first = combination.pop()+1 #backtrack
+            else:
+                combination.append(first)
+                first+=1
+"""
+Iterative solution is not so easy to understand.
+I suggest you run a easier example on paper, and you will know how it works. (`N = 4 , K = 2`)
+For every iterative, we append the combination to the answer if the length is equal to K already.
+Adjust the `first` whenever needed (`len(combination)==K or first>N`), if not, keep on appending.
+
+The time complexity is O(N!/(N!(N-K)!)), combination N choose K.
+The space complexity is O(N!/(N!(N-K)!)), combination N choose K.
+"""
+
+
+
+
+
+
+
+

problems/subsets-ii.py

@@ -0,0 +1,53 @@
+"""
+If we use the solution from the [last question](https://leetcode.com/problems/subsets/),
+We will notice that it will have some duplicates.
+This is because if you have three 2 (`[2, 2, 2]`).
+You might choosing two different sets of 2 and end up looking the same.
+For example, you choose the first and the second => `[2, 2]`
+You choose the second and the third => `[2, 2]`
+
+One workaround I did is just using hash-set.
+```
+return list(set([tuple(combination) for combination in answer]))
+```
+This cause us really high time complexity.
+Since turning list to tuple and tuple to list is actually O(N) in theory.
+
+Time complexity would be `O((2^N) * N)` be cuase for each element in the answer we need to convert it to tuple and back.
+"""
+class Solution(object):
+    def subsetsWithDup(self, nums):
+        nums.sort()
+        answer = [[]]
+        for num in nums:
+            new_subs = []
+            for sub in answer:
+                new_subs.append(sub+[num])
+            answer.extend(new_subs)
+        return list(set([tuple(combination) for combination in answer]))
+
+"""
+I found the best solution and explaination is made by @ZitaoWang's answer and here is his [explaination](https://leetcode.com/problems/subsets-ii/discuss/171626/Python-solution). I copied from it.
+For example, `nums = [1,1,2,2,2,4,4,5]`. In this case, `counter = {1:2, 2:3, 4:2, 5:1}`.
+We intialize `answer = [[]]` and build the solution iteratively as we loop over the counter.
+We first reach `num, count = 1, 2`. The power set of [1,1] is `[[], [1], [1,1]]`.
+Then we reach `num, count = 2, 3`.
+The power set of [1,1,2,2,2] is obtained by appending either zero, one, two or three 2's to all elements in `answer`.
+After which we get answer = [[], [1], [1,1], [2], [1,2], [1,1,2],[2,2], [1,2,2], [1,1,2,2],[2,2,2], [1,2,2,2], [1,1,2,2,2]].
+After we loop over counter, answer will be the power set of nums.
+
+Time complexity: `O(2^N)`, space complexity: `O(2^N)`.
+"""
+from collections import Counter
+
+class Solution(object):
+    def subsetsWithDup(self, nums):
+        counter = Counter(nums)
+        answer = [[]]
+
+        for num, count in counter.items():
+            power_set = [[num]*c for c in xrange(1, count+1)]
+            for i in xrange(len(answer)):
+                for s in power_set:
+                    answer.append(answer[i]+s)
+        return answer

problems/subsets.py

@@ -0,0 +1,74 @@
+"""
+For every number in `nums` you either take (O) or not take it (X).
+So for example
+```
+nums = [1,2,3]
+
+Subset [] is [X,X,X]
+Subset [1] is [O,X,X] => [1,X,X]
+Subset [2] is [X,O,X] => [X,2,X]
+Subset [3] is [X,X,O] => [X,X,3]
+Subset [1,2] is [O,O,X] => [1,2,X]
+Subset [1,3] is [O,X,O] => [1,X,3]
+.
+.
+.
+
+Subset [1,2,3] is [O,O,O] => [1,2,3]
+```
+So there are total 2x2x2 posibilities (subsets).
+Because for each number, it has two choices, take (O) or not take (X).
+"""
+
+
+class Solution(object):
+    def subsets(self, nums):
+        def helper(i, combination):
+            answer.add(tuple(combination))
+            if i>=len(nums): return
+            helper(i+1, combination+[nums[i]])
+            helper(i+1, combination)
+
+        answer = set()
+        helper(0, [])
+        return [list(combination) for combination in answer]
+"""
+`helper()` help add `combination` to the answer.
+And if we have run through all the numbers, return.
+If not, for this number at index `i`, there are two scenarios.
+Add it to the combination, or not.
+
+And there might be duplicates, and I could not think of better way without using hash set on `answer`.
+
+The time complexity is O(2^N). The space complexity is O(2^N), too.
+"""
+
+
+class Solution(object):
+    def subsets(self, nums):
+        answer = [[]]
+        for n in nums:
+            new_subs = []
+            for sub in answer:
+                new_subs.append(sub+[n])
+            answer.extend(new_subs)
+        return answer
+"""
+So for each n in `nums`, what we do is
+```
+new_subs = []
+for sub in answer:
+    new_subs.append(sub+[n])
+answer.extend(new_subs)
+```
+We take all the subset in the `answer`, append n, put the new subset into `new_subs`.
+And the answer become `subsets` + `new subsets`.
+You can think of it as
+`subsets` => the combination which we did not take n.
+`new subsets` => the combination which we take n.
+
+Now if we have iterated the third element, then the `answer` now contains all the possible subsets, the combination which we took the third element, and the combination which we did not take the third element.
+
+The time complexity is O(2^N). The space complexity is O(2^N), too.
+(This solution is in spired by @ZitaoWang's elegant solution)
+"""