代码随想录算法训练营第22天| LeetCode77. 组合 | 216.组合总和III | 17.电话号码的字母组合

目录

[回溯算法：带你学透回溯算法（理论篇）| 回溯法精讲！_哔哩哔哩_bilibili](#回溯算法：带你学透回溯算法（理论篇）| 回溯法精讲！_哔哩哔哩_bilibili)

[题目链接：77. 组合 - 力扣（LeetCode）](#题目链接：77. 组合 - 力扣（LeetCode）)

[题目链接：216. 组合总和 III - 力扣（LeetCode）](#题目链接：216. 组合总和 III - 力扣（LeetCode）)

[题目链接：17. 电话号码的字母组合 - 力扣（LeetCode）](#题目链接：17. 电话号码的字母组合 - 力扣（LeetCode）)

---

"你和喜欢的人，一起看晚霞。我和晚霞一起，看喜欢的人。"

回溯算法：带你学透回溯算法（理论篇）| 回溯法精讲！_哔哩哔哩_bilibili

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。回溯是递归的副产品，只要有递归就会有回溯。

代码随想录相关内容讲解：代码随想录 (programmercarl.com)

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

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

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

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

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

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

题目链接：77. 组合 - 力扣（LeetCode）

要生成范围 [1,𝑛]中所有可能的 𝑘 个数的组合，生成组合、排列等问题使用回溯法（Backtracking）来解决。

回溯法的基本思路：

1. 选择：在每一步中选择一个数，并递归地生成后续的组合。
2. 约束：确保选择的数满足组合的要求，即不能重复，并且组合长度为 𝑘。
3. 结束条件：当组合的长度达到 𝑘 时，将组合加入结果集。

回溯法的具体实现：

1. 定义一个辅助函数来进行递归。
2. 使用一个列表 combination 来存储当前的组合。
3. 当组合的长度达到 𝑘 时，将其加入结果集。
4. 递归地选择下一个数，直到所有组合生成完毕。

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> combination = new ArrayList<>();
        backtrack(result, combination, n, k, 1);
        return result;
    }


    private void backtrack(List<List<Integer>> result, List<Integer> combination, int n, int k, int start) {
        // 如果当前组合的长度达到了k，加入结果集
        if (combination.size() == k) {
            result.add(new ArrayList<>(combination));
            return;
        }

        // 从start到n递归选择下一个数
        for (int i = start; i <= n; i++) {
            combination.add(i); // 选择数i
            backtrack(result, combination, n, k, i + 1); // 递归生成后续组合
            combination.remove(combination.size() - 1); // 回溯，撤销选择
        }
    }
}

题目链接：216. 组合总和 III - 力扣（LeetCode）

本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

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

选取过程如图：

算法思路：

1. 选择：在每一步中选择一个数，并递归地生成后续的组合。
2. 约束 ：确保选择的数满足组合的要求，即不能重复，组合长度为 k，并且组合的和为 n。
3. 结束条件 ：当组合的长度达到 k 并且组合的和为 n 时，将组合加入结果集。
4. 剪枝 ：如果当前组合的和已经超过 n 或组合的长度已经超过 k，则不再继续递归。

class Solution216 {
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> combination = new ArrayList<>();
        backtrack(result, combination, k, n, 1);
        return result;
    }

    private void backtrack(List<List<Integer>> result, List<Integer> combination, int k, int n, int start) {
        // 如果当前组合的长度达到了k且和为n，加入结果集
        if (combination.size() == k && n == 0) {
            result.add(new ArrayList<>(combination));
            return;
        }

        // 如果当前组合长度已经达到k或和已经超过n，直接返回
        if (combination.size() >= k || n < 0) {
            return;
        }

        // 从start到9递归选择下一个数
        for (int i = start; i <= 9; i++) {
            combination.add(i); // 选择数i
            backtrack(result, combination, k, n - i, i + 1); // 递归生成后续组合
            combination.remove(combination.size() - 1); // 回溯，撤销选择
        }
    }
}

题目链接：17. 电话号码的字母组合 - 力扣（LeetCode）

使用 Map 将每个数字 映射到对应的字母集合；使用后回溯法来解决n个for循环的问题，例如：输入："23"，抽象为树形结构，如图所示：

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

算法步骤：

1. 数字到字母的映射：根据电话按键，将每个数字映射到对应的字母集合。
2. 回溯：使用回溯法生成所有可能的字母组合。
3. 结束条件：当生成的组合长度等于输入数字字符串的长度时，将该组合加入结果列表。
4. 选择和撤销选择：递归地选择每个数字对应的字母，并在递归返回时撤销选择。

class Solution17 {
    // 静态映射，初始化电话按键对应的字母
    private static final Map<Character, String> phoneMap = new HashMap<>();

    static {
        phoneMap.put('2', "abc");
        phoneMap.put('3', "def");
        phoneMap.put('4', "ghi");
        phoneMap.put('5', "jkl");
        phoneMap.put('6', "mno");
        phoneMap.put('7', "pqrs");
        phoneMap.put('8', "tuv");
        phoneMap.put('9', "wxyz");
    }

    public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        if (digits == null || digits.length() == 0) {
            return result; // 如果输入为空，返回空列表
        }
        backtrack(result, new StringBuilder(), digits, 0);  // 调用回溯方法，生成组合
        return result;
    }

    private void backtrack(List<String> result, StringBuilder combination, String digits, int index) {
        // 如果组合的长度等于输入数字字符串的长度，加入结果列表
        if (index == digits.length()) {
            result.add(combination.toString());
            return;
        }

        // 获取当前数字对应的字母集合
        char digit = digits.charAt(index);
        String letters = phoneMap.get(digit);
        // 遍历每个字母
        for (char letter : letters.toCharArray()) {
            combination.append(letter); // 选择一个字母
            backtrack(result, combination, digits, index + 1); // 递归处理下一个数字
            combination.deleteCharAt(combination.length() - 1); // 撤销选择
        }
    }
}