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

news2024/11/14 18:56:06

回溯章节理论基础：

https://programmercarl.com/%E5%9B%9E%E6%BA%AF%E7%AE%97%E6%B3%95%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

216.组合总和III

题目链接：https://leetcode.cn/problems/combination-sum-iii/

思路:

本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。
对于昨天做的77.组合而言，多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1…9]，本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。
选取过程如图：
在这里插入图片描述
因为这道题的话，多了一个要求和，所以传入的参数里面多了一个sum。
终止条件就是，如果path.size() 和 k相等了，就终止。
如果此时path里收集到的元素和（sum）和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

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

剪枝：

（1）如果已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。
（2）for循环的范围也可以剪枝，i <= 9 - (k - path.size()) + 1就可以了。k - path.size() 就代表剩余还要选多少个数，比如我们这里k=5，那么取7，取8都没有意义了，因为这个时候往后再取，也取不到5个数。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> paths = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(n,k,1,0);
        return result;
    }

    public void backtracking(int n, int k, int startIndex, int sum){
        if(sum > n) return ;

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

        // 对取k个数，这里也进行剪枝
        for(int i=startIndex; i <= 9-(k-paths.size()) + 1; i++){
            paths.add(i);
            sum = sum + i;
            backtracking(n, k, i+1, sum);
            sum = sum - i;
            paths.removeLast();
        }
    }
}

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

17.电话号码的字母组合

首先是数字和字母如何映射的问题，这里可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射。
在这里插入图片描述
遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。

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

再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。这个参数可不是startIndex了，而是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

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

那么终止条件就是如果index 等于输入的数字个数（digits.size）了。然后收集结果，结束本层递归。

class Solution {
    String[] letterMap = {
        "",   // 0
        "",   // 1
        "abc",  // 2
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz"
    };
    List<String> result = new ArrayList<>();  
    StringBuilder s = new StringBuilder();    // 每次迭代的字符串拼接
    public List<String> letterCombinations(String digits) {
        // 特殊情况：用例2 输入：digits = "" 输出：[]
        if(digits == null || digits.length() == 0)
            return result;
        backtracking(digits,0);
        return result;
    }

    public void backtracking(String digits, int index){
        if(index ==digits.length()){
            result.add(s.toString());
            return ;
        }
        int digit = digits.charAt(index) - '0';    // 类型转换成int
        String letters = letterMap[digit];  // 数字对应的字母组合
        for(int i=0;i<letters.length();i++){
            s.append(letters.charAt(i));
            backtracking(digits,index+1);
            s.deleteCharAt(s.length() - 1);
        }
    }
}