1.什么是回溯算法
“回溯”算法也叫“回溯搜索”算法,主要用于在一个庞大的空间里搜索我们所需要的问题的解。“回溯”指的是“状态重置”,可以理解为“回到过去”、“恢复现场”,是在编码的过程中,是为了节约空间而使用的一种技巧。而回溯其实是“深度优先遍历”特有的一种现象。之所以是“深度优先遍历”,是因为我们要解决的问题通常是在一棵树上完成的,在这棵树上搜索需要的答案,一般使用深度优先遍历。
2. 示例1(回溯+状态重置)
“全排列”就是一个非常经典的“回溯”算法的应用。我们知道,N 个数字的全排列一共有 N!这么多个。
以数组 [1, 2, 3] 的全排列为例。
- 我们先写以 1 开头的全排列,它们是:[1, 2, 3], [1, 3, 2];
- 以 2 开头的全排列,它们是:[2, 1, 3], [2, 3, 1];
- 最后写以 3 开头的全排列,它们是:[3, 1, 2], [3, 2, 1]
我们只需要按顺序枚举每一位可能出现的情况,已经选择的数字在接下来要确定的数字中不能出现。按照这种策略选取就能够做到不重不漏,把可能的全排列都枚举出来。
使用编程的方法得到全排列,就是在如下图这样的一个树形结构中进行编程,具体来说,就是执行一次深度优先遍历,从树的根结点到叶子结点形成的路径就是一个全排列。
下面我们解释如何编码:
(1)首先这棵树除了根结点和叶子结点以外,每一个结点做的事情其实是一样的,即在已经选了一些数的前提下,我们需要在剩下还没有选择的数中按照顺序依次选择一个数,这显然是一个递归结构
(2)递归的终止条件是,数已经选够了,因此我们需要一个变量来表示当前递归到第几层,我们把这个变量叫做 depth
(3)这些结点实际上表示了搜索(查找)全排列问题的不同阶段,为了区分这些不同阶段,我们就需要一些变量来记录程序进行到哪一步了,在这里我们需要两个变量:
【a】已经选了哪些数,到叶子结点时候,这些已经选择的数就构成了一个全排列(path)
【b】一个布尔数组 isused,初始化的时候都为 false 表示这些数还没有被选择,当我们选定一个数的时候,就将这个数组的相应位置设置为 true ,这样在考虑下一个位置的时候,就能够以 O(1) 的时间复杂度判断这个数是否被选择过,这是一种“以空间换时间”的思想
把这两个变量称之为“状态变量”,它们表示了我们在求解一个问题的时候所处的阶段。
(4)在非叶子结点处,产生不同的分支,这一操作的语义是:在还未选择的数中依次选择一个元素作为下一个位置的元素,这显然得通过一个循环实现。
(5)因为是执行深度优先遍历,从较深层的结点返回到较浅层结点的时候,需要做**“状态重置”,即“回到过去”、“恢复现场”, 将最近加入到path变量中的数弹出,并将isused数组中对应位置设置为False**
程序实现
def permutation(nums):
result = []
pre = [] # 保存临时结果
isused = [False]*len(nums)
def recursion(pre, isused):
if len(pre) == len(nums):
# 此处需要注意,不可使用res.append(pre), 因为后面对pre的改变此处也会随之改变,因此需要深度复制
result.append(pre.copy())
return
for i in range(len(nums)):
if isused[i] == False:
pre.append(nums[i])
isused[i] = True
recursion(pre, isused)
pre.pop()
isused[i] = False
recursion(pre, isused)
return result
if __name__ == "__main__":
result = permutation([1, 2, 3, 4])
print(result)
2.2 复杂度分析
(回溯算法的时间复杂度一般都比较高,有些问题分析起来很复杂,我个人觉得没有必要掌握,而且剪枝剪得好的话,复杂度会降得很低,因此分析的最坏时间复杂度的意义也不是很大,视情况而定。)
时间复杂度:O(NxN!)
3. 示例2(回溯不带状态重置)
给定两个整数 n 和 k,返回 1 … n 中所有可能的 k 个数的组合
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
在该例子中不需要设置isused
数组来记录哪些数字被使用过了,因为组合和排列不同,对于组合而言,[1, 2]和[2, 1]是同一个组合,而对于排列而言, 则是不同的排列
完整程序
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
if n == [] or k>n:
return []
path = []
result = []
start = 1
self.digui(path, result, start, k, n)
return result
def digui(self, path, result, start, k, n):
if len(path) == k:
result.append(path[:])
return
for i in range(start, n+1):
path.append(i)
start += 1
self.digui(path, result, start, k, n)
path.pop()
4. 示例3 (回溯+状态重置+剪枝)
给定一个可包含重复数字的序列,返回所有不重复的全排列。
输入: [1,1,2]
输出:
[
[1,1,2],
[1,2,1],
[2,1,1]
]
此处题目要求找出所有不重复的全排列, 即要求去重,所以在回溯法中必须剪枝以达到去重效果,程序如下:
class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
res = []
pre = []
isused = [False]*len(nums)
# 先进行排序
nums.sort()
self.digui(nums, isused, pre, res)
return res
def digui(self, nums, isused, pre, res):
if len(pre) == len(nums):
res.append(pre.copy())
return
for i in range(len(nums)):
# 增加条件剪枝去重
if i>0 and nums[i]==nums[i-1] and isused[i-1]==False or isused[i]:
continue
else:
isused[i]=True
pre.append(nums[i])
self.digui(nums, isused, pre, res)
isused[i] = False
pre.pop()
总体思路就是先将列表元素排序,然后按照示例1方法回溯查找所有排列,增加条件nums[i]==nums[i-1] and isused[i-1]==False
进行剪枝, 为什么该条件能够剪枝,自己画树图模拟查找过程即可发现
5. 总结
先画图,画图是非常重要的,只有画图才能帮助我们想清楚递归结构,想清楚如何剪枝。在画图的过程中思考清楚:
(1)分支如何产生;
(2)题目需要的解在哪里?是在叶子结点、还是在非叶子结点、还是在从跟结点到叶子结点的路径?
(3)哪些搜索是会产生不需要的解的?例如:产生重复是什么原因,如果在浅层就知道这个分支不能产生需要的结果,应该提前剪枝,剪枝的条件是什么,代码怎么写?