回溯基础
回溯的本质是枚举，穷举所有可能找到答案。和递归一样有三点需要注意： 1 回溯函数的参数
2 终止条件
3 单层的处理逻辑
记住下面的模板~
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
77. 组合
题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
输入： n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
示例 2：
输入： n = 1, k = 1
输出： [[1]]
提示：
1 <= n <= 201 <= k <= n
解题思路
定义：backtrack参除了n和k，还需要start，避免重复枚举元素。 终止条件：track的长度和k相同 单层搜索：从start到n进行横向遍历，然后使用backtrack递归纵向遍历。
剪枝：只遍历[start,end = n-(k-len(self.track))+1]范围内的元素，后面的元素凑不满k个了。
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
self.result = [] # 所有结果集
self.track = [] # 当前路径
self.backtrack(n, k , 1) # [1,n]
return self.result
def backtrack(self, n: int, k: int, start:int) -> None:
# 结束条件
if len(self.track) == k:
# self.result.append(self.track)
self.result.append(self.track[:]) # 使用切片创建副本
return
# 单层搜索
# for i in range(start, n+1): # start避免重复
end = n-(k-len(self.track))+1
for i in range(start,end+1): # start避免重复
self.track.append(i)
self.backtrack(n, k, i+1) # i为1时，子集从2开始
self.track.pop()
总结
注意track需要用切片来创建一份副本，然后放入答案，否则track会被修改，最终答案都是空的。
剪枝的n-(k-len(track))+1表示：k-len(track)是还缺的元素，在集合n中至多要从该起始位置 : n - (k - len(track)) + 1开始遍历，+1是因为包含倒数第k-len(track)个。
216. 组合总和 III
题目：找出所有相加之和为 n **的 k ****个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。
示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释: 1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。
示例 3:
输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。
提示:
2 <= k <= 91 <= n <= 60
解题思路
定义：backtrack参数start避免重复枚举元素，sum_val用于剪枝（当前和>target,不需要再加元素了）。 终止条件：track的长度和k相同，并且和为target 单层搜索：从start到9进行横向遍历，然后使用backtrack递归纵向遍历。
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
class Solution:
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
self.result = []
self.track = []
self.backtrack(k, n, 1, 0)
return self.result
def backtrack(self, k:int, target:int, start:int, sum_val: int): # 遍历的数字，开始位置
if len(self.track) == k and sum_val == target:
self.result.append(self.track[:])
return
if sum_val > target:
return
# 单层搜索
end = 9 - (k-len(self.track)) + 1
# for i in range(start, 10):
for i in range(start, end + 1):
sum_val += i
self.track.append(i)
self.backtrack(k, target, i+1, sum_val)
sum_val -= i
self.track.pop()
总结
17. 电话号码的字母组合
题目：给定一个仅包含数字 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']的一个数字。
解题思路
1 定义，backtrack(digits, index)，处理digits[index]数字
2 终止条件：len(track)==len(digits)
3 单层搜索：对于digits[index]，遍历digits[index]对应的所有字符，然后再遍历下个数字
- 时间复杂度: O(3^m * 4^n)，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数
- 空间复杂度: O(3^m * 4^n)
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
if not digits:
return []
# 数字到字母的映射
self.phone_map = {
'2': 'abc',
'3': 'def',
'4': 'ghi',
'5': 'jkl',
'6': 'mno',
'7': 'pqrs',
'8': 'tuv',
'9': 'wxyz'
}
self.result = []
self.track = []
self.backtrack(digits, 0)
return self.result
def backtrack(self,digits: str, index: int) -> None:
if len(digits) == len(self.track):
self.result.append("".join(self.track))
return
letters = self.phone_map[digits[index]]
for c in letters:
self.track.append(c)
self.backtrack(digits, index+1)
self.track.pop()
总结
我们通过递归地构建所有可能的字母组合，并在构建过程中剪枝，避免了无效的计算。这种方法虽然在最坏情况下可能会产生大量的组合，但它能够保证找到所有可能的解。
