回溯基础
基础、组合、组合综合问题的题解参考
参考https://editor.csdn.net/md/?articleId=121913091
77. 组合
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
path = []
res = []
def backtracking(n, k, startindex):
# 说明收集个数达到了
if k == len(path):
#加入结果
res.append(path[:])
return
#
for i in range(startindex,n - (k - len(path)) + 2): #优化的地方 剪枝
path.append(i) #处理节点
backtracking(n, k, i + 1)#递归 下一个开始地方从i的后一位开始
path.pop()# 回溯 撤销处理的节点
backtracking(n, k, 1)
return res
216.组合总和III
class Solution:
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
path = []
res = []
def backtracking(k, targetsum, sum, startindex):
# 如果sum已经超过tarfetsum 就不用往下找了
if sum > targetsum:
return
if k == len(path):
#加入结果
if sum == targetsum:
res.append(path[:])
# 如果path长度==k 但sum != targetSum 直接返回
return
for i in range(startindex,9 - (k - len(path)) + 2): #优化的地方 剪枝
sum += i #处理节点
path.append(i) #处理节点
backtracking(k, n, sum, i + 1)# 递归, i+1调整startIndex 因为每个数用一次
sum -= i# 回溯
path.pop()# 回溯 撤销处理的节点
backtracking(k, n, 0, 1)
return res
17. 电话号码的字母组合
思路:
参考https://www.programmercarl.com/0017.%E7%94%B5%E8%AF%9D%E5%8F%B7%E7%A0%81%E7%9A%84%E5%AD%97%E6%AF%8D%E7%BB%84%E5%90%88.html#%E5%9B%9E%E6%BA%AF%E6%B3%95%E6%9D%A5%E8%A7%A3%E5%86%B3n%E4%B8%AAfor%E5%BE%AA%E7%8E%AF%E7%9A%84%E9%97%AE%E9%A2%98
数字和字母如何映射?map映射
两个字母就两个for循环,三个字符我就三个for循环,以此类推,然后发现代码根本写不出来?回溯
输入1 * #按键等等异常情况?map对应
回溯三部曲:
- 确定回溯函数参数
这个index是记录遍历第几个数字了,就是用来遍历digits的(题目中给出数字字符串),同时index也表示树的深度。
vector<string> result;
string s;
void backtracking(const string& digits, int index)
- 确定终止条件
例如输入用例"23",两个数字,那么根节点往下递归两层就可以了,叶子节点就是要收集的结果集。
那么终止条件就是如果index 等于 输入的数字个数(digits.size)了(本来index就是用来遍历digits的)。
然后收集结果,结束本层递归。
if (index == digits.size()) {
result.push_back(s);
return;
}
- 确定单层遍历逻辑
首先要取index指向的数字,并找到对应的字符集(手机键盘的字符集)。
int digit = digits[index] - '0'; // 将index指向的数字转为int
string letters = letterMap[digit]; // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
s.push_back(letters[i]); // 处理
backtracking(digits, index + 1); // 递归,注意index+1,一下层要处理下一个数字了
s.pop_back(); // 回溯
}
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
# map来用数字和字母映射
map ={
'2': 'abc',
'3': 'def',
'4': 'ghi',
'5': 'jkl',
'6': 'mno',
'7': 'pqrs',
'8': 'tuv',
'9': 'wxyz'
}
res = []
path = ''
# 这个index是记录遍历digits第几个数字了,就是用来遍历digits的(题目中给出数字字符串),同时index也表示树的深度,第几层
def backtracking(digits,index):
# 在嵌套函数中用nonlocal 使用外部变量
nonlocal path
# 当遍历的深度index等于digits长度
if index == len(digits):
res.append(path)
return
# 判断是哪一层的字母 比如'23'种的 digits[0]为'2' 再到map中找
letters = map[digits[index]]
for le in letters:
path += le # 处理
backtracking(digits,index + 1)# index+1 处理下一层递归 处理digits的下一个数
path = path[:-1] #回溯 把最后一个字母去掉 因为-1达不到
if digits =='':
return []
backtracking(digits,0)
return res
39. 组合总和
思路:
本题还需要startIndex来控制for循环的起始位置,对于组合问题,什么时候需要startIndex呢?
如果是一个集合
来求组合的话,就需要startIndex,例如:77.组合 (opens new window),216.组合总和III (opens new window)。
如果是多个集合
取组合,各个集合之间相互不影响,那么就不用startIndex,例如:17.电话号码的字母组合
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
path = []
res = []
def backtracking(candidates, target, sum, startindex):
# 剪枝部分
if sum > target:
return
if sum == target:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
sum += candidates[i]
path.append(candidates[i])
backtracking(candidates, target, sum, i)# 这里下一次开始的地方还可以是i 因为可以重复使用
sum -= candidates[i]
path.pop()
backtracking(candidates,target, 0, 0)
return res
for循环内剪枝,提前排序
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
path = []
res = []
# 剪枝需要提前排序
candidates.sort()
def backtracking(candidates, target, sum, startindex):
if sum == target:
res.append(path[:])# 浅拷贝所以不能直接添path
return
for i in range(startindex, len(candidates)):
# 如果本层 sum + condidates[i] > target,就提前结束遍历,没必要进行下一层的回溯,剪枝
if sum + candidates[i] > target:
return
sum += candidates[i]
path.append(candidates[i])
backtracking(candidates, target, sum, i)# 这里下一次开始的地方还可以是i 因为可以重复使用
sum -= candidates[i]
path.pop()
backtracking(candidates,target, 0, 0)
return res
40.组合总和II
如果按照39的组合和来做,求出所有组合再去重,则会超时,所以要在搜索的过程中就去掉重复组合
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
path = []
res = []
# 剪枝需要提前排序
candidates.sort()
def backtracking(candidates, target, sum, startindex):
if sum == target:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
# 如果本层 sum + condidates[i] > target,就提前结束遍历,没必要进行下一层的回溯,剪枝
if sum + candidates[i] > target:
return
sum += candidates[i]
path.append(candidates[i])
backtracking(candidates, target, sum, i + 1)# 这里下一次开始的地方还可以是i+1 因为不可以重复使用
sum -= candidates[i]
path.pop()
backtracking(candidates,target, 0, 0)
# [[1,1,6],[1,2,5],[1,7],[1,2,5],[1,7],[2,6]]
# 去重
s = set()
ans = []
for item in res:
if item not in ans:
ans.append(item)
return ans
本题candidates 中的每个数字在每个组合中只能使用一次
。
本题数组candidates的元素是有重复
的,而39.组合总和 (opens new window)是无重复元素的数组candidates
树层去重
的话,需要对数组排序!
元素在同一个组合内是可以重复的,我们要去重的是同一树层上的“使用过”
,同一树枝上的都是一个组合里的元素,不用去重!
简单来说:保证本层不重复 但不同层可以重复
//candidates[i]==candidates[i-1]可以参考三数之和 如果当前元素和前一个元素相同 跳过
//同时要确保i-1不会越界 因为i从startindex开始 所以i-1>=startindex有i>=startindex 即i>startindex
if(i>startindex&&candidates[i]==candidates[i-1])
{
continue;
}
首先我们要知道candidates这个数组是固定的,其次candidates[i]==candidate[i-1]这个条件控制的是仅仅是前后元素是否相等,但是单纯用这一条件的话会导致同一跟树枝(纵向)出现相同元素也会被剪掉,就是连[1, 1, 6]这种答案都不可以出现。但是一旦加了 i > startIndex
这个条件就不一样了,因为如果在同一根树枝上进行迭代你会发现 i一直是等于 startIndex
的,只有横向的时候才会出现 i > startIndex的情况
,所以 i > startIndex && candidates[i]==candidate[i-1]
可以进行树层去重
。
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
path = []
res = []
# 剪枝需要提前排序
candidates.sort()
def backtracking(candidates, target, sum, startindex):
if sum == target:
res.append(path[:])
return
for i in range(startindex, len(candidates)):
# 如果本层 sum + condidates[i] > target,就提前结束遍历,没必要进行下一层的回溯,剪枝
if sum + candidates[i] > target:
return
# 参考三数之和 去重 同时保证i-1 不越界 i-1>=startindex
if i > startindex and candidates[i] == candidates[i - 1]:
continue
sum += candidates[i]
path.append(candidates[i])
backtracking(candidates, target, sum, i + 1)# 这里下一次开始的地方是i+1 因为不可以重复使用
sum -= candidates[i]
path.pop()
backtracking(candidates,target, 0, 0)
return res