初学python的我开始Leetcode题10-1
提示：100道LeetCode热题10-1主要是回溯相关，包括四题：全排列、子集、电话号码的字母组合、组合总和。由于初学，所以我的代码部分仅供参考。
前言
下周是第十六周，然后是两周的期末周，所以马上会缺两周左右......
回溯算法和暴力枚举法都是解决组合、排列、子集等问题的常用方法，但它们在实现方式和效率上有显著的区别。
暴力枚举法是一种直接尝试所有可能情况的方法，直到找到所有符合条件的解。
特点：
-
简单直接：通过直接列举所有可能的组合、排列或子集来找到解。
-
时间复杂度高：对于较大的输入规模，暴力枚举法可能会非常慢，因为它尝试了所有可能的情况。
-
空间复杂度低：通常只需要存储当前的解和最终结果。
适用场景：
-
输入规模较小，所有可能情况数量不多时。
-
问题本身没有明显的剪枝空间，即很难通过某种方式减少需要尝试的情况。
回溯算法是一种通过试错来解决问题的算法，它尝试分步解决问题，如果发现当前路径不能得到有效解，则回退到上一步选择另一条路径继续尝试。
特点：
-
效率较高：通过剪枝（即在发现当前路径不可能产生有效解时提前终止该路径的探索），回溯算法可以避免尝试所有可能的情况，从而提高效率。
-
空间复杂度可能较高：需要递归调用，可能会占用较多的栈空间。
-
实现复杂度较高：需要设计递归函数和回溯逻辑，实现相对复杂。
适用场景：
-
输入规模较大，但问题本身有剪枝空间。
-
需要找到所有可能的解，而不仅仅是一个解。
提示：以下是本篇文章正文内容，下面结果代码仅供参考
题目1：全排列
1.题目要求：
题目如下：
给定一个不含重复数字的数组
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]]提示：
1 <= nums.length <= 6-10 <= nums[i] <= 10nums中的所有整数 互不相同
代码框架已经提供如下：
class Solution(object):
def permute(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
2.结果代码：
class Solution(object):def permute(self, nums):n=len(nums)res=[]def backtrack(path,used):if len(path)==len(used):res.append(path[:])returnfor i in range(len(used)):if not used[i]:used[i]=Truepath.append(nums[i]) backtrack(path,used)path.pop()used[i]=Falseused=[False]*len(nums)backtrack([],used)return res说明：
-
初始化变量：
-
n：数组nums的长度。 -
res：用于存储所有生成的排列。
-
-
定义递归函数
backtrack：-
path：当前路径，即当前生成的排列。 -
used：一个布尔数组，用于标记哪些数字已经被使用。
-
-
终止条件：
-
当
path的长度等于nums的长度时，说明已经生成了一个完整的排列，将其添加到结果列表res中。
-
-
递归过程：
-
遍历
used数组，找到未被使用的数字。 -
将找到的数字添加到
path中，并标记为已使用。 -
递归调用
backtrack，传入更新后的path和used。 -
回溯：在递归返回后，将当前选择的数字从
path中移除，并标记为未使用，以便尝试下一个数字。
-
-
初始化
used数组：-
用于标记哪些数字已经被使用。
-
-
调用
backtrack函数：-
从空路径和所有数字未被使用开始递归。
-
因为对于每个数字有 n 种选择，总共有 n! 种排列。
因为递归调用的深度最多为 n。
题目2：子集
1.题目要求：
题目如下：
给你一个整数数组
nums，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]示例 2：
输入：nums = [0] 输出：[[],[0]]提示：
1 <= nums.length <= 10-10 <= nums[i] <= 10nums中的所有元素 互不相同
代码框架已经提供如下：
class Solution(object):
def subsets(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
2.结果代码：
class Solution(object):def subsets(self, nums):""":type nums: List[int]:rtype: List[List[int]]"""def backtrack(start, path):# 将当前路径添加到结果列表中results.append(path[:])# 遍历从 start 开始的所有元素for i in range(start, len(nums)):# 选择当前元素path.append(nums[i])# 递归调用 backtrackbacktrack(i + 1, path)# 回溯：移除当前元素path.pop()results = []backtrack(0, [])return results说明：
-
定义递归函数
backtrack：-
start：当前递归的起始位置。 -
path：当前路径，即当前生成的子集。
-
-
终止条件：
-
当
path被添加到结果列表results中时，说明已经生成了一个完整的子集。
-
-
递归过程：
-
从
start开始遍历所有元素，找到未被选择的元素。 -
将找到的元素添加到
path中，并标记为已选择。 -
递归调用
backtrack，传入更新后的start和path。 -
回溯：在递归返回后，将当前选择的元素从
path中移除，并标记为未选择，以便尝试下一个元素。
-
-
初始化结果列表
results：-
用于存储所有生成的子集。
-
-
调用
backtrack函数：-
从起始位置 0 和空路径开始递归。
-
因为对于每个元素，有 2 种选择（选择或不选择），总共有 2n 个子集。
因为递归调用的深度最多为 n。
题目3：电话号码的字母组合
1.题目要求：
题目如下：
给定一个仅包含数字
2-9的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]示例 2：
输入：digits = "" 输出：[]示例 3：
输入：digits = "2" 输出：["a","b","c"]提示：
0 <= digits.length <= 4digits[i]是范围['2', '9']的一个数字。
代码框架已经提供如下：
class Solution(object):
def letterCombinations(self, digits):
"""
:type digits: str
:rtype: List[str]
"""
2.结果代码：
class Solution(object):def letterCombinations(self, digits):""":type digits: str:rtype: List[str]"""if not digits:return []# 定义数字到字母的映射phone_map = {'2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl','6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz'}def backtrack(index, path):# 终止条件：如果当前路径长度等于 digits 的长度，说明已经生成了一个完整的组合if index == len(digits):combinations.append("".join(path))return# 获取当前数字对应的所有可能字母possible_letters = phone_map[digits[index]]for letter in possible_letters:# 选择当前字母path.append(letter)# 递归调用 backtrackbacktrack(index + 1, path)# 回溯：移除当前字母path.pop()combinations = []backtrack(0, [])return combinations说明：
-
定义递归函数
backtrack：-
index：当前递归的索引位置。 -
path：当前路径，即当前生成的字母组合。
-
-
终止条件：
-
当
index等于digits的长度时，说明已经生成了一个完整的字母组合，将其添加到结果列表combinations中。
-
-
递归过程：
-
获取当前数字对应的所有可能字母。
-
遍历所有可能的字母，将其添加到
path中，并标记为已选择。 -
递归调用
backtrack，传入更新后的index和path。 -
回溯：在递归返回后，将当前选择的字母从
path中移除，并标记为未选择，以便尝试下一个字母。
-
-
初始化结果列表
combinations：-
用于存储所有生成的字母组合。
-
-
调用
backtrack函数：-
从索引位置 0 和空路径开始递归。
-
题目4：组合总和
1.题目要求：
题目如下：
给你一个 无重复元素 的整数数组
candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为
target的不同组合数少于150个。示例 1：
输入：candidates =[2,3,6,7], target =7输出：[[2,2,3],[7]] 解释： 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。 仅有这两种组合。示例 2：
输入: candidates = [2,3,5],target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]]示例 3：
输入: candidates =[2],target = 1 输出: []提示：
1 <= candidates.length <= 302 <= candidates[i] <= 40candidates的所有元素 互不相同1 <= target <= 40
代码框架已经提供如下：
class Solution(object):
def combinationSum(self, candidates, target):
"""
:type candidates: List[int]
:type target: int
:rtype: List[List[int]]
"""
2.结果代码：
class Solution(object):def combinationSum(self, candidates, target):""":type candidates: List[int]:type target: int:rtype: List[List[int]]"""def backtrack(remaining, path, start):if remaining == 0:results.append(path[:])returnfor i in range(start, len(candidates)):if candidates[i] > remaining:breakpath.append(candidates[i])backtrack(remaining - candidates[i], path, i)path.pop()results = []candidates.sort() # 排序可以避免重复组合backtrack(target, [], 0)return results说明：
-
定义递归函数
backtrack：-
remaining：剩余需要找到的和。 -
path：当前路径，即当前生成的组合。 -
start：当前递归的起始位置，用于避免重复使用同一个数字。
-
-
终止条件：
-
当
remaining等于 0 时，说明已经找到了一个有效的组合，将其添加到结果列表results中。
-
-
递归过程：
-
从
start开始遍历所有元素，找到可以添加到当前组合中的数字。 -
将找到的数字添加到
path中，并递归调用backtrack，传入更新后的remaining和path。 -
回溯：在递归返回后，将当前选择的数字从
path中移除，以便尝试下一个数字。
-
-
初始化结果列表
results：-
用于存储所有生成的组合。
-
-
调用
backtrack函数：-
从剩余和
target和空路径开始递归。
-
-
排序：
-
对
candidates进行排序，可以避免重复组合。
-
总结
针对回溯的四种题型进行了学习，了解了部分有关回溯与python的相关知识，大家加油！