代码随想录训练营day25, 组合总和III, 电话号码的字母总和

组合总和III

和上一题很像,还需要一个targetSum用来比较

1. 终止条件这里有两个:一是要到叶子节点,而是要targetSum = sum
2. 单层递归里的逻辑要有sum += i;
3. 这里的剪枝也有两个:
   1. 如果取的sum大于targetSum, 那么就没必要继续递归了
   2. 也要符合k个数的条件,for循环边界9 - (k - path.size()) + 1

(细节: 一定要记住for循环里是小于等于啊!!! <=; 同时回溯这里sum也要) 

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

    public void dfs(int targetSum, int k, int sum, int startIndex){
        //一开始先剪个枝
        if(sum > targetSum){
            return;
        }
        //终止条件
        if(path.size() == k){
            if(sum == targetSum){
                res.add(new ArrayList<>(path));
                return;
            }
        }
        //开始递归循环,有第二个剪枝
        for(int i = startIndex; i <= 9 - (k - path.size()) + 1; i++){
            path.add(i);
            sum += i;
            dfs(targetSum, k, sum, i + 1);
            //sum也要回溯哦
            path.remove(path.size() - 1);
            sum -= i;
        }
    }
}

电话号码的字母总和

这里需要一个字符数组,HashMap来保存电话映射

这里是两个组合,所以不需要startIndex

思路:

1. 还是需要一个res,不过是字符串集合, 还要stringbuilder path用来迭代时获得字符串, 还要一个string[]把题目的内容输入, index是用来做下标
2. 这里的终止方法就是当index为空时
3. 单层回溯时,先要找到digit,作为题目digits里的数字,然后根据digit数字去找到字母, 再开始回溯

(这里涉及到很多stringbuilder的操作, 包括toString, charAt, deleteCharAt等等)

class Solution {
    //先创建一个数组集合
    List<String> res = new ArrayList<>();
    //每次迭代会获取一个字符串,所以使用stringbuilder
    StringBuilder path = new StringBuilder();
    public List<String> letterCombinations(String digits) {
        //先可以给这个数组剪枝
        if(digits.length() == 0){
            return res;
        }
        //然后把电话键盘输入到string数组里面, 根据下标,这里0,1直接为空
        String[] numString = {"", "", "abc","def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        backtracking(digits, numString, 0);
        return res;
        } 
    
    //开始写回溯方法, index就是下标
    public void backtracking(String digits, String[] numString, int index){
        //这里的终止条件:如果index指到了digits字符串的空位,则说明遍历完了
        if(index == digits.length()){
            //细节:一添加回溯获得的字符串,再转换为string
            res.add(path.toString());
            return;
        }
        //先找到题目digits里的数字
        int digit = digits.charAt(index) - '0';
        //根据找到的数字,再到numString字符数组里去找字母
        String letter = numString[digit];
        //正式开始回溯,这里是从两个集合里取,所以不需要startIndex去重
        for(int i = 0; i < letter.length(); i++){
            path.append(letter.charAt(i));
            backtracking(digits, numString, index + 1);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

关于回溯,什么时候startIndex + 1, 什么时候是i + 1;

其实可以发现i + 1是因为他只有一个数组,所以每次Index都是变的, 而第二种情况, 有两个集合, index是不变的, 所以就直接index + 1;