代码随想录算法训练营Day29 | 491. 递增子序列 | 46. 全排列 | 47. 全排列 II

491. 递增子序列

题目链接 | 解题思路

看上去和 90. 组合II 非常相似，同样是同一集合内的子集。但是，本题的递增是由原序列决定的，所以不能对序列排序！题中的例子 [4, 7, 6, 7]，如果排序后变成了 [4, 6, 7, 7]，[4, 6, 7, 7] 也成为了一个递增子序列，但不符合题目要求。

回忆之前的定义，这里需要的是同一层的去重（40. 组合总和II），即同一层上遇到重复的元素值就直接跳过即可（其产生的结果必然是第一次遇到该值的结果的子集）；path 的去重仅限元素，可以允许元素值的重复。

• 相同父节点下，同一层使用过的元素值不能再用（直接跳过）
• 同一 path 上的值必须（非严格）递增
• 并非所有结果都在叶子上，收集结果时不要直接 return

以此可以推出回溯的三要素：

• 参数和返回值：两个经典全局变量；一个额外的参数 start_idx 来记录当前起点，因为组合显然不能重复使用元素。
• 终止条件：每一条 path 的结束仅有两种可能 1）到达数组结尾； 2）当前 path 不符合要求。实际上可以不特意设置终止条件，在 for loop 中会自动结束。
  • 处理符合条件的 path 时不能返回！
• 单层搜索：相同父节点下，同一层使用过的元素值不能再用。所以在同一层（for loop）内，保存一个本地变量，记录当前层使用过的元素值。

这里的 used 数组（层级记录）只记录当前层的使用情况（for loop），它的存在不会跟着递归改变，也就不用回溯。这和之前的 used 数组有巨大的区别，因为之前的 used 记录了 path 上的使用，所以要跟着 path 进行递归+回溯。

优化：在单层搜索中，用来记录当前层使用过的元素值的变量，符合直觉的应该是一个 set，这样可以轻松判断当前元素值是否已经出现过。但 set 用作哈希时，insert 的操作会很耗时，用 list 作为哈希容器会更好，因为本题中限定了数值范围 [-100, 100]。

class Solution:
    def __init__(self):
        self.curr_record = []
        self.results = []
    
    def backtrack(self, nums: List[int], start_idx: int):
        if len(self.curr_record) >= 2:
            self.results.append(self.curr_record.copy())
        
        loop_used = [False] * 201
        for i in range(start_idx, len(nums)):
            if len(self.curr_record) > 0 and nums[i] < self.curr_record[-1]:    # the current elemet is making decreasing
                continue
            if loop_used[nums[i] + 100]:          # this element has been used
                continue
            self.curr_record.append(nums[i])
            loop_used[nums[i] + 100] = True
            self.backtrack(nums, i + 1)
            self.curr_record.pop()

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        self.backtrack(nums, 0)
        return self.results

本题的重点在于，去重的记录是同一节点下的同一层，是在 for loop 而非 path 上的记录，所以无需回溯，这点一定要分清楚。

46. 全排列

题目链接 | 解题思路

排列和组合/子集最大的区别在于：start_idx 不再通用了！
在排列问题中，已经使用过的元素并不会在 for loop 的下一个 iteration 中禁用，而是仅在当前递归的 path 中禁用（需要根据 path 进行递归+回溯）。这导致我们不再依靠 start_idx 来进行去重，而是完全依靠使用记录。

• 参数和返回值：两个经典全局变量；不再需要 start_idx。
• 终止条件：只有叶子节点才会包含符合条件的排列结果，所以当前收集的 path 长度等于原数组时，意味着可以储存当前结果了。
• 单层搜索：不再改变 start_idx，而是依靠使用记录 used 数组来决定下一次递归中能使用的元素（递归的变化更隐蔽了，每层都是从头到尾，变化的是使用记录）。

class Solution:
    def __init__(self):
        self.curr_record = []
        self.results = []
    
    def backtrack(self, nums: List[int], used_nums: List[int]):
        if len(used_nums) == len(nums):
            self.results.append(self.curr_record.copy())
            return None
        
        for num in nums:
            if num not in used_nums:
                self.curr_record.append(num)
                used_nums.append(num)
                self.backtrack(nums, used_nums)
                self.curr_record.pop()
                used_nums.pop()

    def permute(self, nums: List[int]) -> List[List[int]]:
        self.backtrack(nums, [])
        return self.results

优化

