刷题第二十四天 491. 递增子序列 46. 全排列 47.全排列Ⅱ

491. 递增子序列

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

        def back_tracking(result, subset, nums, start_index):
            if len(subset) >= 2 and subset not in result:
                result.append(subset.copy())
            for i in range(start_index, len(nums)):
                if subset and nums[i] < subset[-1]:
                    continue
                subset.append(nums[i])
                back_tracking(result, subset, nums, i + 1)
                subset.pop()
        
        result = []
        subset = []
        start_index = 0
        back_tracking(result, subset, nums, start_index)
        return result

主要是去重的思想，和子集的想法类似，但是这里给出的数组不是有序的，不能改变顺序

看了视频之后理解了树层去重，用到uset，每层循环开始之前定义一个uset来记录每层用过的元素，如果新元素出现过了，那就continue

46. 全排列

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

        def back_tracking(result, subset, nums):
            if len(subset) == len(nums):
                result.append(subset.copy())
                return
            for i in range(0, len(nums)):
                if nums[i] in subset:
                    continue
                subset.append(nums[i])
                back_tracking(result, subset, nums)
                subset.pop()
        result = []
        subset = []
        back_tracking(result, subset, nums)
        return result

判断一下是否已经用过该元素就可以了

47. 全排列Ⅱ

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:

        def back_tracking(result, subset, nums):
            if len(subset) == len(nums):
                result.append(subset.copy())
                return
            for i in range(0, len(nums)):
                if used[i] == 1:
                    continue
                if i > 0 and nums[i] == nums[i - 1] and used[i - 1] == 0:
                    continue
                subset.append(nums[i])
                used[i] = 1
                back_tracking(result, subset, nums)
                subset.pop()
                used[i] = 0
        result = []
        subset = []
        nums.sort()
        used = [0] * len(nums)
        back_tracking(result, subset, nums)
        return result

和之前的去重方法类似，这次是树枝去重，因为结果都是在树枝上收获的，两个逻辑，因为是全排列，所以所有的元素都会用上，如果新的元素已经被用过了，那就直接continue；另外一点就是如果i>0，说明在水平的树层，然后碰到相等的值，并且是头叶子，那么直接continue。