代码随想录第二十四天 | 回溯：理论基础，组合问题以及剪枝（leetcode 77）

题目分类

1、回溯算法理论基础

1.1 什么是回溯

回溯法也可以叫做回溯搜索法，它是一种搜索的方式

在二叉树系列中，我们已经不止一次，提到了回溯，例如leetcode 257，因为使用了递归，其实还隐藏着回溯
回溯是递归的副产品，只要有递归就会有回溯

所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数

1.2 回溯法的效率

回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质

1.3 回溯解决的问题

回溯法，一般可以解决如下几种问题：
组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式（组合无序，排列有序）
棋盘问题：N皇后，解数独等等

1.4 直观理解回溯法

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

递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）

1.5 回溯三部曲

1、回溯函数模板返回值以及参数
回溯算法中函数返回值一般为void
再来看一下参数，因为回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数

回溯函数伪代码如下：

void backtracking(参数)

2、回溯函数终止条件
既然是树形结构，那么我们在讲解二叉树的递归的时候，就知道遍历树形结构一定要有终止条件
所以回溯也有要终止条件

什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归

所以回溯函数终止条件伪代码如下：

if (终止条件) {
    存放结果;
    return;
}

3、回溯搜索的遍历过程
回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成了树的深度

注意图中，我特意举例集合大小和孩子的数量是相等的
回溯函数遍历过程伪代码如下：

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

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

分析完过程，回溯算法模板框架如下：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

1.6 总结

本篇我们讲解了，什么是回溯算法，知道了回溯和递归是相辅相成的
接着提到了回溯法的效率，回溯法其实就是暴力查找，并不是什么高效的算法
然后列出了回溯法可以解决几类问题，可以看出每一类问题都不简单
最后我们讲到回溯法解决的问题都可以抽象为树形结构（N叉树），并给出了回溯法的模板

2、组合问题

2.1 leetcode 77：组合

第一遍代码
start标记起点，kk标记还剩下多少个元素

if(start > n) {
	return;
}

不能加，因为小集合的最后一个元素正好是大集合的最后一个元素的情况就会丢失
因为在这种情况下，kk == 0时肯定start > n了，当判断完kk == 0后for进不去直接return了

这么写，kk == 1的时候cur.push_back(start)再将cur加入res是错的
有两个错：首先如果大集合最后一个元素小集合正好差一个，就会在结果中出现超过限制的值
其次，这里对cur操作没有加入把里面的元素弹出（回溯）！
比如输入4，2，最后结果就会是[[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5]]
不停往里面加东西却没有对元素弹出

------>>> 所以应该避免在别处对需要回溯的元素有操作

class Solution {
public:
    vector<vector<int>> res;
    void backTracking(int start, int n, int kk, vector<int>& cur) {
    //start标记起点，Kk标记还剩下多少个元素
        /* if(start > n) {
             return;
         }
         不能加，因为小集合的最后一个元素正好是大集合的最后一个元素的情况就会丢失(考虑只取一个元素，正好最后一个元素符合要求)
         因为在这种情况下，kk == 0时肯定start > n了，当判断完kk == 0后for进不去直接return了,从而缺失了记录的过程（记录是在进去两个数之后）
         */
        if(kk == 0) {
            res.push_back(cur);
            return;
        }
        /*
        这么写，kk == 1的时候cur push_back(start)再将cur加入res是错的
        有两个错：首先如果大集合最后一个元素小集合正好差一个，就会在结果中出现超过限制的值
        其次，这里对cur操作没有加入把里面的元素弹出（回溯）！比如4，2就会[[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5]]
        不停往里面加东西却没有对元素弹出
        **所以应该避免在别处对需要回溯的元素有操作
        */
        for(int i = start; i <= n; i++) {
            cur.push_back(i);
            backTracking(i + 1, n, kk - 1, cur);//回溯kk, i
            cur.pop_back();//回溯cur
            
        }
        return;
    }
    vector<vector<int>> combine(int n, int k) {
        vector<int> tmp;
        backTracking(1, n, k, tmp);
        return res;
    }
};

回溯搜索法来了，虽然回溯法也是暴力，但至少能写出来，不像for循环嵌套k层让人绝望
那么回溯法怎么暴力搜呢？

上面我们说了要解决 n为100，k为50的情况，暴力写法需要嵌套50层for循环，那么回溯法就用递归来解决嵌套层数的问题
递归来做层叠嵌套（可以理解是k层for循环），每一次的递归中嵌套一个for循环，那么递归就可以用于解决多层嵌套循环的问题了
此时递归的层数大家应该知道了，例如：n为100，k为50的情况下，就是递归50层

回溯法解决的问题都可以抽象为树形结构（N叉树），用树形结构来理解回溯就容易多了，那么我把组合问题抽象为如下树形结构：

可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取
第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推

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

回溯法三部曲
1、递归函数的返回值以及参数
在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合

代码如下：

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果

其实不定义这两个全局变量也是可以的，把这两个变量放进递归函数的参数里（第一遍代码放了一个），但函数里参数太多影响可读性，所以定义全局变量

函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数
然后还需要一个参数，为int型变量startIndex，这个参数用来记录本层递归中，集合从哪里开始遍历（集合就是[1,…,n] ），防止出现重复的组合
在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex

整体代码如下：

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)

2、回溯函数终止条件
什么时候到达叶子节点？
path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径
用result二维数组，把path保存起来，并终止本层递归

终止条件代码如下：

if (path.size() == k) {
    result.push_back(path);
    return;
}

第一遍代码就在这里栽了

3、单层搜索的过程
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历

代码如下：

for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
    path.push_back(i); // 处理节点
    backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    path.pop_back(); // 回溯，撤销处理的节点
}

backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回
backtracking的下面部分就是回溯的操作了，撤销本次处理的结果

组合问题 C++完整代码如下：

class Solution {
private:
    vector<vector<int>> result; // 存放符合条件结果的集合
    vector<int> path; // 用来存放符合条件结果
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n; i++) {
            path.push_back(i); // 处理节点
            backtracking(n, k, i + 1); // 递归
            path.pop_back(); // 回溯，撤销处理的节点
        }
    }
public:
    vector<vector<int>> combine(int n, int k) {
        result.clear(); // 可以不写
        path.clear();   // 可以不写
        backtracking(n, k, 1);
        return result;
    }
};

2.2 leetcode 77：剪枝优化（对for循环即横向遍历进行改进）

图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历
所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了

优化之后的for循环是：

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置