day25 代码随想录 | 非递减子序列 全排列

491 非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

这个题呢，要注意对题目的理解，还有对去重的理解。

leetcode给的示例比较简单，我们举一个不简单的，比如1,2,3,1,1

对于他的输出结果，应该是什么

一种错误的想法是1,2 1,3 2,3 123,这是错误的，第一个1可以跟后面的1配对得到1,1 和1,1,1

当我们第一个1跟后面的1配对了之后，那么后面的1就不能在进行组合了。

上面以4767为例做的树状图，还是去重，在同层的问题，同一父节点下，不能再重复使用相同元素。这就是去重的逻辑，那么我们如何执行这个判断逻辑呢

我们可以用一个set 来保存已经加入过的元素，后面如果继续遍历到，那么就直接跳过，这是对每一层而言，因此在进入for backtracking之前进行初始化，在for循环后面加，保证是在同一层！

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        path = []
        result = []
        self.backtracking(nums, 0, path, result)
        return result

    def backtracking(self, nums, startIndex, path, result):
        if len(path) > 1:
            result.append(path[:])

        uset = set()

        for i in range(startIndex, len(nums):
            if nums[i] in uset:
                continue
            if path and nums[i] < path[-1]:
                continue

            uset.add(nums[i])
            path.append(nums[i])
            self.backtracking(nums, i+1, path, result)
            path.pop()

全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

注意与组合的区别和联系，与组合的联系在于，我们都是取叶子节点。不同的在于，排列不需要startIndex,我每次选择的元素只要不包括我自身就可以了，横向遍历就是从0到len(nums)

class Solution:
    def permute(self, nums):
        path = []
        result = []
        self.backtracking(nums, path, result)
        return result

    def backtracking(self, nums, path, result):
        if len(path) == len(nums):
            result.append(path[:]

        for i in range(len(nums)):
            if nums[i] in path:
                continue
            path.append(nums[i])
            self.backtracking(nums, path, result)
            path.pop()

47 全排列II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

有重复元素，关键还是在如何去重，对于相同的元素，对于同层而言，必须去重。

之前在组合，因为有startIndex,我们可以根据startIndex去重

但是排列没有，我们需要将数字排序，然后使用维护一个used数组，来看是否去重不去重。

去重的树状示意图如上所示，跟组合很像。

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort() # 一定要排序
        path = []
        used = [0] * len(nums)
        result = []
        self.backtracking(self, nums, used, path, result)
        return result   

    def backtracking(self, nums, used, path, result):
        if len(path) == len(nums):
            result.append(path[:])

        for i in range(len(nums)):
            if i > 0 and used[i-1] == 0 and nums[i] == nums[i-1]:
                continue

            if used[i] == 1:
                continue

            used[i] = 1
            path.append(nums[i])
            self.backtracking(nums, used, path, result)
            used[i] = 0
            path.pop()