代码随想录：回溯5-8

17.电话号码的字母组合

题目

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

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

示例 1：

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

代码

class Solution {
    //letter用于映射2->abc
    String[] letters = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder(); //保存path的字母
    public List<String> letterCombinations(String digits) {
        //这个要写，不然如果digits长度为0，返回的list里面是""
        if(digits.length() == 0 || digits == null){
            return res;
        }
        backTracking(digits,0);
        return res;
    }
    public void backTracking(String digits,int index){
        //终止条件：路径sb的字母个==于字符串数字个数
        if(sb.length() == digits.length()){
            res.add(sb.toString());
            return;
        }
        //遍历digits字符串，i=index用来确定从第几个数字开始
        for(int i=index; i < digits.length(); i++){
            char c = digits.charAt(i);  //拿到2
            String letter = letters[c - '0'];  //拿到abc
            for(int j=0; j < letter.length(); j++){  //遍历abc
                char l = letter.charAt(j); //拿到a
                sb.append(l);  //sb路径中是a
                backTracking(digits,i + 1);  //遍历digit的下一个数字3，获取下一个字母
                sb.deleteCharAt(sb.length()-1); //把sb的a删除回溯，继续遍历bc
            }
        }
    }
}

39.组合总和

题目

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList();
    int sum;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {

        backTracking(candidates,target,0);
        return res;
    }

    public void backTracking(int[] nums,int target,int index){
        //终止条件：sum和等于target
        if(sum == target){
            //注意点：必须要new
            res.add(new ArrayList<>(path));
            return;
        }
        //终止条件：sum和大于target，剪枝返回
        if(sum > target){
            return;
        }

        //for循环遍历每个数字，i=index,保证从哪个位置开始取数字
        //int i=0,如果写成这个，223,232,322,重复出现
        for(int i=index; i < nums.length; i++){ //2347
            int num = nums[i]; 
            path.add(num);
            sum += num;
            //这里是i，不是i+1，因为digit可以重复取
            backTracking(nums,target,i); //path里面是2，递归2347，path里面是3，递归347
            sum -= num;
            path.remove(path.size()-1);
        }
    }
}

40.组合总和II

题目

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);  //排序后才从去重
        backTracking(candidates,target,0);
        return res;
    }

    public void backTracking(int[] nums,int target,int index){
        if(sum > target){
            return;
        }
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
        
        //index用于保证从candidates中的第几个数字开始取
        for(int i=index; i < nums.length; i++){
            //同层的去重，122233，去重为123
            //i > index,如果写成i>0,1156目标值为8，116取不到
            if(i > index && nums[i] == nums[i-1]){
                continue;
            }
            sum += nums[i];
            path.add(nums[i]);
            //i+1，因为candidates里面的数字只能用一次
            backTracking(nums,target,i+1);
            sum -= nums[i];
            path.remove(path.size()-1);
        }
    }
}