代码随想录训练营第二十二天 | 回溯 77. 组合 216.组合总和III17.电话号码的字母组合

77. 组合

不能重复的组合就是集合：使用startIndex即可横向遍历

1. 使用LinkedList可以移除最后一个元素
2. 剪枝：根据path的大小，动态调整范围——起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        result = new ArrayList<>();
        this.n = n;
        this.k = k;
        path = new ArrayList<>();
        backTracking(1);
        return result;
    }

    private List<List<Integer>> result;
    private int n;
    private int k;
    private List<Integer> path;
    
    private void backTracking(int start){ // 集合，不能有重复元素，因此可以从start开始

        if(path.size()==k) {
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i=start; i <= n + 1 - (k - path.size()); i++){ // 原本有n+1个元素，还需要取 k - path.size()个元素
            path.add(i);
            backTracking(i+1);
            path.remove(path.size()-1);
        }
    }
}

216.组合总和III

1. 用targetSum更好一点，少写一个参数。
2. 终止条件判断：在开头进行判断，如果到达就终止。不要将代码逻辑写到for循环中。

class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        combination(k, n, 1, 0); // 从1开始，初始和为0
        return result;
    }

    private List<List<Integer>> result;
    private LinkedList<Integer> path;

    private void combination(int k, int n, int start, int sum) {
        if (path.size() == k) { // 如果路径大小等于k
            if (sum == n) { // 如果路径和等于目标和
                result.add(new LinkedList<>(path)); // 添加到结果集
            }
            return; // 无论是否满足条件，都返回
        }

        for (int i = start; i <= 9; i++) { // 从start到9
            if (sum + i > n) break; // 如果当前和已经大于目标和，提前终止循环
            path.add(i); // 将当前数字加入路径
            combination(k, n, i + 1, sum + i); // 递归调用，从下一个数字开始
            path.removeLast(); // 回溯
        }
    }
}

17.电话号码的字母组合

class Solution {
    public List<String> letterCombinations(String digits) {

        result = new ArrayList<>();
        if("".equals(digits)) return result;
        path = new LinkedList<>();
        backTracking(digits, 0);
        return result;
    }

    private List<String> result;
    private LinkedList<Character> path;
    private char[][] cs = new char[][]{{}, {}, {'a', 'b', 'c'}, {'d', 'e', 'f'}, {'g', 'h', 'i'}, {'j', 'k', 'l'}, {'m', 'n', 'o'}, {'p', 'q', 'r', 's'}, {'t', 'u', 'v'}, {'w', 'x', 'y', 'z'}};

    private void backTracking(String digits, int index){
        // 终止条件
        if(index==digits.length()){
            result.add(path.stream().map(String::valueOf).collect(Collectors.joining()));
            return;
        }
        // 回溯
        for(char c : cs[digits.charAt(index)-'0']){
            path.add(c);
            backTracking(digits, index+1);
            path.removeLast();
        }
    }
}

代码随想录解法：

1. 映射数组：使用String[]类型的数组，而非char[][]
2. 字符串判空
3. path：使用StringBuilder进行字符串拼接，而非char[]。 append(), deleteCharAt()
4. 获取字符串对应数字：digits.charAt(num) - '0'

class Solution {

    //设置全局列表存储最后的结果
    List<String> list = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return list;
        }
        //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        //迭代处理
        backTracking(digits, numString, 0);
        return list;

    }

    //每次迭代获取一个字符串，所以会涉及大量的字符串拼接，所以这里选择更为高效的 StringBuilder
    StringBuilder temp = new StringBuilder();

    //比如digits如果为"23",num 为0，则str表示2对应的 abc
    public void backTracking(String digits, String[] numString, int num) {
        //遍历全部一次记录一次得到的字符串
        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }
        //str 表示当前num对应的字符串
        String str = numString[digits.charAt(num) - '0'];
        for (int i = 0; i < str.length(); i++) {
            temp.append(str.charAt(i));
            //递归，处理下一层
            backTracking(digits, numString, num + 1);
            //剔除末尾的继续尝试
            temp.deleteCharAt(temp.length() - 1);
        }
    }