May 29, 2023 · May 25, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023
diff --git a/problems/0040.组合总和II.md b/problems/0040.组合总和II.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -354,93 +354,92 @@ class Solution {
		```

		## Python
	回溯+巧妙去重(省去使用used
	回溯
		```python
		class Solution:
	def __init__(self):
	self.paths = []
	self.path = []

	def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
	'''
	类似于求三数之和,求四数之和,为了避免重复组合,需要提前进行数组排序
	'''
	self.paths.clear()
	self.path.clear()
	# 必须提前进行数组排序,避免重复
	candidates.sort()
	self.backtracking(candidates, target, 0, 0)
	return self.paths

	def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
	# Base Case
	if sum_ == target:
	self.paths.append(self.path[:])
	def backtracking(self, candidates, target, total, startIndex, path, result):
	if total == target:
	result.append(path[:])
		return

	# 单层递归逻辑
	for i in range(start_index, len(candidates)):
	# 剪枝,同39.组合总和
	if sum_ + candidates[i] > target:
	return

	# 跳过同一树层使用过的元素
	if i > start_index and candidates[i] == candidates[i-1]:

	for i in range(startIndex, len(candidates)):
	if i > startIndex and candidates[i] == candidates[i - 1]:
		continue

	sum_ += candidates[i]
	self.path.append(candidates[i])
	self.backtracking(candidates, target, sum_, i+1)
	self.path.pop() # 回溯,为了下一轮for loop
	sum_ -= candidates[i] # 回溯,为了下一轮for loop

	if total + candidates[i] > target:
	break

	total += candidates[i]
	path.append(candidates[i])
	self.backtracking(candidates, target, total, i + 1, path, result)
	total -= candidates[i]
	path.pop()

	def combinationSum2(self, candidates, target):
	result = []
	candidates.sort()
	self.backtracking(candidates, target, 0, 0, [], result)
	return result

		```
	回溯+去重(使用used)
	回溯+去重(使用used)
		```python
		class Solution:
	def __init__(self):
	self.paths = []
	self.path = []
	self.used = []

	def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
	'''
	类似于求三数之和,求四数之和,为了避免重复组合,需要提前进行数组排序
	本题需要使用used,用来标记区别同一树层的元素使用重复情况:注意区分递归纵向遍历遇到的重复元素,和for循环遇到的重复元素,这两者的区别
	'''
	self.paths.clear()
	self.path.clear()
	self.usage_list = [False] * len(candidates)
	# 必须提前进行数组排序,避免重复
	candidates.sort()
	self.backtracking(candidates, target, 0, 0)
	return self.paths

	def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
	# Base Case
	if sum_ == target:
	self.paths.append(self.path[:])
	def backtracking(self, candidates, target, total, startIndex, used, path, result):
	if total == target:
	result.append(path[:])
		return

	# 单层递归逻辑
	for i in range(start_index, len(candidates)):
	# 剪枝,同39.组合总和
	if sum_ + candidates[i] > target:
	return

	# 检查同一树层是否出现曾经使用过的相同元素
	# 若数组中前后元素值相同,但前者却未被使用(used == False),说明是for loop中的同一树层的相同元素情况
	if i > 0 and candidates[i] == candidates[i-1] and self.usage_list[i-1] == False:

	for i in range(startIndex, len(candidates)):
	# 对于相同的数字,只选择第一个未被使用的数字,跳过其他相同数字
	if i > startIndex and candidates[i] == candidates[i - 1] and not used[i - 1]:
		continue

	sum_ += candidates[i]
	self.path.append(candidates[i])
	self.usage_list[i] = True
	self.backtracking(candidates, target, sum_, i+1)
	self.usage_list[i] = False # 回溯,为了下一轮for loop
	self.path.pop() # 回溯,为了下一轮for loop
	sum_ -= candidates[i] # 回溯,为了下一轮for loop
	if total + candidates[i] > target:
	break

	total += candidates[i]
	path.append(candidates[i])
	used[i] = True
	self.backtracking(candidates, target, total, i + 1, used, path, result)
	used[i] = False
	total -= candidates[i]
	path.pop()

	def combinationSum2(self, candidates, target):
	used = [False] * len(candidates)
	result = []
	candidates.sort()
	self.backtracking(candidates, target, 0, 0, used, [], result)
	return result

		```
	回溯优化
	```python
	class Solution:
	def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
	candidates.sort()
	results = []
	self.combinationSumHelper(candidates, target, 0, [], results)
	return results

	def combinationSumHelper(self, candidates, target, index, path, results):
	if target == 0:
	results.append(path[:])
	return
	for i in range(index, len(candidates)):
	if i > index and candidates[i] == candidates[i - 1]:
	continue
	if candidates[i] > target:
	break
	path.append(candidates[i])
	self.combinationSumHelper(candidates, target - candidates[i], i + 1, path, results)
	path.pop()
	```
		## Go
		主要在于如何在回溯中去重

Expand Down