1.组合
给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
class Solution:
def combine(self,n,k):
res = []#存放符合条件结果的集合
path = []#用来存放符合条件结果
def backtrack(n,k,startIndex):
if len(path) == k:
res.append(path[:])
return
for i in range(startIndex,n - (k - len(path)) + 2):
path.append(i)#处理节点
backtrack(n,k,i + 1)#递归
path.pop()#回溯，撤销处理的节点
backtrack(n,k,1)
return res2.组合总和III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
- 所有数字都是正整数。
- 解集不能包含重复的组合。
class Solution:
def combine(self,n,k):
res = []
path = []
self.sum_now = 0
def backtracking(n,k,start_num):
if self.sum_now > n:
return
if len(path) == k:
if self.sum_now == n:
res.append(path[:])
return
for i in range(start_num,9 - (k - len(path)) + 2):
path.append(i)
self.sum_now += i
backtracking(n,k,i + 1)
path.pop()
self.sum_now -= i
backtracking(n,k,1)
return res3.电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
class Solution:
def __init__(self):
self.answers = []
self.answer = ''
self.letter_map = {
'2':'abc',
'3':'def',
'4':'ghi',
'5':'jkl',
'6':'mno',
'7':'pqrs',
'8':'tuv',
'9':'wxyz'
}
def letterCombinations(self,digits):
self.answers.clear()
if not digits:return []
self.backstracking(digits,0)
return self.answers
def backstracking(self,digits,index):
if index == len(digits):# 当遍历穷尽后的下一层
self.answers.append(self.answer)
return
# 单层递归逻辑
letters = self.letter_map[digits[index]]
for letter in letters:
self.answer += letter
self.backstracking(digits,index + 1)# 递归至下一层
self.answer = self.answer[:-1]# 回溯4.组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def combinationSum(self, candidates, target):
'''
因为本题没有组合数量限制，所以只要元素总和大于target就算结束
'''
self.path.clear()
self.paths.clear()
# 为了剪枝需要提前进行排序
candidates.sort()
self.backtracking(candidates, target, 0, 0)
return self.paths
def backtracking(self,candidates, target, sum, startIndex):
if sum > target:
return
if sum == target:
self.paths.append(self.path[:])# 因为是shallow copy，所以不能直接传入self.path
return
#单层递归逻辑
# 如果本层 sum + condidates[i] > target，就提前结束遍历，剪枝
for i in range(startIndex, len(candidates)):
if sum + candidates[i] > target:
return
self.path.append(candidates[i])
sum += candidates[i]
self.backtracking(candidates, target, sum, i)# 因为无限制重复选取，所以不是i-1
self.path.pop()# 回溯
sum -= candidates[i]# 回溯5.组合总和II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def combinationSum(self, candidates, target):
'''
因为本题没有组合数量限制，所以只要元素总和大于target就算结束
'''
self.path.clear()
self.paths.clear()
# 为了剪枝需要提前进行排序
candidates.sort()
self.backtracking(candidates, target, 0, 0)
return self.paths
def backtracking(self,candidates, target, sum, startIndex):
if sum == target:
self.paths.append(self.path[:])# 因为是shallow copy，所以不能直接传入self.path
return
#单层递归逻辑
# 如果本层 sum + condidates[i] > target，就提前结束遍历，剪枝
for i in range(startIndex, len(candidates)):
if sum + candidates[i] > target:
return
# 跳过同一树层使用过的元素
if i > startIndex and candidates[i] == candidates[i - 1]:
continue
self.path.append(candidates[i])
sum += candidates[i]
self.backtracking(candidates, target, sum, i + 1)
self.path.pop()# 回溯
sum -= candidates[i]# 回溯6.分割回文串
给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
返回 s 所有可能的分割方案。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def partition(self, s):
'''
递归用于纵向遍历
for循环用于横向遍历
当切割线迭代至字符串末尾，说明找到一种方法
类似组合问题，为了不重复切割同一位置，需要start_index来做标记下一轮递归的起始位置(切割线)
'''
self.path.clear()
self.paths.clear()
self.backtracking(s, 0)
return self.paths
def backtracking(self,s, startIndex):
if startIndex >= len(s):
self.paths.append(self.path[:])
return
# 单层递归逻辑
for i in range(startIndex, len(s)):
# 此次比其他组合题目多了一步判断：
# 判断被截取的这一段子串([start_index, i])是否为回文串
tmp = s[startIndex: i + 1]
if tmp == tmp[::-1]:# 若反序和正序相同，意味着这是回文串
self.path.append(tmp)
self.backtracking(s,i + 1)# 递归纵向遍历：从下一处进行切割，判断其余是否仍为回文串
self.path.pop()
else:
continue7.复原IP地址
给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
class Solution:
def __init__(self):
self.paths = []
def partition(self, s):
'''
本质切割问题使用回溯搜索法，本题只能切割三次，所以纵向递归总共四层
因为不能重复分割，所以需要start_index来记录下一层递归分割的起始位置
添加变量point_num来记录逗号的数量[0,3]
'''
self.paths.clear()
if len(s) > 12:return []
self.backtracking(s, 0, 0)
return self.paths
def backtracking(self,s, startIndex, point_num):
if point_num == 3:
if self.isValid(s, startIndex, len(s) - 1):
self.paths.append(s[:])
return
# 单层递归逻辑
for i in range(startIndex, len(s)):
# [start_index, i]就是被截取的子串
if self.isValid(s, startIndex, i):
s = s[:i + 1] + '.' + s[i + 1:]
self.backtracking(s, i + 2,point_num + 1)# 在填入.后，下一子串起始后移2位
s = s[:i + 1] + s[i + 2:]# 回溯
else:
# 若当前被截取的子串大于255或者大于三位数，直接结束本层循环
continue
def isValid(self,s,start,end):
if start > end:return False
if s[start] == '0' and start != end:
return False
if not (0 <= int(s[start: end + 1]) <= 255):
return False
return True8.子集
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
class Solution:
def __init__(self):
self.paths = []
self.path = []
def partition(self, nums):
self.path.clear()
self.paths.clear()
self.backtracking(nums, 0)
return self.paths
def backtracking(self, nums, startIndex):
# 收集子集，要先于终止判断
self.paths.append(self.path[:])
if startIndex == len(nums):
return
# 单层递归逻辑
for i in range(startIndex, len(nums)):
self.path.append(nums[i])
self.backtracking(nums, i + 1)
self.path.pop()
