代码随想录算法day19 | 回溯算法part01 | 77. 组合，216.组合总和III，17.电话号码的字母组合

不是很强但是很秃

于 2024-08-21 14:48:29 发布

阅读量619

点赞数 20

分类专栏： LeetCode算法文章标签：算法数据结构 leetcode java 深度优先剪枝

本文链接：https://blog.csdn.net/m0_62415132/article/details/141386332

版权

LeetCode算法专栏收录该内容

30 篇文章 0 订阅

订阅专栏

第77题. 组合

对着在回溯算法理论基础给出的代码模板，来做本题组合问题，大家就会发现写回溯算法套路。

力扣题目链接(opens new window)

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]

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

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

代码如下：

int n = 4;
for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
        print('[' + i + ',' + j + ']');
    }
}

输入：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++) {
            print('[' + i + ',' + j + + ',' + u + ']');
        }
    }
}

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

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

咋整？

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

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

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

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

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

本来对递归就懵，回溯法中递归还要嵌套for循环，可能就直接晕倒了！

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

我们在代码随想录算法 | 回溯算法先导知识 | 题目分类，理论基础-CSDN博客中说过，回溯法解决的问题都可以抽象为树形结构（N叉树），用树形结构来理解回溯就容易多了。

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

77.组合

可以看出这棵树，一开始集合是 1，2，3，4，从左向右取数，取过的数，不再重复取。

第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。

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

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

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

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

在代码随想录算法 | 回溯算法先导知识 | 题目分类，理论基础-CSDN博客中我们提到了回溯法三部曲，按照回溯法三部曲开始讲解代码。

回溯法三部曲

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

在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。

代码如下：

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

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

函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数。

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

为什么要有这个 startIndex 呢？

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

77.组合2

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

那么整体代码如下：

List<List<Integer>> result= new ArrayList<>();  // 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();  // 用来存放符合条件单一结果
public List<List<Integer>> combine(int n, int k)

回溯函数终止条件

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

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

如图红色部分：

77.组合3

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

所以终止条件代码如下：

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

单层搜索的过程

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

77.组合1

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

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

代码如下：

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

可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。

backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

关键地方都讲完了，组合问题Java完整代码如下：

class Solution {
    List<List<Integer>> result= new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    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();
        }
    }
}

时间复杂度: O(n * 2^n)
空间复杂度: O(n)

总结

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

从而引出了回溯法就是解决这种k层for循环嵌套的问题。

然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。

接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。

剪枝优化

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

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

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

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

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。在第二层for循环，从元素3开始的遍历都没有意义了。

这么说有点抽象，如图所示：

77.组合4

图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。

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

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

注意代码中 i，就是for循环里选择的起始位置。

for (int i = startIndex; i <= n; i++) {

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

已经选择的元素个数：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++) // 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;
    }

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

216.组合总和III

如果把组合问题理解了，本题就容易一些了。

力扣题目链接(opens new window)

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

所有数字都是正整数。
解集不能包含重复的组合。

示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]

示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。

相对于77.组合，无非就是多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,...,9]。

想到这一点了，做过77.组合之后，本题是简单一些了。

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

例如 k = 2，n = 4的话，就是在集合 [1,2,3,4,5,6,7,8,9] 中求 k（个数） = 2, n（和） = 4的组合。

选取过程如图：

216.组合总和III

图中，可以看出，只有最后取到集合（1，3）和为4 符合条件。

回溯三部曲

确定递归函数参数

和77.组合一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。

这里我依然定义 path 和 result为全局变量。

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

接下来还需要如下参数：

targetSum（int）：目标和，也就是题目中的n。
k（int）：就是题目中要求k个数的集合。
sum（int）：为已经收集的元素的总和，也就是path里元素的总和。
startIndex（int）：为下一层for循环搜索的起始位置。

所以代码如下：

List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int targetSum, int k, int startIndex, int sum)

其实这里sum这个参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，我这里为了直观便于理解，还是加一个sum参数。

还要强调一下，回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。

确定终止条件

什么时候终止呢？

在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。

所以如果path.size() 和 k相等了，就终止。

如果此时path里收集到的元素和（sum）和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

所以终止代码如下：

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

单层搜索过程

本题和77.组合区别之一就是集合固定的就是9个数[1,...,9]，所以for循环固定i<=9

如图：

216.组合总和III

处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。

代码如下：

for(int i = startIndex; i <= 9; i++) {
    path.add(i);
    sum += i;
    build(k, n, i + 1, sum);
    sum -= i;    // 回溯
    path.removeLast();    // 回溯
}

别忘了处理过程和回溯过程是一一对应的，处理有加，回溯就要有减！

参照代码随想录算法 | 回溯算法先导知识 | 题目分类，理论基础-CSDN博客的模板，不难写出如下Java代码：

