代码随想录day28 回溯（4）

491. 非递减子序列 - 力扣（LeetCode） 

一开始看错题了，先将数组排序，但其实题目要求取原数组的递增子序列，所以此题需要处理一个可能是乱序的数组。(1)为保证子序列递增，加入当前元素前确保它不比path最后一个元素小；(2)每得到一个新path，只要它长度超过1，加入res；(3)由于数组乱序，不能通过当前元素的上一个元素去重，所以在每一层递归里新建一个集合，保存该层已访问过的数值，只有当元素未访问才能加入path。

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
    
    def bt(self, nums, start):
        visit = set()
        for i in range(start, len(nums)):
            if self.path and self.path[-1] > nums[i]:
                continue
            if nums[i] in visit:
                continue
            
            self.path.append(nums[i])
            if len(self.path) >= 2:
                self.res.append(self.path[:])
            self.bt(nums, i+1)
            self.path.pop()
            visit.add(nums[i])

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

 

46. 全排列 - 力扣（LeetCode） 

path的每个位置可以取除了前面已使用过的数字之外的全部数，由于数组元素不重复，可以用visit数组存放已访问过的数；visit也需要回溯。

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
        self.visit = []
    
    def bt(self, nums):
        if len(self.path) == len(nums):
            self.res.append(self.path[:])
            return
        
        for num in nums:
            if num not in self.visit:
                self.visit.append(num)
                self.path.append(num)
                self.bt(nums)
                self.path.pop()
                self.visit.pop()

    def permute(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        self.bt(nums)
        return self.res

47. 全排列 II - 力扣（LeetCode）

需要对nums去重，先排序nums；只需要对同层去重，若visit[i-1] == True，说明i-1是上一层的元素，否则是同层的元素。若是同层而且与i数值重复，就跳过i。

class Solution:
    def __init__(self):
        self.path = []
        self.res = []
    
    def bt(self, nums):
        if len(self.path) == len(nums):
            self.res.append(self.path[:])
            return
        
        for i in range(len(nums)):
            if i > 0 and nums[i-1] == nums[i] and not self.visit[i-1]: #若与上一个相等而且与上一个同层，跳过
                continue 
                
            if not self.visit[i]:
                self.visit[i] = True
                self.path.append(nums[i])
                self.bt(nums)
                self.path.pop()
                self.visit[i] = False

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        self.visit = [False for _ in range(len(nums))]
        self.bt(nums)
        return self.res