LeetCode 491.递增子序列
题目/文章/视频链接:491.递增子序列
看完代码随想录的想法:
跟之前的子集问题有点类似,但是又有明显区别,不能对原数组进行排序,而且去重逻辑也不太一样,需要在每一层记录一下数组内的元素有无重复使用,并且子集的长度≥2才行,其他地方跟求子集的地方都比较相似的。
敲代码过程的困难:
判断去重的数组应该放在for遍历之外,代表该一层的数组元素是否重复,这个数组的位置一开始放进for遍历之内,结果子集有重复的
实际代码:
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[:])
# 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()
LeetCode 46.全排列
题目/文章/视频链接:46.全排列
看完代码随想录的想法:
排列问题还是需要去重数组进行去重,只不过不需要StartIndex了,每次for遍历都从头开始遍历,其他都是回溯的基础操作
敲代码过程的困难:
没啥问题,不需要StartIndex从头遍历,正常回溯操作
实际代码:
class Solution:
def __init__(self):
self.path = []
self.paths = []
def permute(self, nums: List[int]) -> List[List[int]]:
'''
因为本题排列是有序的,这意味着同一层的元素可以重复使用,但同一树枝上不能重复使用(usage_list)
所以处理排列问题每层都需要从头搜索,故不再使用start_index
'''
usage_list = [False] * len(nums)
self.backtracking(nums, usage_list)
return self.paths
def backtracking(self, nums: List[int], usage_list: List[bool]) -> None:
# Base Case本题求叶子节点
if len(self.path) == len(nums):
self.paths.append(self.path[:])
return
# 单层递归逻辑
for i in range(0, len(nums)): # 从头开始搜索
# 若遇到self.path里已收录的元素,跳过
if usage_list[i] == True:
continue
usage_list[i] = True
self.path.append(nums[i])
self.backtracking(nums, usage_list) # 纵向传递使用信息,去重
self.path.pop()
usage_list[i] = False
LeetCode 47.全排列 II
题目/文章/视频链接:47.全排列||
看完代码随想录的想法:
这是包含重复元素的排列问题,那就要在去重数组进行进一步的判断,跟之前的包含重复元素的子集问题操作一样,排列问题和子集问题大同小异,注意几个细节的问题就好
敲代码过程的困难:
在去重数组的进一步操作还是有点生疏
实际代码:
class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
# res用来存放结果
if not nums: return []
res = []
used = [0] * len(nums)
def backtracking(nums, used, path):
# 终止条件
if len(path) == len(nums):
res.append(path.copy())
return
for i in range(len(nums)):
if not used[i]:
if i>0 and nums[i] == nums[i-1] and not used[i-1]:
continue
used[i] = 1
path.append(nums[i])
backtracking(nums, used, path)
path.pop()
used[i] = 0
# 记得给nums排序
backtracking(sorted(nums),used,[])
return res
今日收获:
今天学习了如何解决排列问题,跟组合问题区别就在于每层for遍历都是从头开始遍历不是从StarIndex的位置,其他操作大同小异,今日学习1.5h!