Suzy加油吧 Day 29 | 回溯算法进行中：491. 递增子序列，46 全排列，47 全排列2

491. 递增子序列（新 & 难）

呜呜呜呜呜

题目

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

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

solution

1. 这道题不能排序，所以不能用之前的去重used数组的方法
2. 并且used数组不能作为全局变量，必须在每一层都要清空

class Solution:
    def __init__(self):
        self.res=[]
        self.path=[]
    # 不能用used数组，因为本题不能排序
    # used数组不能设置为全局变量 因为used只记录当前层的使用记录
    def backtracking(self,nums,startindex):
        if len(self.path)>=2:
            self.res.append(self.path[:])
        used=set([]) # 每层都更新为空
        for i in range(startindex,len(nums)):
            if (self.path and nums[i]<self.path[-1]) or (nums[i] in used):continue
            used.add(nums[i])
            self.path.append(nums[i])
            self.backtracking(nums,i+1)
            self.path.pop()
        return
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        #used=[0]*len(nums)
        self.backtracking(nums,0)
        return self.res

46 全排列

solution

class Solution:
    def __init__(self):
        self.res=[]
        self.path=[]
    def backtracking(self,nums):
        print(nums)
        if len(self.path)==len(nums):
            self.res.append(self.path[:])
            return
        for i in range(0,len(nums)):
            if nums[i] in self.path:continue
            self.path.append(nums[i])
            self.backtracking(nums)
            self.path.pop()
        return
    def permute(self, nums: List[int]) -> List[List[int]]:
        targetlen=len(nums)
        self.backtracking(nums)
        return self.res

呜呜呜

if nums[i] in self.path:continue
这一句就是把已经放进path里的跳过！可以用in判断是否在数组中！
不要操作nums，比如去掉某个元素，这样容易出错！lzx对于python里的拷贝很不在行！躲避！

47 全排列2

hard for me

集合中有重复元素了！我不会去重！

solution

我把它想复杂了，可以先排列，然后用used数组的方法，不需要用set

class Solution:
    def __init__(self):
        self.res=[]
        self.path=[]
    def backtracking(self,nums,used):
        #print(self.res,self.path)
        if len(self.path)==len(nums):
            self.res.append(self.path.copy())
            return
        for i in range(0,len(nums)):
            print(nums[i])
            if (nums[i]==nums[i-1] and i>=1) and used[i-1]==0:continue
            if used[i]==1:continue
            used[i]=1
            self.path.append(nums[i])
            self.backtracking(nums,used)
            used[i]=0
            self.path.pop()
        return 
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        used=[0]*len(nums)
        self.backtracking(nums,used)
        return self.res