（回溯02）组合总和iii 电话号码的字母组合

最新推荐文章于 2024-09-25 13:54:13 发布

qq_44962949

最新推荐文章于 2024-09-25 13:54:13 发布

阅读量966

点赞数 24

文章标签：算法

本文链接：https://blog.csdn.net/qq_44962949/article/details/138259392

版权

本文介绍了如何使用回溯算法解决LeetCode中的两个问题：组合总和III和电话号码的字母组合。涉及递归函数参数设定、终止条件判断和单层处理逻辑，展示了如何优化时间和空间复杂度。

摘要由CSDN通过智能技术生成

一、组合总和 III

力扣第216题目：

回溯三部曲：

1. 确定递归函数参数：

三个全局变量：

定义 result 集合用来存放结果集

定义 path 集合用来存放当前结果

定义 count 用来记录当前取值总和

回溯函数的三个参数：

k 为要取多少个数， n 为取得数的相加之和（k 和 n 为题目已给出），startindex 为当前层取数的起始位置。

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int count = 0;
    public void backtracking(int n, int k, int startindex)

2. 确定终止条件

当 path.size() == k 时，说明已经取了 k 个数，若 count == n 说明这 k 个数相加等于 n ，符合条件，将 path 加入 result 集中，若不满足 count == n ，则直接终止本层取数

        if(path.size() == k && count == n) {
            result.add(new ArrayList(path));
            return;
        }
        if(path.size() == k && count != n) {
            return;
        }

3. 单层处理逻辑

当前层下标 i 取值从 startindex 开始到 n 结束，count 记录选取数值总和，path 记录组合，下层 i 取值从startindex + 1 开始到 n 结束。注意：当函数回溯时，count 和 path 也要回溯！！

        for(int i = startindex; i <= 9; i++) {
            count += i;
            path.add(i);
            backtracking(n, k, i + 1);
            count -= i;
            path.remove(path.size() - 1);
        }

总代码如下：

class Solution {

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

    public void backtracking(int n, int k, int startindex) {
        if(path.size() == k && count == n) {
            result.add(new ArrayList(path));
            return;
        }
        if(path.size() == k && count != n) {
            return;
        }

        for(int i = startindex; i <= 9; i++) {
            count += i;
            path.add(i);
            backtracking(n, k, i + 1);
            count -= i;
            path.remove(path.size() - 1);
        }
    }
}

时间复杂度：O(n * $2^{n}$ )

空间复杂度：O(n)

修枝操作（改进）：

若 count 已经大于 n 了，就没必要在进行下层回溯了

class Solution {

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

    public void backtracking(int n, int k, int startindex) {
        if(path.size() == k && count == n) {
            result.add(new ArrayList(path));
            return;
        }
        if(path.size() == k && count != n) {
            return;
        }

        for(int i = startindex; i <= 9; i++) {
            count += i;
            if(count > n) {
                count -= i;
                return;
            }
            path.add(i);
            backtracking(n, k, i + 1);
            count -= i;
            path.remove(path.size() - 1);
        }
    }
}

二、电话号码的字母组合

力扣第17题：

回溯三部曲：

1. 确定递归参数

三个全局变量:

字符串数组 letterMap 用来映射字母和数字的关系

result 集合用来存放结果集

path 用来存放当前结果

两个返回参数：

digits 是题目给出的字符串，index 是指 digits字符串中字符的下标

    String[] letterMap = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
    List<String> result = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    public void backtracking(String digits, int index) {

    }

2. 确定终止条件

当 index 等于 digits 的长度时，说明已经访问到叶子节点，将结果 path 加入到 result 集合中，并返回

        if(index == digits.length()) {
            result.add(path.toString());
            return;
        }

3. 单层处理逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：

        int num = digits.charAt(index) - '0';
        String cur = letterMap[num];
        for(int i = 0; i < cur.length() ; i++) {
            path.append(cur.charAt(i));
            backtracking(digits, index + 1);
            path.deleteCharAt(path.length() - 1);
        }

总代码：

class Solution {
    String[] letterMap = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
    List<String> result = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    public List<String> letterCombinations(String 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(path.toString());
            return;
        }
        int num = digits.charAt(index) - '0';
        String cur = letterMap[num];
        for(int i = 0; i < cur.length() ; i++) {
            path.append(cur.charAt(i));
            backtracking(digits, index + 1);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

时间复杂度：O(3^m * 4^n) ，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数

空间复杂度：O(3^m * 4^n)