刷题计划 day22回溯（一）【组合】【组合总和 III】【电话号码的字母组合】

⚡刷题计划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. 组合

组合

(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循环选择的起始位置之后的元素个数已经不足我们需要的元素个数了，那么就没有必要搜索了。

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

已经选择的元素个数：path.size();
还需要的元素个数为: 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++)

优化后整体代码如下：

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. 电话号码的字母组合

电话号码的字母组合

(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指向的数字转为int
		for(int i=0;i<str.length();i++){
			path.append(str.charAt(i));
			backTracking(digits,numString,numIndex+1);// 递归，注意numIndex+1，一下层要处理下一个数字了
			path.deleteCharAt(path.length()-1);
		}
	}

}

点个免费的赞赞吧~