回溯算法——17，39

今天继续学习回溯算法相关内容，分别是LeetCode17.电话号码的字母组合和LeetCode39.组合总和。两道题都和前面的组合类的题很像，但是一些细节处有所差异，需要针对性的编写。

LeetCode17.电话号码的字母组合

这道题很有意思，模拟了九键输入法。就是根据输入的数字，来获得所有的字母组合。这道题和前面的组合题目的差异在于，这道题是一道二维数组，因为需要一个2-9的数字，每一个数字里面又有3-4个字母，需要将这些字母全部拿出来进行组合。

class Solution {
    String[] letters=new String[10];
    List<String> result=new ArrayList<>();
    StringBuilder sb=new StringBuilder();

    public void InitMap(String[] letters){
        letters[0]="";
        letters[1]="";
        letters[2]="abc";
        letters[3]="def";
        letters[4]="ghi";
        letters[5]="jkl";
        letters[6]="mno";
        letters[7]="pqrs";
        letters[8]="tuv";
        letters[9]="wxyz";
    }

    public void backtracking(String digits,int startIndex){
        if (sb.length()==digits.length()){
            result.add(sb.toString());
            return;
        }
        for (int i = startIndex; i <digits.length() ; i++) {
            for (int j = 0; j < letters[(int)(digits.charAt(i)-'0')].length(); j++) {
                sb.append(letters[(int)(digits.charAt(i)-'0')].charAt(j));
                backtracking(digits,i+1);
                sb.delete(sb.length()-1,sb.length());
            }
        }
    }

    public List<String> letterCombinations(String digits){
        if(digits.isEmpty()){
            return result;
        }
        InitMap(letters);
        backtracking(digits,0);
        return result;
    }
}

首先我们需要先定义出这个二维数组。定义一个长度为10的数组，数组下标可以对应输入的数字。而0，1这两个下标没有对应输入的数字，可以将其置空。而下标为2-9的数组元素，可以分别存入九键中对应的字符串，之后再从这些串中选取字符进行组合。

在回溯算法的基础模板上，从一层for循环变成了两层for循环。因为这里需要取到输入的字符串中的每一个数字，这是外层循环，也就是模板中的那层循环，内层循环是取到数字后，还需要将数字对应到字符串上，对那个字符串中的每一个字符进行组合，才能遍历出所有的结果。

这里需要注意的有两点。第一，如果输入的字符串为空，需要返回的是一个存有一个空字符串的集合，所以需要判断。如果没有判断，则是一个空集合。所以需要单独处理这种情况。第二，char转换成int，不能直接使用强转，强转会将其转换成该char对应的ASCII码值，所以需要先减去char类型的’0’，以此得到真正的数字，否则会出现数组越界的情况。

LeetCode39.组合总和

这道题如果出现0，将会进入一个死循环，所以题目特别说明，数组中的元素值>=1。这道题的不同在于，因为每一个数字可以重复使用，所以在下一次递归的时候，不能直接像前几道题一样将起始值+1，这样就无法重复使用了。正确做法应该是，在每一次循环结束之后，再将初始值+1，就可以保证每一个数字可以被重复利用。递归返回的条件也需要注意，这次不能只是等于target才返回，这样的话，如果遇到数组中的数字无论怎么组合都无法等于target的情况，同样会进入死循环，出现爆栈问题。如果总和>target，就意味着这一路无法得到target，及时回溯，进入下一条路。如果等于，则将结果存入result中即可。

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

    public int Sum(List<Integer> path){
        int sum=0;
        for (int i = 0; i <path.size(); i++) {
            sum=sum+path.get(i);
        }
        return sum;
    }
    public void backtracking(int[] candidates, int target,int startIndex){
        if(Sum(path)==target){
            result.add(new ArrayList<>(path));
            return;
        }else if(Sum(path)>target){
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            path.add(candidates[i]);
            backtracking(candidates,target,startIndex);
            path.removeLast();
            startIndex++;
        }
    }

    public List<List<Integer>> combinationSum(int[] candidates,int target){
        backtracking(candidates,target,0);
        return result;
    }
}