代码随想录 Day-29｜#491 递增子序列｜#46 全排列 ｜#47全排列II

清单

• 491.递增子序列
• 46.全排列
• 47.全排列 II

LeetCode #491 递增子序列

1. 题目

给你一个整数数组 nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。
数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

2. 思路

按照回溯三部曲:

1. 递归函数的返回值和参数, 数组 nums，开始角标start_index，遍历路径path，储存结果result
2. 终止条件：遍历完nums数组
3. 单层搜索过程: for循环遍历

3. 代码实现

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        result = []
        path = []
        self.backtracing(nums, 0, path, result)
        return result

    def backtracing(self, nums, start_index, path, result):
        if len(path) > 1:
            result.append(path[:])
        
        uset = set()
        for i in range(start_index,len(nums)):
            if (path and nums[i] < path[-1]) or nums[i] in uset:
                continue

            uset.add(nums[i])
            path.append(nums[i])
            self.backtracing(nums, i + 1, path, result)
            path.pop()

LeetCode #46 全排列

1. 题目

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以按任意顺序返回答案。

2. 思路

按照回溯三部曲:

1. 递归函数的返回值和参数，数组 nums，遍历路径path，储存结果result，used数组记录使用元素
2. 终止条件：遍历完nums数组
3. 单层搜索过程: for循环遍历

3. 代码实现

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        result = []
        self.backtracing(nums, [], [False] * len(nums), result)
        return result
    
    def backtracing(self, nums, path, used,result):
        if len(path) == len(nums):
            result.append(path[:])
            return

        for i in range(len(nums)):
            if used[i]:
                continue
            used[i] = True
            path.append(nums[i])
            self.backtracing(nums, path, used, result)
            path.pop()
            used[i] = False

LeetCode #47 全排列 II

1. 题目

给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列

2. 思路

按照回溯三部曲:

1. 递归函数的返回值和参数，数组 nums，遍历路径path，储存结果result，used数组记录使用元素
2. 终止条件：遍历完nums数组
3. 单层搜索过程: for循环遍历

3. 代码实现

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        result = []
        nums.sort()
        self.backtracing(nums, [], [False] * len(nums),result)
        return result
    
    def backtracing(self, nums, path, used, result):
        if len(path) == len(nums):
            result.append(path[:])
            return

        for i in range(len(nums)):
            if (i > 0 and nums[i] == nums[i-1] and not used[i-1]) or used[i]:
                continue
            used[i] = True
            path.append(nums[i])
            self.backtracing(nums, path, used,result)
            path.pop()
            used[i] = False