代码随想录算法训练营Day27 | 回溯算法理论基础、77.组合、216.组合总和Ⅲ、17.电话号码的字母组合

目录

回溯算法理论基础

77.组合

216.组合总和Ⅲ

17.电话号码的字母组合

回溯算法理论基础

视频讲解：带你学透回溯算法（理论篇）| 回溯法精讲！

代码随想录：回溯算法理论基础

回溯函数与递归函数指的是同一个函数，回溯的本质是穷举所有可能，最后得到想要的答案。

回溯法可用于解决如下问题：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等等

注：组合无序，排列有序

回溯法解决的问题可以抽象为树形结构，因为回溯法解决的都是在集合中递归查找子集的问题，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。

回溯算法代码模板如下：

void backtrack(参数) {
    if (满足终止条件) {
        //记录结果
        return;
    }
    for (选择 : 当前所有可能的选择) {
        // 处理节点
        修改当前状态；
        // 递归地进行下一步选择
        backtrack(路径, 新的参数);
        // 回溯
        恢复到之前的状态；
    }
}

77.组合

题目

77. 组合 - 力扣（LeetCode）

给定两个整数 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

思路

视频讲解：LeetCode：77.组合

视频讲解：LeetCode：77.组合 剪枝优化

代码随想录：77.组合

如果解决一个问题有多个步骤，每一个步骤有多种方法，题目中找出所有的方法，可以使用回溯算法，回溯算法是在一棵树上的 深度优先遍历 。

组合问题不要求一个组合内元素的顺序，因此很多时候需要按某种顺序展开搜索，才能做到不重不漏。

回溯算法首先需要画出递归树，如图：

n相当于数的宽度，k相当于树的深度，每当搜索到叶子节点，就得到一个结果。

剪枝优化： 当 n = 4，k = 4 时，第一层for循环时从元素2开始的遍历就没有意义了，如图：

图中每一个节点代表本层的一个for循环，每一层的for循环从第二个数开始的遍历都是无效遍历。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置，如果for循环选择的起始位置之后的元素个数少于需要的元素个数，就没有必要继续搜索了。

题解

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

    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);
        return res;
    }

    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            res.add(new ArrayList<>(path));
            return;
        }
        //优化处，原为 i <= n
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            path.add(i);
            backtracking(n, k, i + 1);
            path.removeLast();
        }
    }
}

216.组合总和Ⅲ

题目

216. 组合总和 III - 力扣（LeetCode）

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

• 只使用数字1到9
• 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例1：

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例2：

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例3：

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

• 2 <= k <= 9
• 1 <= n <= 60

思路

代码随想录：216.组合总和Ⅲ

视频讲解：LeetCode：216.组合总和Ⅲ

剪枝有两种情况：

1. 剩余和小于当前数
2. 剩余元素不足以满足组合数量

题解

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

    public List<List<Integer>> combinationSum3(int k, int n) {
        backtrack(k, n, 1);
        return res;
    }

    void backtrack(int k, int n, int startIndex) {
        if (path.size() == k) {
            if (n == 0)
                res.add(new ArrayList(path));
            return;
        }
        for (int i = startIndex; i <= 9; i++) {
            if (n < i || path.size() + (9 - i + 1) < k) {
                break; // 剪枝：如果剩余和小于当前数，或者剩余元素不足以满足组合数量，直接跳出循环
            }
            path.add(i);
            backtrack(k, n - i, i + 1);
            path.removeLast();
        }
    }
}

17.电话号码的字母组合

题目

17. 电话号码的字母组合 - 力扣（LeetCode）

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

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

示例1：

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

示例2：

输入：digits = ""
输出：[]

示例3：

输入：digits = "2"
输出：["a","b","c"]

提示：

• 0 <= digits.length <= 4
• digits[i] 是范围 ['2', '9'] 的一个数字。

思路

代码随想录：17.电话号码的字母组合

视频讲解：LeetCode：17.电话号码的字母组合

使用 HashMap 存放数字和字母之间的映射。

树形结构如下：

题解

class Solution {
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    public List<String> letterCombinations(String digits) {
        //digits为空字符串时返回null
        if (digits.length() == 0)
            return res;
        Map<Character, String> map = Map.of(
                '2', "abc",
                '3', "def",
                '4', "ghi",
                '5', "jkl",
                '6', "mno",
                '7', "pqrs",
                '8', "tuv",
                '9', "wxyz"
        );
        backtrack(digits, 0, map);
        return res;
    }

    void backtrack(String digits, int index, Map<Character, String> map) {
        if (index == digits.length()) {
            res.add(sb.toString());
            return;
        }
        char ch = digits.charAt(index);
        String str = map.get(ch);
        
        for (int i = 0; i < str.length(); i++) {
            sb.append(str.charAt(i));
            backtrack(digits, index + 1, map);
            sb.deleteCharAt(sb.length() - 1);
        }
    }
}