【代码训练营】day 25 | 216.组合总和III & 17.电话号码的字母组合

所用代码 java

组合总和III LeetCode 216

题目链接：组合总和III LeetCode 216 - 中等

思路

递归深度： 由k控制，宽度则是[1-9]。

用一个计数器count来自减，就不用传一个新的sum

回溯三部曲：

1. 确定递归参数和返回值
2. 确定回溯终止条件 – 剪枝操作
3. 单层递归逻辑

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k, n, 1);
        return res;
    }
​
    public void backtracking(int k, int count, int startIndex){
        if (count == 0 && path.size() == k){
            // 不能直接res.add(path) 因为path是全局变量，我们存的是引用地址，会一直变化
            res.add(new ArrayList<>(path));
            return;
        }
        // path存的数量大于了k就可以直接返回了
        if (path.size() > k) return;
        
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            count -= i;
            path.add(i);
            backtracking(k, count, i + 1);
            count += i;
            path.remove(path.size()-1);
        }
        return;
    }
}

总结

根据回溯三部曲以及框架就把代码写出来了，而且一下就过了。

剪枝操作：

1. 9 - (k - path.size()) + 1，若共需要3个数且path存了一个数，还需两个数，所以起始位置就不能大于8。
2. if (path.size() > k) return; 当存的数大于了k个时，就可以直接返回了。

注意：上面两个剪枝操作其实是类似的，因为上面这两个操作都控制着path.size()，一个是待加入元素的位置不能超过的起点，另一个是已经加入元素后path的长度。

其实上面的代码多递归了一层，比如只需要3个数，就可以直接在第3个数的时候判断并返回，没必要加入一个数，改进：

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k, n, 1);
        return res;
    }
​
    public void backtracking(int k, int count, int startIndex){
        // 剪枝：count<0时，就不用再继续减了，因为肯定不符合
        if (count < 0 ) return;
        
        // 直接在path.size()=k的时候return
        if (path.size() == k){
            if (count == 0){
                res.add(new ArrayList<>(path));
            }
            return;
        }
        
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            count -= i;
            path.add(i);
            backtracking(k, count, i + 1);
            count += i;
            path.remove(path.size()-1);
        }
        return;
    }
}

剪枝：

• if (count < 0 ) return; 当count<0时，就没必要再加入数据了，因为再加入数回一直变小，肯定小于0的。

电话号码的字母组合 LeetCode 17

题目链接：电话号码的字母组合 LeetCode 17 - 中等

思路

深度：输入数字的个数；宽度：每个数字的字母长度

class Solution {
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    //strNum下标[2-9]对应着数字2-9所含的字母
    String[] strNum = new String[]{
            "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs","tuv", "wxyz"
    };
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0){
            return list;
        }
        backtracking(digits, 0);
        return list;
    }
​
    public void backtracking(String digits, int index){
//        System.out.println("sb = " + sb);
        // 当搜索到最后是就退出
        if (digits.length() == index){
            list.add(sb.toString());
            return;
        }
        int num = digits.charAt(index) - '0';
//        System.out.println("num = " + num);
        String str = strNum[num];
        for (int i = 0; i < str.length(); i++){
            sb.append(str.charAt(i));
            // 每次传入的是index + 1，表明递归搜索的是下一组字母
            backtracking(digits, index + 1);
            sb.deleteCharAt(sb.length()-1);
        }
    }
}

总结

需搞清楚树的深度和宽度代表什么，才可以更容易析出递归。

index表示递归遍历到哪一个数字了，本题是n个集合里边遍历，不会出现重复，所以用index表示遍历的是那一个集合。