⚡刷题计划day22 回溯（一）开始，此期开启回溯专题，敬请期待关注，可以点个免费的赞哦~

往期可看专栏，关注不迷路，

您的支持是我的最大动力🌹~

目录

回溯算法理论基础

回溯法解决的问题

如何理解回溯法

回溯法算法模板

题目一：77. 组合

回溯法三部曲

递归函数的返回值以及参数

回溯函数终止条件

单层逻辑

剪枝优化

题目二：216. 组合总和 III

初版

剪枝优化

优化1：

优化2：

优化后完整代码：

题目三：17. 电话号码的字母组合

---

参考代码随想录

回溯算法理论基础

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

回溯法的性能如何呢，这里要和大家说清楚了，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。

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

那么既然回溯法并不高效为什么还要用它呢？

因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。

此时大家应该好奇了，都什么问题，这么牛逼，只能暴力搜索。

回溯法解决的问题

回溯法，一般可以解决如下几种问题：

• 组合问题：N个数里面按一定规则找出k个数的集合

• 切割问题：一个字符串按一定规则有几种切割方式

• 子集问题：一个N个数的集合里有多少符合条件的子集

• 排列问题：N个数按一定规则全排列，有几种排列方式

• 棋盘问题：N皇后，解数独等等

相信大家看着这些之后会发现，每个问题，都不简单！

另外，会有一些同学可能分不清什么是组合，什么是排列？

组合是不强调元素顺序的，排列是强调元素顺序。

例如：{1, 2} 和 {2, 1} 在组合上，就是一个集合，因为不强调顺序，而要是排列的话，{1, 2} 和 {2, 1} 就是两个集合了。

记住组合无序，排列有序，就可以了。

如何理解回溯法

回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！

因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。

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

这块可能初学者还不太理解，后面的回溯算法解决的所有题目中，我都会强调这一点并画图举相应的例子，现在有一个印象就行。

回溯法算法模板

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

具体可结合例题进行理解

题目一：77. 组合

1. 组合

(https://leetcode.cn/problems/combinations/description/)

本题是回溯法的经典题目。

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

但如果n为100，k为50呢，那就50层for循环，是不是开始窒息。

此时就会发现虽然想暴力搜索，但是用for循环嵌套连暴力都写不出来！

咋整？

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

那么回溯法怎么暴力搜呢？

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

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

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

那么我把组合问题抽象为如下树形结构：

图中可以发现n相当于树的宽度，k相当于树的深度。

那么如何在这个树上遍历，然后收集到我们要的结果集呢？

图中每次搜索到了叶子节点，我们就找到了一个结果。

相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

回溯法三部曲

递归函数的返回值以及参数

首先我们需要定义两个全局变量，一个记录当前符合条件的路径，一个记录符合条件路径的集合。

LinkedList<Integer> path = new LinkedList<>();
List<List<Integer>> result = new ArrayList<>();

函数里至少还需要题目所给的两个参数，n,k。

然后还需要一个参数startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。

为什么要有这个startIndex呢？

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

所以需要startIndex来记录下一层递归，搜索的起始位置。

void backtracking(int n,int k,int startIndex)

回溯函数终止条件

到达叶子节点及到终点，

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

if(path.size()==k){result.add(new ArrayList<>(path));return;
}

单层逻辑

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

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

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

代码如下：

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

完整代码：

class Solution {
​LinkedList<Integer> path = new LinkedList<>();List<List<Integer>> result = new ArrayList<>();public List<List<Integer>> combine(int n, int k) {backtracking(n,k,1);return result;}public void backtracking(int n,int k,int startIndex){if(path.size()==k){result.add(new ArrayList<>(path));return;}
​for(int i=startIndex;i<=n;i++){path.add(i);backtracking(n,k,i+1);path.removeLast();}}
}

可以再对比一下前面给出的模板，是不是还挺像的。

剪枝优化

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

我们遍历时候的范围i<=n是可以剪枝优化的，怎么优化呢？

举个例子，比如n=4,k=4，组合就只有一个[1,2,3,4]，这时候再遍历，元素数量也没有四个，再循环就没有意义，如图理解：

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

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

接下来看一下优化过程如下：

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

2. 还需要的元素个数为: k - path.size();

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

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里大家想不懂的话，建议也举一个例子，就知道是不是要+1了。

所以优化之后的for循环是：

for(int i=startIndex;i<=n-(k-path.size())+1;i++)

优化后整体代码如下：

class Solution {
​LinkedList<Integer> path = new LinkedList<>();List<List<Integer>> result = new ArrayList<>();public List<List<Integer>> combine(int n, int k) {backtracking(n,k,1);return result;}public void backtracking(int n,int k,int startIndex){if(path.size()==k){result.add(new ArrayList<>(path));return;}
​for(int i=startIndex;i<=n-(k-path.size())+1;i++){path.add(i);//处理节点backtracking(n,k,i+1);path.removeLast();//回溯，撤销处理的节点}}
}

题目二：216. 组合总和 III

[216. 组合总和 III

(https://leetcode.cn/problems/combination-sum-iii/description/)

此题与上一题思路很像，多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,...,9]。

本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

直接看AC代码即可：

初版

class Solution {LinkedList<Integer> path = new LinkedList<>();List<List<Integer>> result = new ArrayList<>();int sum =0;public List<List<Integer>> combinationSum3(int k, int n) {backtracking(k,n,1);return result;}public void backtracking(int k,int n,int startIndex){if(path.size()==k){if(sum==n){result.add(new ArrayList<>(path));}return;}
​for(int i=startIndex;i<=9;i++){path.add(i);sum+=i;backtracking(k,n,i+1);path.removeLast();sum-=i;}}
}

剪枝优化

优化1：

和上题一样，for循环的范围可以剪枝，i <= 9 - (k - path.size()) + 1就可以了。

优化2：

如图可以发现，当我们sum已经大于n的时候，再往后遍历也就没意义了，直接剪掉。

那么剪枝的地方可以放在递归函数开始的地方，剪枝代码如下：

if(sum>n){return;
}

优化后完整代码：

class Solution {LinkedList<Integer> path = new LinkedList<>();List<List<Integer>> result = new ArrayList<>();int sum =0;public List<List<Integer>> combinationSum3(int k, int n) {backtracking(k,n,1);return result;
​}public void backtracking(int k,int n,int startIndex){if(sum>n){return;}if(path.size()==k){if(sum==n){result.add(new ArrayList<>(path));}return;}for(int i=startIndex;i<=9-(k-path.size())+1;i++){path.add(i);sum+=i;backtracking(k,n,i+1);path.removeLast();sum-=i;}}
}

题目三：17. 电话号码的字母组合

1. 电话号码的字母组合

(https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/)

从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。

如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环.......

大家应该感觉出和第一题遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。

首先定义一个String进行映射：

//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

回溯法来解决n个for循环的问题

详细见代码即可：

class Solution {List<String> result = new ArrayList<>();StringBuilder path = new StringBuilder();public List<String> letterCombinations(String digits) {if(digits==null || digits.length()==0) {return result;}int len = digits.length();//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};backTracking(digits,numString,0);return result;}public void backTracking(String digits,String[] numString,int numIndex){if(numIndex==digits.length()){result.add(path.toString());return;}String str = numString[digits.charAt(numIndex)-'0'];// 将numIndex指向的数字转为intfor(int i=0;i<str.length();i++){path.append(str.charAt(i));backTracking(digits,numString,numIndex+1);// 递归，注意numIndex+1，一下层要处理下一个数字了path.deleteCharAt(path.length()-1);}}}

点个免费的赞赞吧~