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

Update 0491.递增子序列.md

Browse Source
This commit is contained in:
jianghongcheng
2023-05-27 19:17:26 -05:00
committed by GitHub
parent 5801ae7523
commit eb72f26371
1 changed files with 36 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
problems/0491.递增子序列.md
View File

@ -267,79 +267,53 @@ class Solution {
### Python
python3
**回溯**
回溯 利用set去重
```python
class Solution:
def __init__(self):
self.paths = []
self.path = []
def findSubsequences(self, nums):
result = []
self.backtracking(nums, 0, [], result)
return result
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 backtracking(self, nums, startIndex, path, result):
if len(path) > 1:
result.append(path[:]) # 将当前路径的副本加入结果集
# Base Case（可忽略）
if start_index == len(nums):
return
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)
# 单层递归逻辑
# 深度遍历中每一层都会有一个全新的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()
```
**回溯+哈希表去重**
回溯 利用哈希表去重
```python
class Solution:
def __init__(self):
self.paths = []
self.path = []
def findSubsequences(self, nums):
result = []
path = []
self.backtracking(nums, 0, path, result)
return result
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 backtracking(self, nums, startIndex, path, result):
if len(path) > 1:
result.append(path[:]) # 注意要使用切片将当前路径的副本加入结果集
# Base Case（可忽略）
if start_index == len(nums):
return
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()
# 单层递归逻辑
# 深度遍历中每一层都会有一个全新的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()
```
### Go