回溯part 04

LC 90 子集Ⅱ

补昨天的一道，顺便练练手，思路与LC40一致

class Solution:
    def back_track(self, nums , index = 0):
        self.res.append(self.path[:])
        if index > len(nums):
            return
        for i in range(index , len(nums)):
            if i > index and self.used[i - 1] == 0 and nums[i] == nums[i-1]:
                continue
            self.path.append(nums[i])
            self.used[i] = 1
            self.back_track(nums , i + 1)
            self.path.pop()
            self.used[i] = 0
        return self.res

    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        self.path = []
        self.res = []
        self.used = [0] * len(nums)
        nums.sort()
        return self.back_track(nums)

LC 491 递增子序列

又巩固了几个知识点：

1，数层去重：本题在for循环前用set记录已使用的数字，后面就不能以这个集合里的数字作为根节点了

2,取数逻辑：求取结果在树的节点上的情形（子集的情形），一进递归就要收集符合要求的结果，这样才不会漏

class Solution:
    def back_track(self , nums ,index):
        if len(self.path[:]) >= 2:
            self.res.append(self.path[:])

        used = set()
        for i in range(index , len(nums)):
            if (self.path and nums[i] < self.path[-1]) or nums[i] in used:
                continue
            self.path.append(nums[i])
            used.add(nums[i])
            self.back_track(nums , i+1)
            self.path.pop()
        return self.res
            


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

LC 46 全排列

比较简单，used数组记录下用过的元素即可，for循环从0开始，和排列不一样

class Solution:
    def back_track(self, nums , used):
        if len(self.path) == len(nums):
            self.res.append(self.path[:])
        for i in range( 0 , len(nums)):
            if used[i] == 1:
                continue
            self.path.append(nums[i])
            used[i] = 1
            self.back_track(nums,used)
            self.path.pop()
            used[i] = 0
        return self.res
    def permute(self, nums: List[int]) -> List[List[int]]:
        self.path = []
        self.res = []
        return self.back_track(nums,[0]*len(nums))

LC 47 全排列Ⅱ

本题给我的启发：数层去重和树枝去重的逻辑都可以靠一个used数组来实现

class Solution:
    def back_track(self , nums , used):
        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 used[i-1] == 0) or used[i] == 1:
                continue
            self.path.append(nums[i])
            used[i] = 1
            self.back_track(nums , used)
            self.path.pop()
            used[i] = 0
        return self.res
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        self.path = []
        self.res = []
        used = [0] * len(nums)
        nums.sort()
        return self.back_track(nums, used)