216.组合总和III

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

• 只使用数字1到9
• 每个数字 最多使用一次

返回所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7

输出: [[1,2,4]]

解释: 1 + 2 + 4 = 7 没有其他符合的组合了。 

示例 2:

输入: k = 3, n = 9

输出: [[1,2,6], [1,3,5], [2,3,4]]

解释: 1 + 2 + 6 = 9 1 + 3 + 5 = 9 2 + 3 + 4 = 9 没有其他符合的组合了。 

示例 3:

输入: k = 4, n = 1

输出: []

解释: 不存在有效的组合。 在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

 问题分析：

1、递归函数的返回值和参数

本题参数为：k（k个数为一组）、n（和为n）、startIndex（记录当前层搜索开始的位置，初始为1），类型都为int。

2、回溯函数终止条件

当path.size==k&&sum==n时即终止，并把path路径加到result二维集合中

3、单层搜索的过程

for循环用来横向遍历，递归的过程是纵向遍历。

class Solution {
        List<Integer> path=new ArrayList<>();
        List<List<Integer>> result=new ArrayList<>();
        int sum=0;
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return result;
    }
    public void backtracking(int k,int n,int startIndex){
        if(path.size()==k&&sum==n){
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex;i<=9;i++){
            sum=sum+i;
            path.add(i);
            backtracking(k,n,i+1);
            path.remove(path.size()-1);//回溯
            sum=sum-i;//回溯
        }

    }
}

优化：剪枝

i到9一共有9-i+1个元素，而当前还需要k-path.size()个元素，所以必须满足9-i+1>=k-path.size()，移项就可以得到i<=9-(k-path.size())+1

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

       if (path.size()>k) return;//剪枝。必须加上，否则找不到目标值会一直循环
        if(path.size()==k&&sum==n){
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex;i<=9-(k-path.size())+1;i++){//剪枝
            sum=sum+i;
            path.add(i);
            backtracking(k,n,i+1);
            path.remove(path.size()-1);
            sum=sum-i;
        }

    }
}

---

17.电话号码的字母组合

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

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

示例 1：

输入：digits = "23"

输出：["ad","ae","af","bd","be","bf","cd","ce","cf"] 

示例 2：

输入：digits = ""

输出：[] 

示例 3：

输入：digits = "2"

输出：["a","b","c"]

问题分析：

1、确定回溯函数参数 

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

参数有string digits，还要有一个int型的index。

这个index不是以前的startIndex了，是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

2、确定终止条件

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

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

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

3、确定单层遍历逻辑

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

然后用for循环处理字符集

 

 

 

class Solution {
        List<String> result=new ArrayList<>();
        StringBuilder s=new StringBuilder();//普通字符串是不能进行修改的
    public List<String> letterCombinations(String digits) {
        String[] numString={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
        backtracking(digits,numString,0);//index=0,是因为在两个数组中进行，不需要剪枝和记录同一数组位置
        return result;
    }
    public void backtracking(String digits,String[] numString,int index){//index为标记遍历到哪个数字了
        if (digits==null||digits.length()==0) return;
        if (index==digits.length()) {
            result.add(s.toString());//转换为String
            return;
        }
        int dig=digits.charAt(index)-'0';//让字符串中的数字转换为int类型
        String letter=numString[dig];//标记位置为dig代表的数组的字符串
        for (int i=0;i<letter.length();i++){//每个字符串的循环
            s.append(letter.charAt(i));//s相当于path。上一层
            backtracking(digits,numString,index+1);//index+1为下一层，下一个letter字符串
            s.deleteCharAt(s.length()-1);//回溯
        }
    }
}