代码随想录学习Day 21

回溯算法理论基础

回溯法又叫回溯搜索法。回溯是递归的副产品，有递归就会有回溯，回溯操作一般出现在递归函数的下面。回溯函数 == 递归函数。回溯法的本质是穷举。

回溯法解决的问题：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等

回溯法解决的问题都可以抽象为树形结构，因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度构成了树的深度。

回溯法模板

回溯三部曲：

1.回溯函数参数及返回值：回溯函数命名一般为backtracking，函数返回值一般为void。对于参数，因为回溯算法需要的参数不容易确定，所以一般先写逻辑，然后需要什么参数就填什么参数。

def backtracking(参数) -> void:

2.回溯函数终止条件：回溯问题一般是树形结构，一般来说搜到叶子节点，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。

if 终止条件:
    存放结果
    return

3.回溯函数遍历过程：回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。过程如图：

for 选择：本层集合中元素(树中节点孩子的数量就是集合的大小):
    处理节点
    backtracking(路径，选择列表)  # 递归
    回溯，撤销处理结果

for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。backtracking这里自己调用自己，实现递归。从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。

回溯算法模板框架如下：

def backtracking(参数):
    if 终止条件:
        存放结果
        return

    for 选择:本层集合中元素(树中节点孩子的数量就是集合的大小)
        处理节点
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果

77.组合

题目链接

讲解链接

本题如果使用暴力解法，则需要嵌套k层for循环，当k值较大时完全无法实现，所以需要使用回溯法来解决。本题可以抽象为以下树形结构：

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。图中可以发现n相当于树的宽度，k相当于树的深度。图中每次搜索到了叶子节点，我们就找到了一个结果。相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

回溯三部曲：

1.递归函数参数及返回值：参数一定要有n，k，以及一个startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。除此之外还需要两个全局变量result和path，前者用来保存符合条件的结果的集合，后者则用来保存符合条件的单一结果。

def __init__(self):
    self.path = []
    self.result = []
def backtracking(n, k, start_index):

2.递归终止条件：path这个数组的大小如果达到k，就说明找到了一个子集大小为k的组合，在树中path存的就是根节点到叶子节点的路径。这时候将path中的结果传入result中。

if len(path) == k:
    result.append(paht[:])
    return

3.单层递归逻辑：for循环从startindex开始遍历，用path保存取到的元素i，backtracking递归调用自己向深处遍历，遇到叶子节点则返回。

for i in range(startindex, n + 1):
    path.append(i)
    backtracking(n, k, i + 1)
    path.pop()

整体代码如下：

class Solution:
    def __init__(self):
        self.path = []  # 保存符合条件的单一结果
        self.result = []  # 保存符合条件的结果集合
    def backtracking(self, n, k, start_index):  # 回溯函数
        if len(self.path) == k:  # 终止条件
            self.result.append(self.path[:])  # 将结果添加到result中
            return
        for i in range(start_index, n + 1):  # 从startindex开始遍历，对应树的横向遍历
            self.path.append(i)  # 处理节点
            self.backtracking(n, k, i + 1)  # 递归，对应树的纵向遍历，下一层要从i+1开始，防止出现重复元素
            self.path.pop()  # 回溯，撤销处理的节点
    def combine(self, n: int, k: int) -> List[List[int]]:
        self.backtracking(n, k, 1)
        return self.result

当n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。 如图所示：

 

可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。如果for循环选择的起始位置之后的元素个数已经不足我们需要的元素个数了，那么就没有必要搜索了。

优化过程如下：

1. 已经选择的元素个数：len(path)

2. 所需需要的元素个数为: k - len(path)

3. 列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）

4. 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历

剪枝版本：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []  # 存放结果集
        self.backtracking(n, k, 1, [], result)
        return result
    def backtracking(self, n, k, startIndex, path, result):
        if len(path) == k:
            result.append(path[:])
            return
        for i in range(startIndex, n - (k - len(path)) + 2):  # 优化的地方,range函数是右开的，所以是+2
            path.append(i)  # 处理节点
            self.backtracking(n, k, i + 1, path, result)
            path.pop()  # 回溯，撤销处理的节点