目录
核心思想
回溯的本质是穷举，穷举所有可能，选出我们想要的答案
回溯法能解决的问题都可以抽象为树形结构，回溯函数内部递归调用自己(设计到各种参数的传递)是往树的更深层走的过程（所谓的纵向遍历），回溯函数内部的for循环代表的是树的某一层的各种选择可能性（所谓的横向遍历）
回溯算法本质上是对for循环的一种推广，因为有的问题，嵌套几个for循环也解决不了，所以诞生了套娃式的for循环-回溯算法
组合和分割问题都是在叶子节点才收集结果；子集问题在遍历的每个节点就开始收集结果了；
排列问题不会用startidx来指示已经遍历到哪个节点了，因为每次都需要从头开始选取那些还未使用过的元素，所以用used数组防止对同一个数重复选择（需要对数组预先排序）；如果是不能排序的，需要同一层去重，则用set()，每次加入元素之前判断是否在集合中，在的话就不用处理这个元素了，相当于一次剪枝
棋盘和其他问题都是对以上各类问题在具体场景的灵活应用
回溯模板
# 回溯法模板
# 存放所有结果的
res = []
# 存放一条路径上遍历的记录
path = []
# (可选)用于去重(一般要求数组先排序),a是给定的数组
used = [False for i in range(len(a))]
# 参数一般是给定的变量，(可选)遍历时的startidx, (可选)遍历过程中总和,...
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
# (可选)用于去重
record = set()
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
组合
N个数里面按照一定规则找出k个数的集合，不强调元素顺序
77 组合
- medium
- 题目描述
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。
- 解题思路
如果剩余元素个数已经凑不到k个了，那么就可以剪枝了
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
def backtracking(n, k, startidx):
if len(path) == k:
res.append(path[:])
return
# n - (k-len(path))+1
# 还需要k-len(path)个元素
# 所以最多只能从n-(k-len(path))+1处开始搜索(注意这里是从1开始的)
# 最原始的写法是[startidx, n]
for i in range(startidx, n-(k-len(path))+2):
path.append(i)
backtracking(n, k, i+1)
path.pop()
return
res = []
path = []
backtracking(n, k, 1)
return res
17 电话号码的字母组合
- medium
- 题目描述
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
- 解题思路
和上面题目的区别在于，要将字符串中每个位置的数字转换成所代表的字母组合；这里不再使用list类型的path，而是直接用str类型的s变量存储遍历过的路径；这里没有用到77和216中的startidx，因为这是多个集合取组合，各个集合之间相互不影响，而如果是一个集合求组合的话，就需要startidx
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
lettersMap = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"]
res = []
s = ""
def backtracking(digits, index):
nonlocal res, s
if index == len(digits):
res.append(s)
return
idx = int(digits[index]) - 0
temp = lettersMap[idx]
for i in range(len(temp)):
s += temp[i]
backtracking(digits, index + 1)
s = s[:-1]
if len(digits) == 0:
return []
backtracking(digits, 0)
return res
216 组合总和Ⅲ
- medium
- 题目描述
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
只使用数字1到9
每个数字最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
- 2 <= k <= 9
- 1 <= n <= 60
- 解题思路
和77类似，就是在77的条件下多加了一个限制，组合的和必须是指定的数；
2处可以剪枝：集合中的数之和已经超过n了、for循环横向的数字已经无法凑满k个数了
class Solution:
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
res = []
path = []
def backtracking(k, target, startidx, count):
# 剪枝
if count > target:
return
if len(path) == k:
if count == target:
res.append(path[:])
return
# 9 - (k-len(path)) + 1
# 剪枝
for i in range(startidx, 9-(k-len(path))+2):
path.append(i)
count += i
backtracking(k, target, i+1, count)
path.pop()
count -= i
return
backtracking(k, n, 1, 0)
return res
39 组合总和
- medium
- 题目描述
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都 互不相同
1 <= target <= 500
- 解题思路
这道题的单个组合大小是不定的，通过总和的限制间接的对个数进行限制
这道题在递归传参的时候，传的不再是i+1，而是i，因为题目中强调可以重复选择自己
# 回溯思路
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
res = []
path = []
def backtracking(candidates, target, count, startidx):
if count > target:
return
if target == count:
res.append(path[:])
return
for i in range(startidx, len(candidates)):
path.append(candidates[i])
count += candidates[i]
backtracking(candidates, target, count, i)
path.pop()
count -= candidates[i]
# sorted(candidates)
backtracking(candidates, target, 0, 0)
return res
# 剪枝思路
# 对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。
# 其实如果已经知道下一层的sum会大于target，就没有必要进入下一层递归了。那么可以在for循环的搜索范围上做做文章了。
# 对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。
# 和以上代码的不同之处有3点：
# 1.
# 如果 sum + candidates[i] > target 就终止遍历
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i);
sum -= candidates[i];
path.pop_back();
}
# 2. 不需要if count > target了
# 3.外部需要对原数组进行排序
40 组合总和Ⅱ
- medium
- 题目描述
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意：解集不能包含重复的组合。
- 解题思路
本题中给定的候选数组含有重复元素，且每个元素仅能使用一次，要求不能有重复的组合
不能求出所有组合然后再去重很容易超时，在搜索过程中就要去掉重复组合
因为元素在同一组合内可以重复，但是两个组合不能相同，所以对同一树层去重，同一树枝上是一个组合内的不用去重
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
res = []
path = []
def backtracking(candidates, target, count, startidx, used):
if count > target:
return
if count == target:
res.append(path[:])
return
for i in range(startidx, len(candidates)):
if i > 0 and candidates[i] == candidates[i-1] and used[i-1] == False:
continue
path.append(candidates[i])
count += candidates[i]
used[i] = True
backtracking(candidates, target, count, i+1, used)
path.pop()
count -= candidates[i]
used[i] = False
candidates = sorted(candidates)
# 去重，即不选取重复元素
used = [False for i in range(len(candidates))]
backtracking(candidates, target, 0, 0, used)
return res
分割
一个字符串按照一定规则有几种切割方式
131 分割回文串
- medium
- 题目描述
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
- 解题思路
path中每次加入的必须是已经回文的字符串
class Solution:
def partition(self, s: str) -> List[List[str]]:
# 模拟切割线
res = []
path = []
startidx = 0
# 判断字符串是否是回文串
def issym(s, start, end):
i = start
j = end
while(i <= j):
if s[i] == s[j]:
i += 1
j -= 1
else:
return False
return True
def backtracking(s, startidx):
if startidx >= len(s):
res.append(path[:])
return
for i in range(startidx, len(s)):
if issym(s, startidx, i):
path.append(s[startidx:i+1])
else:
continue
backtracking(s, i+1)
path.pop()
backtracking(s, startidx)
return res
93 复原IP地址
- medium
- 题目描述
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
- 1 <= s.length <= 20
- s 仅由数字组成
- 解题思路
0单独可以形成ip地址的某一块，但是带有前导0的数字不可以成为ip地址的一块，pointnum记录添加点号的数量
字符串切割的时候，要用startidx记录每次切割开始的地方，不能对切割过的字符串再切割
class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
res = []
path = ""
# 判断是否是有效的ip地址
def isvalid(s, start, end):
if start > end:
return False
ans = s[start:end+1]
# 长度问题
if len(ans) > 3:
return False
# 出现非数字或者超过255
count = 0
for i in ans:
if i > '9' or i < '0':
return False
count = count*10 + int(i)
if count > 255:
return False
# 前导0(单独一个0可以的)
if s[start] == "0" and start != end:
return False
return True
def backtracking(s, startidx, point):
nonlocal res, path
if point == 3 and isvalid(s, startidx, len(s)-1):
temp = path + s[startidx:len(s)]
res.append(temp)
return
for i in range(startidx, len(s)):
if isvalid(s, startidx, i):
path += s[startidx:i+1] + "."
point += 1
else:
break
backtracking(s, i+1, point)
path = path[:-(len(s[startidx:i+1])+1)]
point -= 1
# 剪枝
if len(s) > 12:
return res
backtracking(s, 0, 0)
return res
子集
N个数的集合里，有多少符合条件的子集
78 子集
- medium
- 题目描述
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
- 解题思路
和求组合的区别在于，每走到一个节点就可以收集结果了（收集完结果不能return），而组合问题和分割问题都是需要走到叶子节点才能开始收集结果
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
def backtracking(nums, startidx):
res.append(path[:])
if startidx >= len(nums):
return
for i in range(startidx, len(nums)):
path.append(nums[i])
backtracking(nums, i+1)
path.pop()
backtracking(nums, 0)
return res
90 子集Ⅱ
- medium
- 题目描述
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
- 解题思路
因为不能包括重复的子集，所以需要用used数组对同一树层去重（首先要是排好序的集合）
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
used = [False for i in range(len(nums))]
def backtracking(nums, start):
res.append(path[:])
if start >= len(nums):
return
for i in range(start, len(nums)):
if i > 0 and nums[i] == nums[i-1] and used[i-1] == False:
continue
path.append(nums[i])
used[i] = True
backtracking(nums, i+1)
path.pop()
used[i] = False
nums = sorted(nums)
backtracking(nums, 0)
return res
排列
N个数按一定规则全排列，有几种排列方式
46 全排列
- medium
- 题目描述
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
- 解题思路
排列问题不需要startidx，因为每次都需要从头开始遍历那些还没使用过的元素
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
used = [False for i in range(len(nums))]
def backtrack(nums):
if len(path) == len(nums):
res.append(path[:])
return
for i in range(len(nums)):
if used[i] == True:
continue
used[i] = True
path.append(nums[i])
backtrack(nums)
used[i] = False
path.pop()
backtrack(nums)
return res
47全排列Ⅱ
- medium
- 题目描述
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
- 解题思路
在全排列的基础上多了一个同一树层去重
class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
used = [False for i in range(len(nums))]
def backtrack(nums):
if len(path) == len(nums):
res.append(path[:])
return
for i in range(len(nums)):
# and连接的条件是对同一树层去重，used[i]=True是防止重复选取同一个数
if i > 0 and nums[i] == nums[i-1] and used[i-1] == False or used[i] == True:
continue
path.append(nums[i])
used[i] = True
backtrack(nums)
path.pop()
used[i] = False
nums =sorted(nums)
backtrack(nums)
return res
棋盘问题
51 N皇后
- hard
- 题目描述
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
- 解题思路
横向搜索的是某行的每一列，纵向搜索的是每一行
class Solution:
def solveNQueens(self, n: int) -> List[List[str]]:
res = []
path = ['.'*n for i in range(n)]
def isValid(row, col):
# 检查row之前的所有行，是否同列
for i in range(row):
if path[i][col] == 'Q':
return False
# 检查斜线是否相同
for i in range(row):
if row-i+col < n and path[i][row-i+col] == 'Q':
return False
if col-(row-i) >=0 and path[i][col-(row-i)] == 'Q':
return False
return True
def backtrack(n, row):
if row == n:
res.append(path[:])
return
# 遍历一行中的每一列
for i in range(n):
if isValid(row, i):
path[row] = '.'*i + 'Q' + '.'*(n-i-1)
backtrack(n, row+1)
path[row] = '.'*n
# 遍历棋盘的每一行通过第二个参数来控制
backtrack(n, 0)
return res
37 解数独
- hard
- 题目描述
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
board.length == 9
board[i].length == 9
board[i][j] 是一位数字或者 ‘.’
题目数据 保证 输入数独仅有一个解
- 解题思路
想象一棵树，每层都是对一个格子的试探性放入不同的数字形成各个分支，下一层就是另一个格子
class Solution:
def solveSudoku(self, board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
"""
# 和N皇后问题最大的不同在于，N皇后是每行只需要放置一个Q，而数独问题需要对一行中每个空位置进行处理
def isValid(row, col, k, board):
# 每行只能出现一次
for j in range(9):
if board[row][j] != '.' and int(board[row][j]) == k:
return False
# 每列只能出现一次
for i in range(9):
if board[i][col] != '.' and int(board[i][col]) == k:
return False
# 3*3宫内
starti = row // 3
startj = col // 3
for i in range(starti*3, starti*3+3):
for j in range(startj*3, startj*3+3):
if board[i][j] != '.' and int(board[i][j]) == k:
return False
return True
def backtrack(board):
# 遍历行列
for i in range(9):
for j in range(9):
if board[i][j] == ".":
for k in range(1, 10):
if isValid(i, j, k, board):
board[i][j] = str(k)
if backtrack(board):
return True
board[i][j] = "."
return False
return True
backtrack(board)
return
其他
491 递增子序列（和子集问题很像）
- medium
- 题目描述
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
- 解题思路
子序列可以不连续，但是子串（子数组）必须是连续的；集合中元素不能重复使用同时因为不能预先排序所以用一个used集合保存每种数字是否被使用过，同样是同一树层去重，同一树枝无需去重
class Solution:
def findSubsequences(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
# used这种做法只适用于排好序的
# used = [False for i in range(len(nums))]
def backtrack(nums, startidx):
if len(path) > 1:
res.append(path[:])
if startidx >= len(nums):
return
record = set()
for i in range(startidx, len(nums)):
# 当前层去重
if len(path) != 0 and path[-1] > nums[i] or nums[i] in record:
continue
path.append(nums[i])
record.add(nums[i])
backtrack(nums, i+1)
path.pop()
backtrack(nums, 0)
return res
332 重新安排行程
- hard
- 题目描述
给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。
所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。
- 解题思路
对每个点可以到达的目的点进行排序，优先选择排序最小的那个目的点；相对来说需要选择合适的数据结构来保存（每个出发点，会存在多个不同可选的目的地，用dict来保存）；只需要找到一条路径就可以返回了，无需遍历整棵树
class Solution:
def findItinerary(self, tickets: List[List[str]]) -> List[str]:
record = collections.defaultdict(list)
path = ["JFK"]
# 题目规定至少存在一种合理的行程
def backtracking(start_point):
if len(path) == len(tickets) + 1:
return True
# 从该点出发所有可以的选择
record[start_point].sort()
for i in record[start_point]:
# 选择该目的地（选择了这张机票）则在字典的List中弹出对应的选择
end_point = record[start_point].pop(0)
path.append(end_point)
# 只需要找到一条路径就可以返回
if backtracking(end_point):
return True
path.pop()
# 上面弹出了，需要回溯，也就是重新加入record对应的键值中
record[start_point].append(end_point)
for t in tickets:
record[t[0]].append(t[1])
backtracking("JFK")
return path
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
