May 29, 2023 · May 25, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023
diff --git a/problems/回溯算法去重问题的另一种写法.md b/problems/回溯算法去重问题的另一种写法.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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])

	backtracking(0, [])
	return res
	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()

		```

		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(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()

	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, [])

	return res
		```

		47. 全排列 II

		```python
		class Solution:
	def permuteUnique(self, nums: List[int]) -> List[List[int]]:
	path = []
	res = []
	used = [False]*len(nums)

	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 permuteUnique(self, nums):
	nums.sort() # 排序
	result = []
	self.backtracking(nums, [False] * len(nums), [], result)
	return result

	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:
Expand Down