学透回溯算法

谁践踏了优雅 2022-09-03 07:25 163阅读 0赞

## 从一道题目入手 ##

[组合][Link 1]

给定两个整数n和 k，返回范围 \[1, n\] 中所有可能的k个数的组合。

你可以按任何顺序返回答案。  
示例1  
输入：n = 4, k = 2  
输出：  
\[  
\[2,4\],  
\[3,4\],  
\[2,3\],  
\[1,2\],  
\[1,3\],  
\[1,4\],  
\]

示例 2  
输入：n = 1, k = 1  
输出：\[\[1\]\]

提示：  
1 <= n <= 20  
1 <= k <= n

本题是回溯法的经典题目。  
直接的解法当然是使用for循环，例如示例中k为2，很容易想到用两个for循环，这样就可以输出和示例中一样的结果。

int n = 4;
    for (int i = 1; i <= n; i++) { 
        for (int j = i + 1; j <= n; j++) { 
            cout << i << " " << j << endl;
        }
    }

输入：n = 100, k = 3  
那么就三层for循环，代码如下：

int n = 100;
    for (int i = 1; i <= n; i++) { 
        for (int j = i + 1; j <= n; j++) { 
            for (int u = j + 1; u <= n; n++) { 
                cout << i << " " << j << " " << u << endl;
            }
        }
    }

如果n为100，k为50呢，那就50层for循环，是不是开始窒息。此时就会发现虽然想暴力搜索，但是用for循环嵌套连暴力都写不出来！

咋整？

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

上面我们说了要解决n为100，k为50的情况，暴力写法需要嵌套50层for循环，那么回溯法就用递归来解决嵌套层数的问题。

递归来做层叠嵌套（可以理解是开k层for循环），每一次的递归中嵌套一个for循环，那么递归就可以用于解决多层嵌套循环的问题了。

此时递归的层数大家应该知道了，例如：n为100，k为50的情况下，就是递归50层。

如果脑洞模拟回溯搜索的过程，绝对可以让人窒息，所以需要抽象图形结构来进一步理解。

把组合问题抽象成树结构如下图

![990cb3e2e2834418bc5c456e054930fa.png][]

可以看出这个棵树，一开始集合是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\] ）。

为什么要有这个startIndex呢？每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex。

从下图中红线部分可以看出，在集合\[1,2,3,4\]取1之后，下一层递归，就只能在\[2,3,4\]中取数了，那么下一层递归如何知道从\[2,3,4\]中取数呢，靠的就是startIndex。

![16903f0a1fe44849bb8f495bcb954368.png][]

所以需要startIndex来记录下一层递归，搜索的起始位置。  
那么整体代码如下：

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

2、回溯终止条件

什么时候到达所谓的叶子节点了呢？

path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。

如图红色部分：

![5bba6567a64d476798959cee627ca491.png][]

此时用result二维数组，把path保存起来，并终止本层递归。

所以终止条件代码如下：

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

3、单层搜索过程

回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。  
![92da040cb3f0476ea18e06a4f6bd306a.png][]

如此我们才遍历完图中的这棵树。

for循环每次从startIndex开始遍历，然后用path保存取到的节点i。

代码如下：

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;
        }
    };

## 剪枝优化 ##

我们说过，回溯法虽然是暴力搜索，但也有时候可以有点剪枝优化一下的。

在遍历的过程中有如下代码：

for (int i = startIndex; i <= n; i++) {  
        path.push_back(i); 
        backtracking(n, k, i + 1); 
        path.pop_back(); 
    }

这个遍历的范围是可以剪枝优化的，怎么优化呢？

来举一个例子，n = 4，k = 4的话，即集合是\[1,2,3,4\]，那么第一层for循环的时候，从元素2开始的遍历都没有意义了，因为从2开始最多只能选到\[2,3,4\]不足4个，永远不会进入path.size() == k这个条件中， 在第二层for循环，从元素3开始的遍历也没有意义了

因此可以归纳出以下公式：

搜索起点的上界 + 接下来要选择的元素个数 - 1 = n

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

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

其中，接下来要选择的元素个数 = k - path.size()，整理得到。

搜索起点的上界 = n - (k - path.size()) + 1

所以，我们的剪枝过程就是：把 i <= n 改成 i <= n - (k - path.size()) + 1

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

优化之后的回溯函数如下：

void backtracking(int n, int k, int startIndex) { 
         if (path.size() == k) { 
             result.push_back(path);
             return;
         }
         for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {  // 优化的地方
             path.push_back(i); // 处理节点 
             backtracking(n, k, i + 1);
             path.pop_back(); // 回溯，撤销处理的节点
         }
     }

## 总结 ##

组合问题是回溯法解决的经典问题，我们开始的时候给大家列举一个很形象的例子，就是n为100，k为50的话，直接想法就需要50层for循环。

从而引出了回溯法就是解决这种k层for循环嵌套的问题。然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。

接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。最后准对求组合问题的回溯法代码做了剪枝优化，这个优化如果不画图的话，其实不好理解，也不好讲清楚。

经典的回溯算法模板伪代码如下：

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

回溯算法力扣题目总结

*  组合问题  
    77.组合  
    77.组合（剪剪枝）  
    216.组合总和III  
    17.电话号码的字母组合  
    39.组合总和  
    40.组合总和II
 *  分割问题  
    131.分割回文串  
    93.复原IP地址
 *  子集问题  
    78.子集  
    90.子集II
 *  排列问题  
    46.全排列  
    47.全排列II
 *  棋盘问题  
    51.N皇后  
    37.解数独

[Link 1]: https://leetcode-cn.com/problems/combinations/
[990cb3e2e2834418bc5c456e054930fa.png]: /images/20220829/b2d444be71c34fa59599bfed794ed4ad.png
[16903f0a1fe44849bb8f495bcb954368.png]: /images/20220829/9b4f6011e3b94e18ad11db2419513178.png
[5bba6567a64d476798959cee627ca491.png]: /images/20220829/8f1bc5cda1864668a77c1d453c99a2d6.png
[92da040cb3f0476ea18e06a4f6bd306a.png]: /images/20220829/ed409811aa8b4ce3bf4e9b653bcde2e1.png