代码随想录算法训练营第24天 | 回溯算法part01 77. 组合
回溯的本质是穷举,穷举所有可能,然后选出我们想要的答案.
回溯是递归的副产品,只要有递归就会有回溯。
所以回溯函数也就是递归函数,指的都是一个函数。
虽然回溯法很难,很不好理解,但是回溯法并不是什么高效的算法。
如果想让回溯法高效一些,可以加一些剪枝的操作,但也改不了回溯法就是穷举的本质。
那么既然回溯法并不高效为什么还要用它呢?
因为没得选,一些问题能暴力搜索出来就不错了,撑死了再剪枝一下,还没有更高效的解法。
回溯法一般可以解决如下几种问题:
- 组合问题:N个数里面按一定规则找出k个数的集合
- 切割问题:一个字符串按一定规则有几种切割方式
- 子集问题:一个N个数的集合里有多少符合条件的子集
- 排列问题:N个数按一定规则全排列,有几种排列方式
- 棋盘问题:N皇后,解数独等等
关键:如何理解回溯法
回溯法解决的问题都可以抽象为树形结构,是的,所有回溯法的问题都可以抽象为树形结构!
因为回溯法解决的都是在集合中递归查找子集,集合的大小就构成了树的宽度,递归的深度,都构成的树的深度。
递归就要有终止条件,所以必然是一棵高度有限的树(N叉树)。
题目一
给定两个整数 n 和 k,返回 1 … n 中所有可能的 k 个数的组合。(不是排列,无序)
示例: 输入: n = 4, k = 2输出: [[2,4], [3,4], [2,3], [1,2], [1,3], [1,4] ]
本题只有暴力穷举法,但如何暴力穷举仍值得商讨。
如果用for循环,k为几就得用几层for循环,k非常大时,显然无法实现。
因此得考虑使用回溯。
虽然回溯法也是暴力,但至少能写出来,不像for循环嵌套k层让人绝望。
那么回溯法怎么暴力搜呢?
上面我们说了要解决 n为100,k为50的情况,暴力写法需要嵌套50层for循环,那么回溯法就用递归来解决嵌套层数的问题。
递归来做层叠嵌套(可以理解是开k层for循环),每一次的递归中嵌套一个for循环,那么递归就可以用于解决多层嵌套循环的问题了。
回溯法的搜索过程就是一个树型结构的遍历过程,在如下图中,可以看出for循环用来横向遍历,递归的过程是纵向遍历。
- 递归函数的返回值以及参数
在这里要定义两个全局变量数组
一个单层可变数组path,用来存放符合条件单一结果,
一个双层可变数组ans, 用来存放符合条件结果的集合。
函数里一定有两个参数,既然是集合n里面取k个数,那么n和k是两个int型的参数。
然后还需要一个参数,为int型变量startIndex,这个参数用来记录本层递归中,集合从给定数组的哪里开始遍历([1,…,n] )。
例如,在集合[1,2,3,4]取1之后,下一层递归,就要在[2,3,4]中取数了,那么下一层递归如何知道从[2,3,4]中取数呢,靠的就是startIndex。
- 终止条件
什么时候到达所谓的叶子节点了呢?
path这个数组的大小如果达到k,说明我们找到了一个子集大小为k的组合,path存的就是根节点到叶子节点的路径。然后将path存到ans中。
for循环每次从startIndex开始遍历,然后用path保存取到的节点i。
class Solution
{
public List<List<Integer>> ans = new ArrayList< List<Integer> >();
public LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> combine(int n, int k)
{
backtraining(n, k, 1);
return ans;
}
public void backtraining(int n, int k, int start)
{
//end
if(path.size() == k)
{
ans.add(new ArrayList(path) );
return;
}
//every
for(int i=start; i<=n; i++)//横向
{
path.add(i); // 处理节点
backtraining(n, k ,i + 1); // 递归:控制树的纵向遍历,注意下一层搜索要从i+1开始
path.removeLast(); // 回溯,撤销处理的节点
}
}
}
当然是暴力法,那么时间和空间复杂度都不低。
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
拓展:剪枝处理
本题在遍历数量上还可以进一步优化。
图中每一个节点就代表本层的一个for循环。
n=4,k=4的情况下,只有[1,2,3,4]这一种取法,
那么每一层的for循环从第二个数开始遍历的话,
比如第一层取2,后面只能取3,4两种情况,但需要取三个数,这不可能,
因此都没有意义,都是无效遍历。
所以,可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。
因为所剪去的分支下面还有分支,因此很有必要剪去。
上面我们已经选择了startindex,接下来剪枝的目的是减少终止时的位置。
如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了,那么就没有必要搜索了。
注意代码中i,就是for循环里选择的起始位置。
for (int i = startIndex; i <= n; i++) {
接下来看一下优化过程如下:
- 已经选择的元素个数:path.size();(path的长度)
- 还需要的元素个数为: k - path.size();
- 在集合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++) // i为本次搜索的起始位置
代码如下。
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
combineHelper(n, k, 1);
return result;
}
/**
* 每次从集合中选取元素,可选择的范围随着选择的进行而收缩,调整可选择的范围,就是要靠startIndex
* @param startIndex 用来记录本层递归的中,集合从哪里开始遍历(集合就是[1,...,n] )。
*/
private void combineHelper(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);
combineHelper(n, k, i + 1);
path.removeLast();
}
}
}