class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        build(k, n, 1, 0);
        return ans;
    }

    private void build(int k, int n, int startIndex, int sum) {

        if (sum > n) return;

        if (path.size() > k) return;

        if (sum == n && path.size() == k) {
            ans.add(new ArrayList<>(path));
            return;
        }

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

剪枝

这道题目，剪枝操作其实是很容易想到了，想必大家看上面的树形图的时候已经想到了。

如图：

216.组合总和III1

已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。

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

if (sum > targetSum) { // 剪枝操作
    return;
}

当然这个剪枝也可以放在调用递归之前，即放在这里，只不过要记得要回溯操作给做了。

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

最后Java代码如下：

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

	public List<List<Integer>> combinationSum3(int k, int n) {
		backTracking(n, k, 1, 0);
		return result;
	}

	private void backTracking(int targetSum, int k, int startIndex, int sum) {
		// 减枝
		if (sum > targetSum) {
			return;
		}

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

		// 减枝 9 - (k - path.size()) + 1
		for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
			path.add(i);
			sum += i;
			backTracking(targetSum, k, i + 1, sum);
			//回溯
			path.removeLast();
			//回溯
			sum -= i;
		}
	}
}

时间复杂度: O(n * 2^n)
空间复杂度: O(n)

7.电话号码的字母组合

本题大家刚开始做会有点难度，先自己思考20min，没思路就直接看题解。

力扣题目链接(opens new window)

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

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

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

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

理解本题后，要解决如下三个问题：

数字和字母如何映射
两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
输入1 * #按键等等异常情况

数字和字母如何映射

可以使用map或者定义一个数组来做映射，我这里定义一个二维数组，代码如下：

String[] numString = {
            "",     // 0
            "",     // 1
            "abc",  // 2
            "def",  // 3
            "ghi",  // 4
            "jkl",  // 5
            "mno",  // 6
            "pqrs", // 7
            "tuv",  // 8
            "wxyz"};// 9

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

对于回溯法还不了解的同学看这篇：代码随想录算法 | 回溯算法先导知识 | 题目分类，理论基础-CSDN博客

例如：输入："23"，抽象为树形结构，如图所示：

17. 电话号码的字母组合

图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。

回溯三部曲：

确定回溯函数参数

首先需要一个字符串temp来收集叶子节点的结果，然后用一个字符串数组list保存起来，这两个变量我依然定义为全局。

再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的num。

注意这个 num 可不是 77.组合和216.组合总和Ⅲ 中的 startIndex 了。

这个 num 是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时 num 也表示树的深度。

代码如下：

List<String> list = new ArrayList<>();
//每次迭代获取一个字符串，所以会涉及大量的字符串拼接，所以这里选择更为高效的 StringBuilder
StringBuilder temp = new StringBuilder();
//比如digits如果为"23",num 为0，则str表示2对应的 abc
public void backTracking(String digits, String[] numString, int num)

确定终止条件

例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果 num 等于输入的数字个数（digits.size）了（本来 num 就是用来遍历digits的）。

然后收集结果，结束本层递归。

代码如下：

if (num == digits.length()) {
     list.add(temp.toString());
     return;
}

确定单层遍历逻辑

首先要取 num 指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：

//str 表示当前num对应的字符串
String str = numString[digits.charAt(num) - '0'];
for (int i = 0; i < str.length(); i++) {
    temp.append(str.charAt(i));
    //递归，处理下一层
    backTracking(digits, numString, num + 1);
    //剔除末尾的继续尝试
    temp.deleteCharAt(temp.length() - 1);
}

注意这里for循环，可不像是在 77.组合和 216.组合总和Ⅲ 中从startIndex开始遍历的。

因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而 77.组合和 216.组合总和Ⅲ 都是求同一个集合中的组合！

注意：输入1 * #按键等等异常情况

代码中最好考虑这些异常情况，但题目的测试数据中应该没有异常情况的数据，所以我就没有加了。

但是要知道会有这些异常，如果是现场面试中，一定要考虑到！

关键地方都讲完了，按照回溯法模板，不难写出如下Java代码：

class Solution {

    //设置全局列表存储最后的结果
    List<String> list = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return list;
        }
        //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        //迭代处理
        backTracking(digits, numString, 0);
        return list;

    }

    //每次迭代获取一个字符串，所以会涉及大量的字符串拼接，所以这里选择更为高效的 StringBuilder
    StringBuilder temp = new StringBuilder();

    //比如digits如果为"23",num 为0，则str表示2对应的 abc
    public void backTracking(String digits, String[] numString, int num) {
        //遍历全部一次记录一次得到的字符串
        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }
        //str 表示当前num对应的字符串
        String str = numString[digits.charAt(num) - '0'];
        for (int i = 0; i < str.length(); i++) {
            temp.append(str.charAt(i));
            //递归，处理下一层
            backTracking(digits, numString, num + 1);
            //剔除末尾的继续尝试
            temp.deleteCharAt(temp.length() - 1);
        }
    }
}

时间复杂度: O(3^m * 4^n)，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数
空间复杂度: O(3^m * 4^n)

不是很强但是很秃

关注

20
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法day19 | 回溯算法part01 | 77. 组合，216.组合总和III，17.电话号码的字母组合

组合问题是回溯法解决的经典问题，我们开始的时候给大家列举一个很形象的例子，就是n为100，k为50的话，直接想法就需要50层for循环。从而引出了回溯法就是解决这种k层for循环嵌套的问题。然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。
复制链接

扫一扫