update 39 40 Combination Sum II

Author: selfboot

Backtracking/39_CombinationSum.cpp

@@ -1,6 +1,6 @@
 /*
  * @Author: [email protected]
- * @Last Modified time: 2016-07-14 20:03:04
+ * @Last Modified time: 2016-07-14 20:32:51
  */
 
 class Solution {
@@ -9,7 +9,7 @@ class Solution {
     Classic backtracking problem.
 
     One key point: for one specified number,
-    just scan the number larger than it to avoid duplicate combinations.
+    just scan itself and numbers larger than it to avoid duplicate combinations.
     Besides, the current path need to be reset after dfs call in general.
     Refer to:
     https://discuss.leetcode.com/topic/23142/python-dfs-solution

Backtracking/39_CombinationSum.py

@@ -6,7 +6,7 @@ class Solution(object):
     """ Classic backtracking problem.
 
     One key point: for one specified number,
-    just scan the number larger than it to avoid duplicate combinations.
+    just scan itself and numbers larger than it to avoid duplicate combinations.
     Besides, the current path need to be reset after dfs call in general.
     Here we can just use `path + [num]` to avoid modifying path, so no need to reset.
     Refer to:

Backtracking/40_CombinationSumII.cpp

@@ -0,0 +1,55 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-15 21:38:18
+ */
+
+class Solution {
+    /*
+    Classic backtracking problem.
+
+    One key point: for one specified number,
+    just scan the number larger than it to avoid duplicate combinations.
+    Besides, the current path need to be reset after dfs call in general.
+    That's saying, we need to do pop_back after push_back operator.
+    */
+private:
+    void dfs_search(vector<int> &candidates, int start, int target, vector<int> &path, vector<vector<int>> &ans){
+        if(target==0){
+            ans.push_back(path);
+        }
+        for(int i=start; i<candidates.size(); i++){
+            int num = candidates[i];
+            if(num > target){
+                return;
+            }
+
+            // Here skip the same `adjacent` element to avoid duplicated.
+            if(i > start && candidates[i] == candidates[i－1]){
+                continue;
+            }
+            path.push_back(candidates[i]);
+            dfs_search(candidates, i+1, target-num, path, ans);
+            path.pop_back();
+        }
+    }
+public:
+    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
+        if(candidates.size() == 0){
+            return {};
+        }
+        sort(candidates.begin(), candidates.end());
+        vector<int> path;
+        vector<vector<int>> ans;
+        dfs_search(candidates, 0, target, path, ans);
+        return ans;
+    }
+};
+
+/*
+[]
+1
+[2, 5, 1, 4, 9]
+11
+[10, 1, 2, 7, 6, 1, 5]
+8
+*/

Backtracking/40_CombinationSumII.py

@@ -0,0 +1,42 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    """ Classic backtracking problem.
+
+    One key point: for one specified number,
+    just scan the number larger than it to avoid duplicate combinations.
+    Besides, the current path need to be reset after dfs call in general.
+    Here we can just use `path + [num]` to avoid modifying path, so no need to reset.
+    """
+
+    def combinationSum2(self, candidates, target):
+        if not candidates:
+            return []
+        candidates.sort()
+        ans = []
+        self.dfs_search(candidates, 0, target, [], ans)
+        return ans
+
+    def dfs_search(self, candidates, start, target, path, ans):
+        if target == 0:
+            ans.append(path)
+        for i in xrange(start, len(candidates)):
+            num = candidates[i]
+            if num > target:
+                return
+            # Here skip the same `adjacent` element to avoid duplicated.
+            if i > start and candidates[i] == candidates[i - 1]:
+                continue
+            self.dfs_search(candidates, i + 1,
+                            target - num, path + [num], ans)
+
+"""
+[]
+1
+[2, 5, 1, 4, 9]
+11
+[10, 1, 2, 7, 6, 1, 5]
+8
+"""