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

This commit is contained in:
jianghongcheng
2023-05-27 21:49:43 -05:00
committed by GitHub
parent fd2608a38c
commit 19ecde0984

View File

@ -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