回溯算法集合（全排列，组合，子集）
一套模板搞定全排列，组合，子集问题（递归嵌套for循环）
组合问题：leetcode77、leetcode39、leetcode40、leetcode216
全排列问题：leetcode46、leetcode47
子集问题：leetcode78、leetcode90
基础模板
def __init__(self):
#收集所有符合条件的集合
self.paths = []
#临时结果存放并需要回溯
self.path = []
def backtracking(参数值)：
if 递归终止条件：
return
for 循环：
self.path.append(元素)
backtracking(参数值)
self.path.pop()1.组合问题
leetcode77:
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
解题关键：递归函数中的start_index参数用于防止元素选取重复
class Solution:
def __init__(self):
self.paths = []
self.path = []
def combine(self, n: int, k: int) -> List[List[int]]:
def backtracking(n, k, start_index):
#递归终止条件
if len(self.path) == k:
#将符合条件的临时集合加入到最终集合中
self.paths.append(self.path[:])
return
#start_index用于进行控制深度递归时，元素不会进行重复选取，
#而是从本轮递归选取的元素的下一个元素开始。n-(k-len(self.path))+2
#为剪枝操作，当元素从数组中最后几位开始选取时，后面的长度不足为k，故不需要再操作
for i in range(start_index, n-(k-len(self.path))+2):
#加入元素
self.path.append(i)
#递归
backtracking(n, k, i+1)
#元素回溯，会弹出一个元素，进行下一个元素的选取
self.path.pop()
backtracking(n, k, 1)
return self.pathsleetcode39:
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
解题关键：start_index在递归函数的变化，每一个元素可被重复选取，因此递归函数中start_index
仍然为i。
class Solution:
def __init__(self):
self.paths = []
self.path = []
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
def backtracking(candidates, target, start_index):
if target == 0:
self.paths.append(self.path[:])
return
for i in range(start_index, len(candidates)):
#剪枝，大于target的集合不需要再往后选取
if target < 0:
return
#对每个元素做减法，与递归结束条件target==0呼应
target -= candidates[i]
self.path.append(candidates[i])
#题目条件每个元素可以重复被选取，所以这里start_index仍然为i而不是i+1
backtracking(candidates, target, i)
self.path.pop()
#对每个元素做加法，与递归结束条件target==0呼应
target += candidates[i]
backtracking(candidates, target, 0)
return self.pathsleetcode40
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意：解集不能包含重复的组合。
解题关键：数组中含有重复元素，每个元素不能重复使用，需要在选取过程中去重
class Solution:
def __init__(self):
self.path = []
self.paths = []
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
def backtracking(candidates, target, start_index):
if target == 0:
self.paths.append(self.path[:])
return
for i in range(start_index, len(candidates)):
#剪枝
if target < 0:
return
#存在重复元素，去重，这个前提条件是数组为有序
if i > start_index and candidates[i] == candidates[i-1]:
continue
target -= candidates[i]
self.path.append(candidates[i])
#元素不可重复使用，start_index需为i+1，即从下一个元素开始选取
backtracking(candidates, target, i+1)
self.path.pop()
target += candidates[i]
#这里sorted()将数组元素排序，是去重操作的前提条件
backtracking(sorted(candidates), target, 0)
return self.pathsleetcode216
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
只使用数字1到9
每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
def backtracking(k, n, start_index):
if len(self.path) == k:
#无论有没有符合条件的集合，都要结束递归，后面的递归超出条件k个，无意义
if n == 0:
self.paths.append(self.path[:])
return
for i in range(start_index, 9 - (k-len(self.path))+2):
if n < 0:
return
n -= i
self.path.append(i)
backtracking(k, n, i+1)
self.path.pop()
n += i
backtracking(k, n, 1)
return self.paths
2.全排列问题
leetcode46
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
class Solution:
def __init__(self):
self.paths = []
self.path = []
def permute(self, nums: List[int]) -> List[List[int]]:
def backtracking(nums):
if len(self.path) == len(nums):
self.paths.append(self.path[:])
return
for i in range(0, len(nums)):
#去掉含有重复元素的组合
if nums[i] in self.path:
continue
self.path.append(nums[i])
#全排列有顺序的讲究，故每一次递归的遍历都可以从数组的第0个元素开始
backtracking(nums)
self.path.pop()
backtracking(nums)
return self.pathsleetcode47
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
used = [0] * len(nums)
def backtracking(nums, used):
if len(self.path) == len(nums):
self.paths.append(self.path[:])
return
for i in range(0, len(nums)):
#保证每个元素只可用一次
if not used[i]:
#去掉数组中因存在重复元素而形成的重复组合
if i > 0 and nums[i]==nums[i-1] and not used[i-1]:
continue
#含有重复元素，需要记录每个元素的使用情况，并且作为递归函数的参数
used[i] = 1
self.path.append(nums[i])
backtracking(nums, used)
self.path.pop()
used[i] = 0
backtracking(sorted(nums), used)
return self.paths3.子集问题
leetcode78
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
class Solution:
def __init__(self):
self.path = []
self.paths = []
def subsets(self, nums: List[int]) -> List[List[int]]:
def backtracking(nums, start_index):
#每加进来一个元素就做一次结果收集
self.paths.append(self.path[:])
if len(self.path) == len(nums):
return
for i in range(start_index, len(nums)):
self.path.append(nums[i])
#保证元素无重复选取，start_index为i+1
backtracking(nums, i+1)
self.path.pop()
backtracking(nums, 0)
return self.pathsleetcode90
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
解题关键：数组中有重复元素，需要去除因存在重复元素而形成的重复集合
class Solution:
def __init__(self):
self.paths = []
self.path = []
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
def backtracking(nums, start_index):
self.paths.append(self.path[:])
if len(self.path) == len(nums):
return
for i in range(start_index, len(nums)):
#数组中有重复元素，需要去除因存在重复元素而形成的重复集合
if i > start_index and nums[i] == nums[i-1]:
continue
self.path.append(nums[i])
backtracking(nums, i+1)
self.path.pop()
backtracking(sorted(nums), 0)
return self.paths参考文献：代码随想录