Update 回溯算法去重问题的另一种写法.md

problems/回溯算法去重问题的另一种写法.md

@@ -356,76 +356,80 @@ Python：
 
 ```python
 class Solution:
-    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
-        res = []
-        nums.sort()
-        def backtracking(start, path):
-            res.append(path)
-            uset = set()
-            for i in range(start, len(nums)):
-                if nums[i] not in uset:
-                    backtracking(i + 1, path + [nums[i]])
-                    uset.add(nums[i])
+    def subsetsWithDup(self, nums):
+        nums.sort()  # 去重需要排序
+        result = []
+        self.backtracking(nums, 0, [], result)
+        return result
+
+    def backtracking(self, nums, startIndex, path, result):
+        result.append(path[:])
+        used = set()
+        for i in range(startIndex, len(nums)):
+            if nums[i] in used:
+                continue
+            used.add(nums[i])
+            path.append(nums[i])
+            self.backtracking(nums, i + 1, path, result)
+            path.pop()
 
-        backtracking(0, [])
-        return res
 ```
 
 **40. 组合总和 II**
 
 ```python
 class Solution:
-    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
-        
-        res = []
+    def combinationSum2(self, candidates, target):
         candidates.sort()
+        result = []
+        self.backtracking(candidates, target, 0, 0, [], result)
+        return result
 
-        def backtracking(start, path):
-            if sum(path) == target:
-                res.append(path)
-            elif sum(path) < target:
-                used = set()
-                for i in range(start, len(candidates)):
-                    if candidates[i] in used:
-                        continue
-                    else:
-                        used.add(candidates[i])
-                        backtracking(i + 1, path + [candidates[i]])
-        
-        backtracking(0, [])
+    def backtracking(self, candidates, target, sum, startIndex, path, result):
+        if sum == target:
+            result.append(path[:])
+            return
+        used = set()
+        for i in range(startIndex, len(candidates)):
+            if sum + candidates[i] > target:
+                break
+            if candidates[i] in used:
+                continue
+            used.add(candidates[i])
+            sum += candidates[i]
+            path.append(candidates[i])
+            self.backtracking(candidates, target, sum, i + 1, path, result)
+            sum -= candidates[i]
+            path.pop()
 
-        return res
 ```
 
 **47. 全排列 II**
 
 ```python
 class Solution:
-    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
-        path = []
-        res = []
-        used = [False]*len(nums)
+    def permuteUnique(self, nums):
+        nums.sort()  # 排序
+        result = []
+        self.backtracking(nums, [False] * len(nums), [], result)
+        return result
 
-        def backtracking():
-            if len(path) == len(nums):
-                res.append(path.copy())
-            
-            deduplicate = set()
-            for i, num in enumerate(nums):
-                if used[i] == True:
-                    continue
-                if num in deduplicate:
-                    continue
+    def backtracking(self, nums, used, path, result):
+        if len(path) == len(nums):
+            result.append(path[:])
+            return
+        used_set = set()
+        for i in range(len(nums)):
+            if nums[i] in used_set:
+                continue
+            if not used[i]:
+                used_set.add(nums[i])
                 used[i] = True
                 path.append(nums[i])
-                backtracking()
-                used[i] = False
+                self.backtracking(nums, used, path, result)
                 path.pop()
-                deduplicate.add(num)
-        
-        backtracking()
+                used[i] = False
 
-        return res
 ```
 
 JavaScript：