算法训练 Day28

491.递增子序列

解法：回溯 + 去重（用set）

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        path = []
        res = []
        

        def backtracking(nums,startindex):
            if len(path) >= 2:
                res.append(path[:])
                
            used = set()
            for i in range(startindex,len(nums)):
                if (path and nums[i] < path[-1] ) or nums[i] in used:
                    continue
                
                path.append(nums[i])
                used.add(nums[i])

                backtracking(nums,i+1)

                path.pop()
                
        backtracking(nums,0)
        return res

46.全排列

解法：回溯 + 不使用startindex

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        path = []
        res = []

        def backtracking(nums):
            if len(path) == len(nums):
                res.append(path[:])
                return
            
            for i in range(len(nums)):
                if nums[i] in path:
                    continue
                path.append(nums[i])
                backtracking(nums)
                path.pop()
        backtracking(nums)
        return res

47.全排列 II

解法：回溯 + 不使用startindex + 树层去重

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        path = []
        res = []
        nums.sort()
        used = [False] * len(nums)
        def backtracking(nums):
            if len(path) == len(nums):
                res.append(path[:])
                return
            
            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]:
                    path.append(nums[i])
                    used[i] = True
                    backtracking(nums)
                    path.pop()
                    used[i] = False
        backtracking(nums)
        return res