代码随想录回溯Ⅴ

491. 递增子序列

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

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

思路：跟子集Ⅱ一样，只是多了判断是否递增的条件，以及不能使用sort和startindex的组合来去重。

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        path = []
        ans = []
        self.backtracking(ans, path, 0, nums)
        return ans
    
    def backtracking(self,ans,path,startindex,nums):
        if len(path) > 1:  # add contidition
            ans.append(path[:])

        used = set()  # Record the used number
        for i in range(startindex, len(nums)):
            if (path and nums[i] < path[-1]) or nums[i] in used:
                continue

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

46. 全排列

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

思路：排列与集合不同的地方：不需要startindex来指定开始，统一由nums[0]开始遍历。由于没有startindex，所以需要used数组来记录用过的数字。

class Solution:
    
    def permute(self, nums: List[int]) -> List[List[int]]:
        ans = []
        path = []
        used = [False for _ in range(len(nums))]
        self.backtracking(ans, path, nums, used)
        return ans

    def backtracking(self, ans, path, nums, used):
        # base condition
        if len(path) == len(nums):
            ans.append(path[:])
            return 
        
        for i in range(0, len(nums)):
            if used[i]:
                continue
            
            used[i] = True
            path.append(nums[i])
            self.backtracking(ans, path,nums,used)
            path.pop()
            used[i] = False

 

47. 全排列 II

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

思路：在全排列1的基础上，先排序，然后添加continue的条件，不仅used[i]需要continue，当i > 0,nums[i] 与nums[i-1]相同且used[i-1] 为false时，也需要continue

class Solution:
    def permuteUnique(self, nums):
        nums.sort()  
        result = []
        self.backtracking(nums, [], [False] * len(nums), result)
        return result

    def backtracking(self, nums, path, used, result):
        if len(path) == len(nums):
            result.append(path[:])
            return
        for i in range(len(nums)):
            if (i > 0 and nums[i] == nums[i - 1] and not used[i - 1]) or used[i]:
                continue
            used[i] = True
            path.append(nums[i])
            self.backtracking(nums, path, used, result)
            path.pop()
            used[i] = False