algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-08 00:43:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
jianghongcheng
2023-05-27 21:49:43 -05:00
committed by GitHub
parent fd2608a38c
commit 19ecde0984
1 changed files with 53 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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