求职刷题力扣 DAY28---回溯算法

DAY 28

1. 491. 非递减子序列

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

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

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

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

注意要点

3个条件

1. used_set 同层递归去重
2. nums[i] >= path[-1] 满足升序条件
3. len(path) >= 2 满足元素个数不小于二的条件

代码实现

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res, path = [], []

        def recur(start_index: int):
            if start_index >= len(nums):
                return
            used_set = set()
            for i in range(start_index, len(nums)):
                if nums[i] in used_set:
                    continue
                if not path or nums[i] >= path[-1]:
                    path.append(nums[i])
                    if len(path) >= 2:
                        res.append(path[:])
                    recur(i + 1)
                    path.pop()
                    used_set.add(nums[i])
        recur(0)
        return res

2. 46. 全排列

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

示例 1：

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

示例 2：

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

示例 3：

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

注意

这个全排列和组合问题的区别在于不用加上start_index，需要使用visted_set来跳过已经加入的元素。

另外这个只需要包含了所有元素的全排列，如果需要每个长度元素的全排列，只需要改变res.append(path[:])的位置在path.append(nums[i]) 之后就行了（针对不包含重复元素的数组）

如果数组还包含了重复元素，那么就需要sorted()，同时同层元素不等了

代码实现

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res, path = [], []
        used_set = set()
        #还是for循环的写法，只不过这次不需要start_index，需要一个visited的数组来记录
        def back_track(cur_nums):
            if cur_nums >= len(nums):
                res.append(path[:])
                return
            for i in range(len(nums)):
                if i in used_set:
                    continue
                used_set.add(i)
                # set 找元素的复杂度是O(1)
                path.append(nums[i])
                back_track(cur_nums + 1)
                used_set.remove(i)
                path.pop()
            
        back_track(0)
        return res

3. 全排列-all

给定一个包含重复元素的nums 列表， 给出其中所有子集的全排列

掌握这个，就掌握了全排列

注意：

1. 两个去重点，used_list 用于针对全排列的去重，i > 0 and nums[i] == nums[i-1] and nums[i-1] not used用于去重全排列中的重复元素（nums需要sorted）

代码实现

from typing import List
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res, path = [[]], []
        nums = sorted(nums)
        used_lst = [0] * len(nums)
        #还是for循环的写法，只不过这次不需要start_index，需要一个visited的数组来记录
        def back_track(cur_nums):
            if cur_nums >= len(nums):
                return
            for i in range(len(nums)):
                if used_lst[i]:
                    continue
                if i > cur_nums and nums[i] == nums[i-1] and not used_lst[i-1]:
                    # print(path, cur_nums, nums[i], nums[i-1], "i", i, i-1)
                    continue
                used_lst[i] = 1
                # set 找元素的复杂度是O(1)
                path.append(nums[i])
                res.append(path[:])
                back_track(cur_nums + 1)
                used_lst[i] = 0
                path.pop()
            
        back_track(0)
        return res