力扣回溯算法思路及例题

最新推荐文章于 2024-05-19 10:59:18 发布

BENOwaxgourd

最新推荐文章于 2024-05-19 10:59:18 发布

阅读量320

点赞数 2

分类专栏：学习笔记文章标签： leetcode python 数据结构算法

本文链接：https://blog.csdn.net/bwaxg/article/details/115304024

版权

学习笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

回溯算法

应用题目类型

枚举，排列组合

算法思想

回溯算法的三要素：

1.有效结果：什么时候这算是一个答案，应该被加入到答案列表里
2.回溯的范围：我们下一个维度要考虑如何将当前层的答案和上一层的答案结合，并继续递归
3.剪枝条件：是不是存在某些情况遇到了之后就不需要再处理了

伪代码：

backtrack的公式：
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return  
   for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

例题

以下例题均来自于力扣

78. 子集

题目：

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

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

示例 2：

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

代码：

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        n = len(nums)
        
        def helper(i, tmp):
            res.append(tmp)
            for j in range(i, n):
                helper(j + 1,tmp + [nums[j]] )
        helper(0, [])
        return res

90. 子集 II

题目：

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：
	解集不能包含重复的子集。

示例：

输入: [1,2,2]
输出:
[ [2], [1], [1,2,2], [2,2], [1,2], [] ]

代码：

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        if not nums:
            return []
        n = len(nums)
        res = []
        nums.sort()

        def helper(idx, n, temp_list):
            if temp_list not in res:
                res.append(temp_list)
            for i in range(idx, n):
                helper(i + 1, n, temp_list + [nums[i]])
        helper(0, n, [])
        return res

46. 全排列

题目：

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例：

输入: [1,2,3]
输出:
[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

代码：

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def backtrack(nums,tmp):
            if not nums:
                res.append(tmp)
                return  
            for i in range(len(nums)):
                backtrack(nums[:i] + nums[i+1:], tmp + [nums[i]])

        res=[]
        backtrack(nums,[])
        return res

47. 全排列 II

题目：

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

示例 1：

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

示例 2：

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

代码：

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

        def backtrace(partial, choices):
            if not choices:
                res.append(partial)
            for choice in set(choices):
                idx = choices.index(choice)
                backtrace(partial + [choice], choices[:idx] + choices[idx+1:])

        backtrace([], nums)
        return res

39. 组合总和

题目：

给定一个无重复元素的数组 candidates 和一个目标数 target
找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。

说明：
	所有数字（包括 target）都是正整数。
	解集不能包含重复的组合

示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[ [7], [2,2,3] ]

示例 2：

输入：candidates = [2,3,5], target = 8,
所求解集为：
[ [2,2,2,2], [2,3,3], [3,5] ]

代码：

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:

        candidates.sort()
        res = []

        def backtrack(candidates, target, tmp):
            if target == 0:
                res.append(tmp)
            if target < 0:
                return
            for i in range(len(candidates)):
                if candidates[i] > target:
                    break
                backtrack(candidates[i:], target - candidates[i], tmp + [candidates[i]])
        backtrack(candidates,target,[])
        return res

40. 组合总和 II

题目：

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。

说明：
	所有数字（包括目标数）都是正整数。
	解集不能包含重复的组合。

示例 1：

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]

示例 2：

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[ [1,2,2], [5] ]

代码：

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        n = len(candidates)
        res = []
        
        def backtrack(i, tmp):
            if sum(tmp) == target:
                res.append(tmp)
                return 
            for j in range(i, n):
                if sum(tmp) + candidates[j]  > target : break
                if j > i and candidates[j] == candidates[j-1]:continue
                backtrack(j + 1, tmp + [candidates[j]])
        backtrack(0, [])    
        return res