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

491.递增子序列

不是排序之后的递增子序列，而是原序列的递增子序列

树结构的层级遍历上需要去重，因此需要了解该层级上什么元素已经被使用了

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def backtracking(self, nums, startIndex):
        # 收集所有结果
        if len(self.path) > 1:
            self.result.append(self.path[:])
        used = [0]*201
        for i in range(startIndex, len(nums)):
            if (self.path and nums[i] < self.path[-1]) or used[nums[i]+100] == 1:
                continue
            used[nums[i] + 100] = 1
            self.path.append(nums[i])
            self.backtracking(nums, i+1)
            self.path.pop()

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

46.全排列

不需要startIndex，标记是否使用

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

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

    def permute(self, nums: List[int]) -> List[List[int]]:
        used = [False] * len(nums)
        self.backtracking(nums, used)
        return self.result

47.全排列 II

需要先排序，然后从树结构的层级上去重

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def backtracking(self, nums, used):
        if len(nums) == len(self.path):
            self.result.append(self.path[:])

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

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        # 先排序
        nums.sort()
        used = [False] * len(nums)
        self.backtracking(nums, used)
        return self.result