no message

Author: Chris Wu

problems/combination-sum-ii.py

@@ -36,3 +36,21 @@ def helper(combination, start, target_remain):
         candidates.sort()
         helper([], 0, target)
         return [list(combination) for combination in answer]
+
+#DFS
+class Solution(object):
+    def combinationSum2(self, candidates, T):
+        def dfs(index, target, path):
+            if target<0:
+                return
+            elif target==0:
+                opt.append(path)
+            else:
+                for i in xrange(index, len(candidates)):
+                    if i>index and candidates[i]==candidates[i-1]: continue
+                    num = candidates[i]
+                    dfs(i+1, target-num, path+[num])
+        opt = []
+        candidates.sort()
+        dfs(0, T, [])
+        return opt

problems/combination-sum-iii.py

@@ -25,3 +25,16 @@ def combinationSum3(self, K, N):
                 ans.append(first)
                 total+=first
                 first+=1
+
+#DFS
+class Solution(object):
+    def combinationSum3(self, K, N):
+        def dfs(path, min_num):
+            if len(path)==K and sum(path)==N:
+                opt.append(path)
+            for num in xrange(min_num, 10):
+                dfs(path+[num], num+1)
+        opt = []
+        dfs([], 1)
+        return opt
+

problems/combination-sum.py

@@ -74,3 +74,47 @@ def helper(candidates, target, combination):
             else:
                 return helper(candidates, target-n, combination+[n]) + helper(candidates[1:], target, combination)
         return helper(sorted(candidates), target, [])
+
+
+# 2019/9/12 Update
+class Solution(object):
+    def combinationSum(self, candidates, T):
+        answer = []
+        ans = []
+        first = 0
+        total = 0
+
+        candidates.sort()
+
+        memo = {}
+        for i, num in enumerate(candidates):
+            memo[num] = i
+
+        while True:
+            if total==T:
+                answer.append(ans[:])
+            if total>=T or first>=len(candidates):
+                if not ans: return answer
+                num = ans.pop()
+                first = memo[num]+1
+                total-=num
+            else:
+                ans.append(candidates[first])
+                total+=candidates[first]
+
+# DFS
+class Solution(object):
+    def combinationSum(self, candidates, T):
+        def dfs(index, target, path):
+            if target<0:
+                return
+            elif target==0:
+                opt.append(path)
+            else:
+                for i in xrange(index, len(candidates)):
+                    num = candidates[i]
+                    dfs(i, target-num, path+[num])
+        opt = []
+        candidates.sort()
+        dfs(0, T, [])
+        return opt

problems/combinations.py

@@ -66,6 +66,22 @@ def combine(self, N, K):
 
 
 
+#DFS
+class Solution(object):
+    def combine(self, N, K):
+        def dfs(n_min, path):
+            if len(path)==K:
+                opt.append(path)
+                return
+            else:
+                for n in xrange(n_min, N+1):
+                    dfs(n+1, path+[n])
+        opt = []
+        dfs(1, [])
+        return opt
+
+
+
 
 
 

problems/subsets-ii.py

@@ -51,3 +51,21 @@ def subsetsWithDup(self, nums):
                 for s in power_set:
                     answer.append(answer[i]+s)
         return answer
+
+
+#DFS
+class Solution(object):
+    def subsetsWithDup(self, nums):
+        nums.sort()
+
+        def dfs(path, nums):
+            opt.append(path)
+            if len(nums)==0: return
+            for i, num in enumerate(nums):
+                if i>0 and nums[i]==nums[i-1]: continue
+                dfs(path+[num], nums[i+1:])
+        opt = []
+        dfs([], nums)
+        return opt
+
+

problems/subsets.py

@@ -72,3 +72,16 @@ def subsets(self, nums):
 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)
 """
+
+#DFS
+class Solution(object):
+    def subsets(self, nums):
+        def dfs(path, nums):
+            opt.append(path)
+            if len(nums)==0: return
+            for i, num in enumerate(nums):
+                dfs(path+[num], nums[i+1:])
+
+        opt = []
+        dfs([], nums)
+        return opt