代码随想录算法训练营第二十四天| 491.非递减子序列、46.全排列、47.全排列 ||

题目链接：491. 非递减子序列 - 力扣（LeetCode）

思路：主要是去重思路上的不同。1.先排序，再用used数组进行判断；2.不能进行排序，用set数组进行判断，如果数字在set中，则在同一层上存在重复

class Solution(object):
    def findSubsequences(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.result = []
        self.path = []
        startIndex = 0
        def backTracking(startIndex):
            if len(self.path) >= 2:
                self.result.append(self.path[:])

            uset = set()#这里每一轮backTracking时都会重新定义，清空
            for i in range(startIndex, len(nums)):
                if (self.path and nums[i] < self.path[-1]) or nums[i] in uset: #当nums[i] 比 self.path最后一个元素小的时候 表示不再递增
                # 这里存在不同的去重方式，因为之前都是先进行排序，然后去重，但是这里不能进行这样的去重；
                    continue
                uset.add(nums[i])#这个循环里都是同一个树层的add
                self.path.append(nums[i])
                backTracking(i+1)
                self.path.pop()

        backTracking(startIndex)
        return self.result

题目链接：46. 全排列 - 力扣（LeetCode）

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.result = []
        self.path = []
        self.used = [False] * len(nums)

        def backTracking():
            if len(self.path) == len(nums):
                self.result.append(self.path[:])
                return

            for i in range(len(nums)):
                if self.used[i] == True:
                    continue
                self.used[i] = True
                self.path.append(nums[i])
                backTracking()
                self.path.pop()
                self.used[i] = False

        backTracking()
        return self.result

题目链接：47. 全排列 II - 力扣（LeetCode）

class Solution(object):
    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """

        self.result = []
        self.path = []
        self.used = [False] * len(nums)
        nums.sort()
        def backTracking():
            if len(self.path) == len(nums):
                self.result.append(self.path[:])
                return

            for i in range(len(nums)):

                if self.used[i] == True:
                    continue

                if i > 0 and nums[i] == nums[i - 1] and self.used[i-1] == False:
                    continue

                self.used[i] = True
                self.path.append(nums[i])
                backTracking()
                self.path.pop()
                self.used[i] = False

        backTracking()
        return self.result