回溯 | Java | LeetCode 77, 216, 17 做题总结

只要有递归就会有回溯。
递归函数下面就是回溯函数。
（1）回溯就是暴力方法的改善。
（2）回溯可以抽象为一个N叉树

• 回溯搜索法：纯暴力（有些问题能搜出来就不错了）
  能解决：
  组合问题：1 2 3 4的组合，找出大小为2的组合
  切割问题：怎么切合集合/字符串
  子集问题：把它的子集列出来
  排列问题：注意区分排列和组合
  棋盘问题：N皇后，解数独等等

第77题. 组合

如果 k=2，那么暴力法，双层for循环就可以
如果 k=3，那么暴力法，三层for循环就可以了
回溯法就用递归来解决嵌套层数的问题。

我分析出递归需要一个记录数组下标的参数，void combine(int n, int k, int i) 但没写出来。

class Solution {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n,k,1);
        return res;
    }

    void backtracking(int n, int k, int startIndex) {
        if(path.size() == k) {
            res.add(new ArrayList<>(path)); //什么意思！！
            return;
        }
        //循环每一次解决根节点的一个孩子
        for(int i=startIndex; i<=n; i++) {
            path.add(i);
            backtracking(n,k,i+1);
            path.removeLast();
        }
    }
}

回溯-剪枝

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        //终止条件
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

216.组合总和III

这一题我为什么写出来了，因为我感觉直接改上一题的操作就可以。

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

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

     void backtracking(int n, int k, int startIndex) {
        if(path.size() == k) {
            int sum = 0;
            for(Integer i : path) {
                sum+=i;
            }
            if(sum == n) {
                res.add(new ArrayList<>(path)); 
            }
            return;
        }
        //循环每一次解决根节点的一个孩子
        for(int i=startIndex; i<=9-(k-path.size())+1; i++) {
            path.add(i);
            backtracking(n,k,i+1);
            path.removeLast();
        }
    }
}

树的深度由K决定，树的宽度是由1-9决定的

17.电话号码的字母组合

import java.util.ArrayList;
import java.util.List;

class Solution {
    List<String> res = new ArrayList<String>();
    private String[] letterMap = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};

    public List<String> letterCombinations(String digits) {
        if(digits.equals("")) return res;

        backTracking(digits, 0);
        return res;
    }

    StringBuilder s = new StringBuilder();
    void backTracking(String digits, int index) {
        if(index == digits.length()) {
            res.add(s.toString());
            return;
        }
        //搞清楚index是什么，index是digits数组的下标
        String cur = letterMap[digits.charAt(index) - '0'];
        for(int i=0; i<cur.length(); i++) {
            s.append(cur.charAt(i));
            backTracking(digits, index+1);

            s.deleteCharAt(s.length()-1);
        }
    }

}