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

491.递增子序列

leetcode 491.递增子序列
代码随想录

class Solution:
    def __init__(self):
        self.pathSet = set()
    def backtracing(self, nums, res, path, startIndex, used):
        if len(path) >= 2:
            temp = tuple(path)
            if temp not in self.pathSet:
                self.pathSet.add(temp)
                res.append(path[:])
        if startIndex >= len(nums):
            return
        for i in range(startIndex, len(nums)):
            if len(path) == 0:
                path.append(nums[i])
            else:
                if nums[i] >= path[-1]:
                    path.append(nums[i])
                else:
                    continue
            # if i > startIndex and nums[i] == nums[i-1] and not used[i]:
            #     continue
            used[i] == True
            self.backtracing(nums, res, path, i+1, used)
            used[i] == False
            path.pop()
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        # 是序列本身存不存在递增（不能对其进行排序）
        # 如何判断递增，当前的元素比path里面的元素大（等）就行了
        # 现在可以找出所有的了，接下来需要去重（还是同一层不可以）,但很难判断，它本身不是递增数组hhh（所以就改用set去重了）
        res = []
        used = [False] * len(nums)
        self.backtracing(nums, res, [], 0, used)
        return res

46.全排列

leetcode 46.全排列
代码随想录

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

47.全排列 II

leetcode 47.全排列 II
代码随想录

class Solution:
    def __init__(self):
        self.pathSet = set()
    def backtracking(self, nums, res, path, used):
        if len(path) == len(nums):
            temp = tuple(path)
            if temp not in self.pathSet:
                self.pathSet.add(temp)
                res.append(path[:])
        for i in range(len(nums)):
            if used[i]:
                continue
            if i > 0 and nums[i] == nums[i-1] and not used[i-1]: # 排好序的之后就可以用这个
                continue
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums, res, path, used)
            used[i] = False
            path.pop()
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        used = [False] * len(nums)
        self.backtracking(nums, res, [], used)
        return res