因为本题设置了输入数据的范围 [-10, 10]，使用数组进行哈希，可以直接搜索对应位置，大大节省使用 used 数组的时间。
不过利用数组进行哈希需要提前知道数据范围，所以需要观察仔细。

class Solution:
    def __init__(self):
        self.curr_record = []
        self.results = []
    
    def backtrack(self, nums: List[int], used_nums: List[int]):
        if len(self.curr_record) == len(nums):
            self.results.append(self.curr_record.copy())
            return None
        
        for num in nums:
            if not used_nums[num + 10]:
                self.curr_record.append(num)
                used_nums[num + 10] = True
                self.backtrack(nums, used_nums)
                self.curr_record.pop()
                used_nums[num + 10] = False

    def permute(self, nums: List[int]) -> List[List[int]]:
        self.backtrack(nums, [False] * 21)
        return self.results

47. 全排列 II

题目链接 | 解题思路

排列的去重，依然要对数组先排序。同时要注意不同的去重机制：

• 同一父节点下的元素值不能重复使用（注意是值），这个去重的周期是在 for loop 之内，不需要进一步递归+回溯，仅限于当前层的记录。
• 当前 path 内使用过的元素不能再使用，这个去重的周期是在 path 内，所以需要保持递归+回溯（path 是不断递归+回溯）。

层级记录 + path 记录（自己的解法）

• 层级纪录：像491一样对当前的 for loop 记录一个本地变量，如果当前元素值被使用过，则下一次遇到就直接跳过
• path 记录：维持一个额外的参数，记录当前 path 对元素的使用情况，如果遇到值相同的不同元素还是可以使用；该记录需要递归+回溯

class Solution:
    def __init__(self):
        self.curr_record = []
        self.results = []
    
    def backtrack(self, nums: List[int], path_record: List[int]):
        if len(self.curr_record) == len(nums):
            self.results.append(self.curr_record.copy())
            return None
        
        level_record = [False] * 21
        for i in range(len(nums)):
            if not level_record[nums[i] + 10]:
                if not path_record[i]:
                    level_record[nums[i] + 10] = True
                    path_record[i] = True
                    self.curr_record.append(nums[i])
                    self.backtrack(nums, path_record)
                    path_record[i] = False
                    self.curr_record.pop()

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        self.backtrack(nums, [False] * len(nums))
        return self.results

单一 used 数组

和之前的题一样，通过一个额外参数 used 数组来记录当前元素的使用。这是一个不断传递的变量，会一直参与递归+回溯。通过对 used 中相同元素值的元素进行记录，可以推得当前的重复元素是层次内的重复还是 path 上的重复：

nums = [1, 1, 2]
used1 = [1, 1, 0]
used2 = [0, 1, 0]

对于 used1，当我们查询到 idx=1 的元素时，前一个相邻的相同值的元素被使用过了，这意味着当前重复是出现在 path 上的，可以继续使用当前值。（对应的 path 上重复）
对于 used2，当我们查询到 idx=1 的元素时，前一个相邻的相同值的元素没被使用，则k可知，之前的结果回溯到了当前元素的父节点，然后再到达该节点。（对应的层次重复）

这样的判断方式的前提是要对输入进行排序。

class Solution:
    def __init__(self):
        self.curr_record = []
        self.results = []
    
    def backtrack(self, nums: List[int], used: List[int]):
        if len(self.curr_record) == len(nums):
            self.results.append(self.curr_record.copy())
            return None
        
        for i in range(len(nums)):
            if i > 0 and nums[i] == nums[i-1] and not used[i-1]:
            	# the previous duplicate is not used, level-duplicate
                continue
            if not used[i]:				# the current element is available
                used[i] = True
                self.curr_record.append(nums[i])
                self.backtrack(nums, used)
                self.curr_record.pop()
                used[i] = False

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        self.backtrack(nums, [False] * len(nums))
        return self.results

去重代码的核心就是这部分：

if i > 0 and nums[i] == nums[i-1] and not used[i-1]:
	continue

其中 not used[i-1] 代表着出现了树层内的重复，那我们就忽略当前的节点（层次内去重）。对于该元素值的结果遍历出现在第一次遇到该元素值的时候。

但另一种写法也可以：

if i > 0 and nums[i] == nums[i-1] and used[i-1]:
	continue

这里检查的是 path 上面的元素重复，即如果当前 path 上使用过了相同值的元素，则忽略当前 path。对于该元素值的结果遍历出现在最后一次遇到该元素值的时候，之前被当作去重了（如下图所示）。这种方法固然可以成立，但是会多很多不必要的检查，效率并不高。