May 29, 2023 · May 25, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023 · May 26, 2023
diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -267,79 +267,53 @@ class Solution {
		### Python

		python3
	回溯
	回溯利用set去重
		```python
		class Solution:
	def __init__(self):
	self.paths = []
	self.path = []

	def findSubsequences(self, nums: List[int]) -> List[List[int]]:
	'''
	本题求自增子序列,所以不能改变原数组顺序
	'''
	self.backtracking(nums, 0)
	return self.paths

	def backtracking(self, nums: List[int], start_index: int):
	# 收集结果,同78.子集,仍要置于终止条件之前
	if len(self.path) >= 2:
	# 本题要求所有的节点
	self.paths.append(self.path[:])
	def findSubsequences(self, nums):
	result = []
	self.backtracking(nums, 0, [], result)
	return result

	def backtracking(self, nums, startIndex, path, result):
	if len(path) > 1:
	result.append(path[:]) # 将当前路径的副本加入结果集

	# Base Case(可忽略)
	if start_index == len(nums):
	return

	# 单层递归逻辑
	# 深度遍历中每一层都会有一个全新的usage_list用于记录本层元素是否重复使用
	usage_list = set()
	# 同层横向遍历
	for i in range(start_index, len(nums)):
	# 若当前元素值小于前一个时(非递增)或者曾用过,跳入下一循环
	if (self.path and nums[i] < self.path[-1]) or nums[i] in usage_list:
	continue
	usage_list.add(nums[i])
	self.path.append(nums[i])
	self.backtracking(nums, i+1)
	self.path.pop()
	used = set() # 使用集合来进行去重操作
	for i in range(startIndex, len(nums)):
	if path and nums[i] < path[-1]:
	continue # 如果当前元素小于上一个元素,则跳过当前元素

	if nums[i] in used:
	continue # 如果当前元素已经使用过,则跳过当前元素

	used.add(nums[i]) # 标记当前元素已经使用过
	self.backtracking(nums, i + 1, path + [nums[i]], result)

		```
	回溯+哈希表去重
	回溯利用哈希表去重
		```python
		class Solution:
	def __init__(self):
	self.paths = []
	self.path = []

	def findSubsequences(self, nums: List[int]) -> List[List[int]]:
	'''
	本题求自增子序列,所以不能改变原数组顺序
	'''
	self.backtracking(nums, 0)
	return self.paths

	def backtracking(self, nums: List[int], start_index: int):
	# 收集结果,同78.子集,仍要置于终止条件之前
	if len(self.path) >= 2:
	# 本题要求所有的节点
	self.paths.append(self.path[:])
	def findSubsequences(self, nums):
	result = []
	path = []
	self.backtracking(nums, 0, path, result)
	return result

	def backtracking(self, nums, startIndex, path, result):
	if len(path) > 1:
	result.append(path[:]) # 注意要使用切片将当前路径的副本加入结果集

	# Base Case(可忽略)
	if start_index == len(nums):
	return

	# 单层递归逻辑
	# 深度遍历中每一层都会有一个全新的usage_list用于记录本层元素是否重复使用
	usage_list = [False] * 201 # 使用列表去重,题中取值范围[-100, 100]
	# 同层横向遍历
	for i in range(start_index, len(nums)):
	# 若当前元素值小于前一个时(非递增)或者曾用过,跳入下一循环
	if (self.path and nums[i] < self.path[-1]) or usage_list[nums[i]+100] == True:
	continue
	usage_list[nums[i]+100] = True
	self.path.append(nums[i])
	self.backtracking(nums, i+1)
	self.path.pop()
	used = [0] * 201 # 使用数组来进行去重操作,题目说数值范围[-100, 100]
	for i in range(startIndex, len(nums)):
	if (path and nums[i] < path[-1]) or used[nums[i] + 100] == 1:
	continue # 如果当前元素小于上一个元素,或者已经使用过当前元素,则跳过当前元素

	used[nums[i] + 100] = 1 # 标记当前元素已经使用过
	path.append(nums[i]) # 将当前元素加入当前递增子序列
	self.backtracking(nums, i + 1, path, result)
	path.pop()

		```
		### Go

Expand Down