代码随想录算法训练营第二十九天| LeetCode491. 递增子序列、LeetCode46. 全排列、LeetCode47. 全排列 II

最新推荐文章于 2024-11-07 23:24:07 发布

喵

最新推荐文章于 2024-11-07 23:24:07 发布

阅读量608

点赞数

分类专栏：算法训练营（LeetCode）文章标签：算法 leetcode python 回溯算法

本文链接：https://blog.csdn.net/weixin_48323589/article/details/127778802

版权

算法训练营（LeetCode）专栏收录该内容

52 篇文章 2 订阅

订阅专栏

一、LeetCode491. 递增子序列

1：题目描述（491. 递增子序列）

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

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

2：解题思路

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res = []
        path = []
        def division(nums, startindex):
            if len(path) >= 2:
                # 当path的长度大于等于2时，就将path加入到res中
                res.append(path[:])
            # 此递归函数，不需要终止条件
            # 当startindex=len(nums)时，下面的for循环不会执行，就直接返回了
            # 深度遍历中每一层都会有一个全新的used
            used = set()         # 用来记录本层递归中，已经被使用的元素的值
            for i in range(startindex, len(nums)):
                if (path and nums[i] < path[-1]) or nums[i] in used:
                    # 当path不为空，并且当前元素的值小于此时path中最后一个值时，不符合递增的条件
                    # 或者当前元素的值已经被使用过
                    # 说明有前一个元素已经把当前元素的所有组合都已遍历过了
                    # 所以直接进入下一个元素的遍历
                    continue
                path.append(nums[i])
                # 元素加入path后，元素下标在used中对应的元素值，需要修改为1
                used.add(nums[i])
                division(nums, i+1)
                # 回溯
                path.pop()
                # 因为used在每层递归中都有是一个全新的，跟path没有关系，所以path进行回溯时，跟used没关系
        division(nums, 0)
        return res

二、LeetCode46. 全排列

1：题目描述（46. 全排列）

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

2：解题思路

自己的写法：

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []
        path = []
        n = len(nums)
        def pathpermute(nums):
            if len(path) == n:
                # 当path的长度等于最开始的nums长度时，将path加入res中
                res.append(path[:])
                return
            for i in range(len(nums)):
                # 把元素加入path
                path.append(nums[i])
                # 用s来接收加入的这个元素，下一层递归的元素是除了当前元素，其他剩余的元素
                # 所以要把当前加入path的元素从数组中移除
                s = nums.pop(i)
                pathpermute(nums)
                # 回溯
                path.pop()
                # 需要将移除的元素，再加回到原来的位置
                nums.insert(i,s)
        pathpermute(nums)
        return res

代码随想录的写法：

class Solution:
    def __init__(self):
        self.res = []
        self.path = []
    
    def permute(self, nums: List[int]) -> List[List[int]]:
        used = [0] * len(nums)     # 用来记录nums中元素是否被使用
        self.backtracking(nums, used)
        return self.res

    def backtracking(self, nums, used):
        if len(self.path) == len(nums):
            # 当path的长度等于nums的长度时，加入res
            self.res.append(self.path[:])
            return
        for i in range(len(nums)):
            if used[i] == 1:
                # 如果当前元素在used对应下标的元素等于1，表示这个元素已经被使用过了
                continue
            # 将当前元素在used中对应下标的元素值修改为1，表示这个元素被使用了
            used[i] = 1
            self.path.append(nums[i])
            self.backtracking(nums, used)
            # 回溯
            used[i] = 0    
            self.path.pop()

三、LeetCode47. 全排列 II

1：题目描述（47. 全排列 II）

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

2：解题思路

自己的写法：

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res = []
        path = []
        n = len(nums)
        def permute(nums):
            if len(path) == n:
                # 当path的长度等于原nums的长度时，将path加入到res中
                res.append(path[:])
                return
            used = set()     # 每一层递归都会生成一个新的used，用来记录本层已经遍历过的元素
            for i in range(len(nums)):
                if nums[i] in used:
                    # 当遍历的元素，已经在这一层的used中出现过，说明元素的组合已经被覆盖了
                    # 继续遍历下一个元素
                    continue
                used.add(nums[i])    # 将当前元素加入到used，表示遍历过
                path.append(nums[i])
                s = nums.pop(i)      # 下一层遍历的是除当前元素外的其他元素，因此从nums中移除
                permute(nums)
                path.pop()           # 回溯
                nums.insert(i, s)    # 需要把移除的元素再加回来
        permute(nums)
        return res

代码随想录的写法：

class Solution:
    def __init__(self):
        self.res = []
        self.path = []

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        used = [0] * len(nums)  # 用来记录nums中对应下标的元素是否被使用过，0:未使用，1:使用过
        nums = sorted(nums)     # 先对nums进行排序
        self.backtracking(nums, used)
        return self.res

    def backtracking(self, nums, used):
        if len(self.path) == len(nums):
            # 当path的长度等于nums的长度时，将path加入res
            self.res.append(self.path[:])
            return
        # 因为时排列，所以i的每层递归都从0开始
        for i in range(len(nums)):
            if i > 0 and nums[i-1] == nums[i] and used[i-1] == 0:
                # 如果当前元素的值等于前一个元素的值，并且前一个元素没有被使用过
                # 说明前一个元素已经覆盖了当前元素的所有组合，就跳过这个元素
                continue
            if used[i] == 1:
                # 如果当前元素的下标在used中对应的值为1，说明在本层递归中，这个元素已经被使用过
                # 需要跳过这个元素，进入下一个元素的遍历
                continue
            used[i] = 1        # 元素被使用了，就将在used中对应的值修改为1
            self.path.append(nums[i])
            self.backtracking(nums, used)
            self.path.pop()    # 回溯
            used[i] = 0