算法训练营 day29 回溯算法 组合总和III 电话号码的字母组合

算法训练营 day29 回溯算法 组合总和III 电话号码的字母组合

组合总和III

216. 组合总和 III - 力扣（LeetCode）

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

做过77. 组合 之后，本题是简单一些了。

回溯三部曲

• 确定递归函数参数

这里依然定义path 和 result为全局变量。

还需要如下参数：

• n（int）目标和，也就是题目中的n。
• k（int）就是题目中要求k个数的集合。
• sum（int）为已经收集的元素的总和，也就是path里元素的总和。
• startIndex（int）为下一层for循环搜索的起始位置。

    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> path = new ArrayList<Integer>();
void backtracking(int k, int n, int sum, int startIndex)

• 确定终止条件

所以如果path.size() 和 k相等了，就终止。

如果此时path里收集到的元素和（sum） 和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

if (path.size() == k) {
	if (sum == n) 
        result.add(new ArrayList<>(path));
    // 如果path.size() == k 但sum != targetSum 直接返回
	return;

• 单层搜索过程

处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。

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

剪枝优化

已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。

代码如下：

class Solution {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> path = new ArrayList<Integer>();

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

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

		if (path.size() == k) {
			if (sum == n) result.add(new ArrayList<>(path));
			return;
		}
        for (int i = startIndex;i<=9-(k-path.size())+1;i++){
            path.add(i);
            sum += i;
            backtracking(k,n,sum,i+1);
            sum -= i;
            path.remove(path.size()-1);
        }
    }
}

电话号码的字母组合

17. 电话号码的字母组合 - 力扣（LeetCode）

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，我这里定义一个二维数组，代码如下：

 String[10] letterMap = {
    "", // 0
    "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
};

• 确定回溯函数参数

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

再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。

    List<String> result = new ArrayList<>();
    StringBuilder temp = new StringBuilder();
void backtracking(String digits, String[] letterMap, int num)

• 确定终止条件

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

那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。

if (num==digits.length()){
    result.add(temp.toString());
    return;
}

• 确定单层遍历逻辑

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

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

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

整体代码如下：

class Solution {
    List<String> result = new ArrayList<>();
    StringBuilder temp = new StringBuilder();

    public List<String> letterCombinations(String digits) {
        if (digits==null||digits.length()==0){
            return result;
        }
        String[] letterMap = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        backtracking(digits,letterMap,0);
        return  result;
    }

    private void backtracking(String digits, String[] letterMap, int num) {
        if (num==digits.length()){
            result.add(temp.toString());
            return;
        }
        String str = letterMap[digits.charAt(num)-'0'];
        for (int i=0;i<str.length();i++) {
            temp.append(str.charAt(i));
            backtracking(digits,letterMap,num+1);
            temp.deleteCharAt(temp.length()-1);
        }
    }
}