首先,组合问题和子集问题其实是等价的,这个后面会讲;至于之前说的三种变化形式,无非是在这两棵树上剪掉或者增加一些树枝罢了
我们通过保证元素之间的相对顺序不变来防止出现重复的子集。
如果把根节点作为第 0 层,将每个节点和根节点之间树枝上的元素作为该节点的值,那么第 n
层的所有节点就是大小为 n
的所有子集。
回溯算法就是个多叉树的遍历问题,关键就是在前序遍历和后序遍历的位置做一些操作,算法框架如下:
def backtrack(...):
for 选择 in 选择列表:
做选择
backtrack(...)
撤销选择
写 backtrack
函数时,需要维护走过的「路径」和当前可以做的「选择列表」,当触发「结束条件」时,将「路径」记入结果集。
class Solution:
def __init__(self):
self.res = []
def subsets(self, nums: List[int]) -> List[List[int]]:
track = [] #回溯问题的track多使用局部变量来表达,再通过回溯函数传递,局部变量具有临时使用的特性,不是一直使用
self.backtrack(nums, 0, track)
return self.res
def backtrack(self, nums, start, track) :
self.res.append(track[:]) #初始为空,
for i in range(start, len(nums)):#这里的nums就是选择列表
track.append(nums[i])
self.backtrack(nums, i + 1, track)
track.pop()
class Solution:
def __init__(self):
self.res = []
# 记录回溯算法的递归路径
self.track = []
# 主函数
def combine(self, n: int, k: int) -> List[List[int]]:
self.backtrack(1, n, k)#k>=1 , 所以这里start可以从1开始
return self.res
def backtrack(self, start: int, n: int, k: int) -> None:
# base case
if k == len(self.track):
# 遍历到了第 k 层,收集当前节点的值
self.res.append(self.track.copy())
return
# 回溯算法标准框架
for i in range(start, n+1):
# 选择
self.track.append(i)
# 通过 start 参数控制树枝的遍历,避免产生重复的子集
self.backtrack(i + 1, n, k)
# 撤销选择
self.track.pop()
组合问题可以由子集问题容易得到,取第k层就可以获得大小为k的组合。
刚才讲的组合/子集问题使用 start
变量保证元素 nums[start]
之后只会出现 nums[start+1..]
中的元素,通过固定元素的相对位置保证不出现重复的子集。
但排列问题本身就是让你穷举元素的位置,nums[i]
之后也可以出现 nums[i]
左边的元素,所以之前的那一套玩不转了,需要额外使用 used
数组来标记哪些元素还可以被选择 排列问题本来就是在玩转位置
递归就像你遇到一个任务,它的解决方法是去完成一个规模更小但相似的任务,而那个小任务的解决方法又是去完成另一个更小的任务,直到任务小到你可以轻松完成为止。在编程中,这种技术通过函数自我调用来实现,用于解决可以分解成子问题的问题。
class Solution:
def __init__(self):
self.res = []
self.track = []
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
# 先排序,让相同的元素靠在一起
nums.sort()
self.backtrack(nums, 0)
return self.res
def backtrack(self, nums: List[int], start: int) -> None:
# 前序位置,每个节点的值都是一个子集
self.res.append(self.track[:])
for i in range(start, len(nums)):
# 剪枝逻辑,值相同的相邻树枝,只遍历第一条
if i > start and nums[i] == nums[i - 1]:
continue
self.track.append(nums[i])
self.backtrack(nums, i + 1)
self.track.pop()
两条值相同的相邻树枝会产生重复 ,进行剪枝操作,
剪枝(Pruning)是一种在算法(尤其是回溯算法)中使用的优化技术。它的核心思想是在搜索问题解空间时,提前终止那些不会产生有效解或不必要的搜索路径,从而减少计算量,提高算法效率。
什么是剪枝操作
在许多组合问题中,解空间(所有可能的解组合)可能非常庞大,而其中只有一部分是有效的或符合要求的解。剪枝的目的是在搜索的过程中,识别并跳过那些不可能产生有效解的分支。
例如,在回溯算法中,每次选择一个选项(即进入一个分支),再继续尝试下一个选项。但在某些情况下,你可以通过提前判断,发现某个分支已经不能满足条件,那么就可以直接放弃这个分支的进一步探索,这就是剪枝。
为什么要剪枝
- 减少计算量:剪枝可以大幅度减少需要计算的分支,从而减少整个问题的搜索空间。例如,在求解一个复杂的组合问题时,如果不剪枝,算法可能需要遍历所有可能的组合。但通过剪枝,可以跳过不可能的分支,减少遍历的次数。
- 提高效率:剪枝可以显著提高算法的运行效率,使得原本可能无法在合理时间内完成的计算变得可行。在一些实际应用中,剪枝往往是使问题从“无法解决”变为“可以解决”的关键。
- 避免冗余计算:剪枝还能帮助避免重复计算不必要的分支。例如,在某些问题中,某些路径可能会多次出现,通过剪枝可以避免这些重复的计算。
总结
剪枝操作通过智能地减少算法的搜索空间,显著提升了算法的效率和执行速度。在处理组合问题、搜索问题时,剪枝往往是不可或缺的优化手段。它的核心思想就是“减少不必要的工作”,通过跳过不可能成功的路径来节省时间和资源。
- 作用范围:
continue
仅影响循环内部,它会跳过当前迭代的剩余部分,但循环仍继续执行下一次迭代。return
直接终止整个函数的执行,并且函数返回到调用者处,不再执行任何代码。
- 使用位置:
continue
只能用于循环中(如for
和while
)。return
只能用于函数内部,用来结束函数并返回值。
- 执行流程影响:
continue
只是跳过循环中的部分代码,不会终止循环本身。return
则完全终止函数的执行,并返回到函数的调用点。
总结
continue
是一个跳过当前循环迭代剩余部分的指令,让循环继续下一个迭代。return
则是一个结束函数执行的指令,通常用于函数的结果返回,并退出函数。
两者在控制程序执行流程时,作用域和效果截然不同。
也就是continue是在循环时候使用, return是在函数结束递归的时候使用。!!!基础知识点
组合问题和子集问题是等价的, 剪枝操作!!第一次接触
class Solution:
def __init__(self):
self.res = []
# 记录回溯的路径
self.track = []
# 记录 track 中的元素之和
self.trackSum = 0
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
# 先排序,让相同的元素靠在一起
candidates.sort()
self.backtrack(candidates, 0, target)
return self.res
# 回溯算法主函数
def backtrack(self, nums: List[int], start: int, target: int):
# base case,达到目标和,找到符合条件的组合
if self.trackSum == target:
self.res.append(self.track[:])
return#return代表这一层递归结束
# base case,超过目标和,直接结束 #也是剪纸的一部分
if self.trackSum > target:
return
# 回溯算法标准框架
for i in range(start, len(nums)):
# 剪枝逻辑,值相同的树枝,只遍历第一条 #减去旁边值相同的数值,不然会造成重复使用
if i > start and nums[i] == nums[i - 1]: #减去数枝
continue#continue只是这一层循环结束
# 做选择
self.track.append(nums[i])
self.trackSum += nums[i]
# 递归遍历下一层回溯树
self.backtrack(nums, i + 1, target)
# 撤销选择
self.track.pop()
self.trackSum -= nums[i]
class Solution:
def __init__(self):
self.track = []
self.res = []
self.used = []
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
nums.sort()#加一下排序,后序进行剪纸
self.used = [False] * len(nums)
self.backtrack( nums)
return self.res
def backtrack(self, nums) -> None:
if len(self.track) == len(nums):
self.res.append(self.track[:])
return #这里加return结束递归
for i in range(0, len(nums)):
if self.used[i]:
continue #这是排列问题,这个元素用过就不能再排列了
if i > 0 and nums[i] == nums[i - 1] and not self.used[i - 1]:
continue
self.track.append(nums[i])
self.used[i] = True
self.backtrack(nums)
self.track.pop()
self.used[i] = False
此剪枝思路,保证了2,2’,2’'的相对位置,去除了重复。
保证相同元素在排列中的相对位置保持不变。 标准全排列算法之所以出现重复,是因为把相同元素形成的排列序列视为不同的序列,但实际上它们应该是相同的;而如果固定相同元素形成的序列顺序,当然就避免了重复。 当出现重复元素时,比如输入 nums = [1,2,2',2'']
,2'
只有在 2
已经被使用的情况下才会被选择,同理,2''
只有在 2'
已经被使用的情况下才会被选择,这就保证了相同元素在排列中的相对位置保证固定。
子集问题和组合问题是同一类问题 标准的子集,组合问题,通过控制start来控制无重复问题, 排列问题通过used来控制位置。
# 无重组合的回溯算法框架
def backtrack(nums: List[int], start: int) -> None:
for i in range(start, len(nums)):
# ...
# 递归遍历下一层回溯树,注意参数
backtrack(nums, i + 1)
# ...
想让每个元素被重复使用,我只要把 i + 1
改成 i
即可:
# 可重组合的回溯算法框架
def backtrack(nums: List[int], start: int):
for i in range(start, len(nums)):
# ...
# 递归遍历下一层回溯树,注意参数
backtrack(nums, i)
# ...
当然,这样这棵回溯树会永远生长下去,所以我们的递归函数需要设置合适的 base case 以结束算法
类变量:
- 类变量是在类的定义中声明的变量,不属于任何特定的实例。所有该类的实例共享同一个类变量的值。
- 在Python中,类变量通常在类体内(但在任何方法之外)定义。它们由类的所有实例共享,这意味着如果一个实例修改了类变量的值,那么这个修改对所有实例都可见。
实例变量:
- 实例变量是在类的实例(对象)中声明的变量。每个实例都有自己独立的实例变量,互不干扰。
- 在Python中,实例变量通常在
__init__
方法中使用self
关键字进行声明,并且只属于特定的实例。
class Solution:
def __init__(self):
self.res = []
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
self.backtrack(candidates, 0, target, 0) #sum一开始是0
return self.res
track = []#这里的track是类变量,写在init里面写成类变量也可以
def backtrack(self, candidates: List, start:int, target: int, sum: int) -> None:
if sum == target:
self.res.append(self.track.copy())
return
if sum > target:
return
for i in range(start, len(candidates)):
self.track.append(candidates[i])
sum += candidates[i]
self.backtrack(candidates, i, target, sum)
sum -= candidates[i]
self.track.pop()
总结
- 类变量: 用于共享属性或方法,适合类的所有实例共享的值。
- 实例变量: 用于保存对象的状态,适合每个实例独立维护的值。
- 局部变量: 用于函数或方法的临时计算,适合只在函数或方法内部使用的值。
总结:
形式一、元素无重不可复选,即 nums
中的元素都是唯一的,每个元素最多只能被使用一次,backtrack
核心代码如下:
# 组合/子集问题回溯算法框架
def backtrack(nums: List[int], start: int):
# 回溯算法标准框架
for i in range(start, len(nums)):
# 做选择
track.append(nums[i])
# 注意参数
backtrack(nums, i + 1)
# 撤销选择
track.pop()
# 排列问题回溯算法框架
def backtrack(nums: List[int]):
for i in range(len(nums)):
# 剪枝逻辑
if used[i]:
continue
# 做选择
used[i] = True
track.append(nums[i])
backtrack(nums)
# 撤销选择
track.pop()
used[i] = False
形式二、元素可重不可复选,即 nums
中的元素可以存在重复,每个元素最多只能被使用一次,其关键在于排序和剪枝,backtrack
核心代码如下: 跳出重复元素
nums.sort()
# 组合/子集问题回溯算法框架
def backtrack(nums: List[int], start: int):
# 回溯算法标准框架
for i in range(start, len(nums)):
# 剪枝逻辑,跳过值相同的相邻树枝
if i > start and nums[i] == nums[i - 1]:
continue
# 做选择
track.append(nums[i])
# 注意参数
backtrack(nums, i + 1)
# 撤销选择
track.pop()
nums.sort()
# 排列问题回溯算法框架
def backtrack(nums: List[int]):
for i in range(len(nums)):
# 剪枝逻辑
if used[i]:
continue
# 剪枝逻辑,固定相同的元素在排列中的相对位置
if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
continue
# 做选择
used[i] = True
track.append(nums[i])
backtrack(nums)
# 撤销选择
track.pop()
used[i] = False
形式三、元素无重可复选,即 nums
中的元素都是唯一的,每个元素可以被使用若干次,只要删掉去重逻辑即可,backtrack
核心代码如下:
# 组合/子集问题回溯算法框架
def backtrack(nums: List[int], start: int):
# 回溯算法标准框架
for i in range(start, len(nums)):
# 做选择
track.append(nums[i])
# 注意参数
backtrack(nums, i)
# 撤销选择
track.pop()
# 排列问题回溯算法框架
def backtrack(nums: List[int]):
for i in range(len(nums)):
# 做选择
track.append(nums[i])
backtrack(nums)
# 撤销选择
track.pop()