基础知识补充
回溯中的组合问题:
![]()
优化:剪枝:在for循环时需要根据当前状态调整循环次数(组合问题)
基础操作补充
!!!牢记模板!!!
result = [] def backtrack(选择列表, 路径): if 满足结束条件: result.add(路径) return for 选择 in 选择列表: # 做选择 路径.add(选择) 将该选择从选择列表移除 backtrack(选择列表, 路径) # 核心 递归调用之前【做选择】,调用之后【撤销选择】 # 撤销选择 路径.remove(选择) 将该选择再加入选择列表
题目
46 全排列
给定一个不含重复数字的数组 nums
,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
class Solution: def permute(self, nums): res = [] # 选择列表就是nums包含的元素 # 使用used标记已经选择的数字 间接表示选择列表的变化 def backtrack(path, used): # 结束条件 if len(path) == len(nums): res.append(path[:]) # !!!此处有坑需要注意 return for i in range(len(nums)): if used[i]: # nums[i]已经选过 跳过 continue # 做选择 path.append(nums[i]) used[i] = True # 更新选择列表 # 递归 backtrack(path, used) # 撤销选择 path.pop() used[i] = False # 回退选择列表的变化 # 初始时路径为空,所有元素都没有选择过所以used中都是False used = [False]*len(nums) path = [] backtrack(path, used) return res
78 子集
给你一个整数数组 nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
class Solution(object): def subsets(self, nums): """ :type nums: List[int] :rtype: List[List[int]] """ res = [] def backtrack(path, start): res.append(path[:]) if len(path) == len(nums): return for i in range(start, len(nums)): path.append(nums[i]) # 递归 backtrack(path, i+1) # 从下一元素开始 避免重复 path.pop() path, start = [], 0 backtrack(path, start) return res
17 电话号码的字母组合
给定一个仅包含数字 2-9
的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
digits.length = 0: return []
digits.length = 1: return ['x','y','z']
digits.length = k: k个组合中各挑一个字母组合
class Solution(object): def letterCombinations(self, digits): """ :type digits: str :rtype: List[str] """ tmp = {'2':'abc', '3':'def', '4':'ghi', '5':'jkl', '6':'mno', '7': 'pqrs', '8':'tuv', '9':'wxyz'} strr = [] for i in digits: strr.append(tmp[i]) length = len(strr) if length == 0: return [] elif length == 1: return [i for i in strr[0]] res = [] def backtrack(path, start): if len(path) == len(strr): res.append(''.join(path)) return for i in range(start, len(strr)): for j in range(len(strr[i])): path.append(strr[i][j]) backtrack(path, i+1) path.pop() path, start = [], 0 backtrack(path, start) return res
39 组合总和
给你一个 无重复元素 的整数数组 candidates
和一个目标整数 target
,找出 candidates
中可以使数字和为目标数 target
的 所有 不同组合 ,并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates
中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同,则两种组合是不同的。 对于给定的输入,保证和为 target
的不同组合数少于 150
个。
candidates = [1,2,3] tartget = 5
会出现[1,1,3]-[1,3,1]的重复情况,因此需要将可选范围限制在当前值(可重复选取)或之后;
class Solution(object): def combinationSum(self, candidates, target): """ :type candidates: List[int] :type target: int :rtype: List[List[int]] """ res = [] def backtrack(path, start): summ = sum(path) if summ >= target: # 终止条件不再限制长度 if summ== target:res.append(path[:]) return for i in range(start, len(candidates)): path.append(candidates[i]) backtrack(path, i) # 当前元素和之后的可重复选取 path.pop() path, start = [], 0 backtrack(path, start) return res
22 括号生成
数字 n
代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
‘(’代表+1,‘)’代表-1,终止条件:sum(path)出现负数时结束,len(path)==2*n时结束;
class Solution(object): def generateParenthesis(self, n): """ :type n: int :rtype: List[str] """ res = [] inputt = ['(', ')'] def backtrack(path, summ): if summ < 0: return if len(path) == 2*n: if summ == 0: res.append(''.join(path)) return for i in range(len(inputt)): path.append(inputt[i]) summ += (1 if inputt[i]=='(' else -1) backtrack(path, summ) strr = path.pop() summ -= (1 if strr=='(' else -1) path, summ = [], 0 backtrack(path, summ) return res
DFS:记录左括号和右括号的数量;
class Solution: def generateParenthesis(self, n): res = [] def dfs(paths, left, right): if left > n or right > left: return if len(paths) == n * 2: # 因为括号都是成对出现的 res.append(paths) return dfs(paths + '(', left + 1, right) # 生成一个就加一个 dfs(paths + ')', left, right + 1) dfs('', 0, 0) return res
79 单词搜索
给定一个 m x n
二维字符网格 board
和一个字符串单词 word
。如果 word
存在于网格中,返回 true
;否则,返回 false
。单词必须按照字母顺序,通过相邻的单元格内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
先遍历一次,找到所有字符串单词首字母在网格中的位置;
从首字母的网格位置入手,先加入当前字母,然后在不越界的情况下加入上/下/左/右的字母,判断加入的第n个字母是否和word中第n个字母相同;
class Solution(object): def exist(self, board, word): """ :type board: List[List[str]] :type word: str :rtype: bool """ res = [] m, n, k = len(board), len(board[0]), len(word) if m*n < k: return False # 元素不够 def backtrack(path, cnt, pos): if path[-1] != word[cnt-1]: return else: if cnt == k: res.append(path[:]) return for i,j in [[-1,0],[1,0],[0,-1],[0,1]]: x, y = pos[0]+i, pos[1]+j if -1<x<m and -1<y<n and board[x][y]: path.append(board[x][y]) cnt, board[x][y] = cnt+1, '' backtrack(path, cnt, [x, y]) # 从下一元素开始 避免重复 board[x][y] = path.pop() cnt -= 1 first_alpha = [] for i in range(m): for j in range(n): if board[i][j] == word[0]: first_alpha.append([i,j]) if len(first_alpha)==0: return False # 没有首字母 for i,j in first_alpha: path, cnt = [board[i][j]], 1 board[i][j] = '' backtrack(path, cnt, [i, j]) board[i][j] = word[0] return bool(res)
可以优化的地方:1.不需要记录path;2.找到一个word就可以结束;(需要backtrack回传)3.改变传入的cnt即可;
class Solution(object): def exist(self, board, word): """ :type board: List[List[str]] :type word: str :rtype: bool """ m, n, k = len(board), len(board[0]), len(word) if m*n < k: return False # 元素不够 def backtrack(cnt, pos): if board[pos[0]][pos[1]] != word[cnt]: return False if cnt == k-1: return True board[pos[0]][pos[1]] = '' for i,j in [[-1,0],[1,0],[0,-1],[0,1]]: x, y = pos[0]+i, pos[1]+j if -1<x<m and -1<y<n and board[x][y]: if backtrack(cnt+1, [x, y]): return True board[pos[0]][pos[1]] = word[cnt] first_alpha = [] for i in range(m): for j in range(n): if board[i][j] == word[0]: first_alpha.append([i,j]) if len(first_alpha)==0: return False # 没有首字母 for i,j in first_alpha: if backtrack(0, [i, j]): return True return False
131 分割回文串
给你一个字符串 s
,请你将 s
分割成一些子串,使每个子串都是 回文串。返回 s
所有可能的分割方案。
子串的选择范围需要从下一字符开始,因此需要起始位置;
加入path的子串必须是回文子串,需要先判断再加入,因此把枚举范围从单个字符变成字符串长度,然后验证当前长度的子串是否是回文;
终止条件:长度到达终点;
class Solution(object): def partition(self, s): """ :type s: str :rtype: List[List[str]] """ res = [] length = len(s) def backtrack(path, start): if start == length: res.append(path[:]) return for i in range(start, length): # 枚举的是回文子串的长度 tmp = s[start:i+1] if tmp==tmp[::-1]: path.append(tmp) backtrack(path, i+1) path.pop() path, start = [], 0 backtrack(path, start) return res
51 N皇后
按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n
个皇后放置在 n×n
的棋盘上,并且使皇后彼此之间不能相互攻击。给你一个整数 n
,返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案,该方案中 'Q'
和 '.'
分别代表了皇后和空位。
搬运【山鬼】的解析:
1. 从上往下放棋子,用变量的表示就是,row从0到n-1
2.backtrack()函数的参数为row,表示当前开始放第row行的皇后,小于row的行(row行往上的)都已经放置皇后了
3. 需要构建一个isValid()函数,参数为board,row,col,返回是否可以在row,col上合法放置皇后;这个函数需要沿着row,col判断这个位置的上方、右上方、左上方是否有皇后。