【代码随想录】回溯

77. 组合

每收集完一次结果时，都要移除末尾元素，向其中添加新元素。比如：
[1, 2] ➡ [1, 3] 要先移除 2，再添加 3，所以适合用 LinkedList 存储路径。

剪枝操作：

• 已经选择的元素个数：path.size()
• 还需要的元素个数为：k - path.size()
• 在集合 n 中至多要从该起始位置：n - (k - path.size()) + 1 开始遍历

class Solution {
    List<List<Integer>> res = new ArrayList<>();  
    List<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        backTrack(n, k, 1);
        return res;
    }
    private void backTrack(int n, int k, int startIndex){
        if(path.size()==k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex; i<=n-(k-path.size())+1; i++){
            path.add(i);
            //为什么传入i+1？
            //因为递归负责沿树的深度方向延伸
            //也就是找当前组合中的下一个元素
            //且不允许与i所指的元素重复
            //所以要看i的后一个是否合适
            backTrack(n, k, i+1);
            path.removeLast();
        }
    }
}

216. 组合总和 III

剪枝：个数没到，总和到了或超了。

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

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

    private void backTrack(int k, int n, int start){
        int ans=sum(path);
        if(ans==n && path.size()==k){
            res.add(new ArrayList(path));
            return;
        }
        if(ans >= n){
            return;
        }
        for(int i=start; i<=9 - (k - path.size()) + 1; i++){
            path.add(i);
            backTrack(k, n, i+1);
            path.removeLast();
        }
    }

    private int sum(List list){
        int ans=0;
        for(int i=0; i<list.size(); i++){
            ans += path.get(i);
        }
        return ans;
    }
}

17. 电话号码的字母组合

就是简单的递归，对于每个数字都是一样的处理方式。

class Solution {
    String[] digitStr = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    List<String> res = new ArrayList<>();
    // 递归和回溯时，字符要增删，所以不能用String
    StringBuilder sb = new StringBuilder();
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return res;
        } 
        backTrack(digits, 0);
        return res;
    }
    private void backTrack(String digits, int index){
        if(sb.length()==digits.length()){
            //不转成String在系统上运行报错
            res.add(new String(sb));
            return;
        }
        String str = digitStr[digits.charAt(index)-'0'];
        for(int i=0; i<str.length(); i++){
            sb.append(str.charAt(i));
            backTrack(digits, index+1);
            sb.deleteCharAt(sb.length()-1);
        }
    }
}

39. 组合总和

因为允许元素重复，所以下一层递归还是从当前元素开始
剪枝：总和超过 target

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    int sum=0;

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

    private void backTrack(int[] candidates, int target, int startIndex){
        if(sum==target){
            res.add(new ArrayList(path));
            return;
        }
        // 剪枝：总和超了
        if(sum>target){
            return;
        }
        for(int i=startIndex;i<candidates.length;i++){
            path.add(candidates[i]);
            sum+=candidates[i];
            //因为允许元素重复，所以下一层递归还是从当前元素(下标i)开始
            backTrack(candidates, target, i);
            path.removeLast();
            sum-=candidates[i];
        }
    }

    // private int sum(List<Integer> path){
    //     int ans = 0;
    //     for(int item : path){
    //         ans+=item;
    //     }
    //     return ans;
    // }
}

40. 组合总和 II

根据要求，可知组合的条件是：

• 每个 path 中有重复的值，但不是重复的元素；
• 不能有重复的 path

第一点容易做到，按照之前的做法，每层递归指定从下一个元素，就会天然形成这种效果
关于第二点的分析：

对于第二个 1，不必再使用了，原因是：
第一个 1 在数值上与之相同，而且它后续组合的元素包含了第二个 1 能组合的所有元素，所以再使用第二个 1 必定产生重复组合。

而且，只根据 i>0 && candidates[i]==candidates[i-1] 这两个条件判定需要跳过的元素是不够的，因为 {1,1,…} 这种情况是允许的，所以还要排除这种情况。可行的一种方式是使用 used 数组记录已经使用的元素。如果前面条件的基础上，当前元素的前一个元素没有使用过，则跳过，就能满足 path 不重复的需求。

使用上面的策略之前先要将 candidates 数组排序，保证相同的元素相邻。这样才能使用条件进行跳过。

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    int sum = 0;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        boolean[] used = new boolean[candidates.length];
        backTrack(candidates, target, 0, used);
        return res;
    }

    private void backTrack(int[] candidates, int target, int startIndex, boolean[] used){
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }
        // if(sum>target){
        //     return;
        // }

        for(int i=startIndex; i<candidates.length; i++){
            // 剪枝：加上目前的元素总和>target，就没必要再进行了
            if(sum+candidates[i]>target){
                break;
            }
            if(i>0 && candidates[i]==candidates[i-1] && used[i-1]==false){
                continue;
            }
            path.add(candidates[i]);
            sum+=candidates[i];
            used[i]=true;
            backTrack(candidates, target, i+1, used);
            path.removeLast();
            sum-=candidates[i];
            used[i]=false;
        }                                             
    }
}

131. 分割回文串

直接背吧。。。

对于字符串 abcdef：

组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…。
切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…。

class Solution {
    List<List<String>> res = new ArrayList<>();
    List<String> hwList = new LinkedList<>();

    public List<List<String>> partition(String s) {
        backTrack(s, 0);
        return res;
    }

    private void backTrack(String s, int startIndex){
        if(startIndex==s.length()){
            res.add(new ArrayList(hwList));
        }
        for(int i=startIndex; i<s.length(); i++){
            String subStr = s.substring(startIndex, i+1);
            if(isHw(subStr)){
                hwList.add(subStr);
                backTrack(s, i+1);
                hwList.removeLast();
            }   
        }
    }
    // 判断是否是回文
    private boolean isHw(String str){
        boolean res = true;
        for(int i=0,j=str.length()-1; i<j; i++,j--){
            if(str.charAt(i)!=str.charAt(j)){
                res=false;
                break;
            }
        }
        return res;
    }
}

78. 子集

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

    public List<List<Integer>> subsets(int[] nums) {
        backTrack(nums, 0);
        res.add(new ArrayList<>());//加入空集
        return res;
    }

    private void backTrack(int[] nums, int startIndex){
        // 终止条件：到达数组末尾
        if(startIndex==nums.length){
            return;
        }
        for(int i=startIndex; i<nums.length; i++){
            subRes.add(nums[i]);
            // 将树的每个节点都记录下来
            res.add(new ArrayList<>(subRes));
            backTrack(nums, i+1);
            subRes.removeLast();
        }
    }
}

46. 全排列

要点：2 加入之后还可以加入 1，也就是可以加入之前的元素，所以要从下标 0 而不是 startIndex 开始遍历，所以要用 used 数组记录已经加入全排列的元素，防止 2 再次被加入。

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

    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backTrack(nums, used);
        return res;
    }

    private void backTrack(int[] nums, boolean[] used){
        if(subRes.size()==nums.length){
            res.add(new ArrayList<>(subRes));
            return;
        }
        for(int i=0; i<nums.length; i++){
            if(used[i]==true){
                continue;
            }
            subRes.add(nums[i]);
            used[i]=true;
            backTrack(nums, used);
            subRes.removeLast();
            used[i]=false;
        }
    }
}