回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案。
组合/切割/子集/排列/棋盘
1、回溯函数返回值和参数：一般为void
2、终止条件：一般到叶子节点终止
3、回溯的遍历过程：集合的大小树的宽度，递归的深度构成树的深度。
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}------------------------------------
(1) 77 组合
(2) 216 组合总和3
(3) 17 电话号码的字母组合
(4) 39 组合总和
(5) 40 组合总和2
------------------------------------
一、组合
1、77 组合
77. 组合 - 力扣（LeetCode）
题目描述：给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
------------ python -------------
未剪枝优化
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
result = [] # 存放结果集
self.backtracking(n, k, 1, [], result)
return result
def backtracking(self, n, k, startIndex, path, result):
if len(path) == k:
result.append(path[:])
return
for i in range(startIndex, n + 1): # 需要优化的地方
path.append(i) # 处理节点
self.backtracking(n, k, i + 1, path, result)
path.pop() # 回溯，撤销处理的节点剪枝优化
class Solution:
def backtracing(self,n,k,index,path,result):
if len(path)==k:
result.append(path[:]) # 这里要[:]拷贝当前路径（切片操作），不然后面的操作会更改path path最后输出的都会是[]
# result.append(path)是对path的引用，path.pop()会改变结果
return
for i in range(index,n-(k-len(path))+2):
path.append(i)
self.backtracing(n,k,i+1,path,result)
path.pop()
def combine(self, n: int, k: int) -> List[List[int]]:
result=[]
self.backtracing(n,k,1,[],result)
return result2、216 组合总和3
216. 组合总和 III - 力扣（LeetCode）
题目描述：找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
------------ python -------------
class Solution:
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
result = [] # 存放结果集
self.backtracking(n, k, 0, 1, [], result)
return result
def backtracking(self, targetSum, k, currentSum, startIndex, path, result):
if currentSum > targetSum: # 剪枝操作
return # 如果path的长度等于k但currentSum不等于targetSum，则直接返回
if len(path) == k:
if currentSum == targetSum:
result.append(path[:])
return
for i in range(startIndex, 9 - (k - len(path)) + 2): # 剪枝
currentSum += i # 处理
path.append(i) # 处理
self.backtracking(targetSum, k, currentSum, i + 1, path, result) # 注意i+1调整startIndex
currentSum -= i # 回溯
path.pop() # 回溯3、17 电话号码的字母组合
17. 电话号码的字母组合 - 力扣（LeetCode）
题目描述：给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
Tips：对于组合问题如果是一个集合求组合，就需要startindex，如果是多个集合取组合，就不用startindex。
------------ python -------------
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
if not digits:
return list()
#如果 digits(s) 是一个空列表 []，那么 ''.join(digits) 会返回一个 空字符串 ""。
s=[]
result=[]
phoneMap = {
"2": "abc",
"3": "def",
"4": "ghi",
"5": "jkl",
"6": "mno",
"7": "pqrs",
"8": "tuv",
"9": "wxyz",
}
def backtracing(index):
if index==len(digits):
result.append("".join(s))
return
digit=digits[index]
for i in phoneMap[digit]:
# s+=i python中字符串不可以修改，但是列表可以pop()
s.append(i)
backtracing(index+1)
s.pop()
backtracing(0)
return result4、39 组合总和
39. 组合总和 - 力扣（LeetCode）
题目描述：给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
------------ python -------------
未剪枝
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
result=[]
def backtracing(candidates,target,total,startindex,path,result):
if total>target:
return
if total==target:
result.append(path[:])
return
for i in range(startindex,len(candidates)):
total+=candidates[i]
path.append(candidates[i])
backtracing(candidates,target,total,i,path,result)
total-=candidates[i]
path.pop()
backtracing(candidates,target,0,0,[],result)
return result
return result剪枝后
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
result=[]
def backtracing(candidates,target,total,startindex,path,result):
if total==target:
result.append(path[:])
return
# 如果 sum + candidates[i] > target 就终止遍历
for i in range(startindex,len(candidates)):
if total+candidates[i]>target:
break #剪枝
total+=candidates[i]
path.append(candidates[i])
backtracing(candidates,target,total,i,path,result)
total-=candidates[i]
path.pop()
candidates.sort() #需要排序
backtracing(candidates,target,0,0,[],result)
return result5、40 组合总和2
40. 组合总和 II - 力扣（LeetCode）
题目描述：给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次。
------------ python -------------
class Solution:
def backtracking(self, candidates, target, total, startIndex, path, result):
if total == target:
result.append(path[:])
return
for i in range(startIndex, len(candidates)):
if i > startIndex and candidates[i] == candidates[i - 1]:
continue
if total + candidates[i] > target:
break
total += candidates[i]
path.append(candidates[i])
self.backtracking(candidates, target, total, i + 1, path, result)
total -= candidates[i]
path.pop()
def combinationSum2(self, candidates, target):
result = []
candidates.sort()
self.backtracking(candidates, target, 0, 0, [], result)
return result