day27 回溯算法part3

39. 组合总和

中等
给你一个无重复元素的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按任意顺序返回这些组合。
candidates 中的同一个数字可以无限制重复被选取。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。

难点：去除重复的组合，和前面的组合题有所不同。元素可以重复选择的意思是在这一次的选择里可以选择已经选过了的元素，而不是可以和上一次选择的完全一样。

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates); // 先进行排序，方便剪枝
        backTrack(candidates, target, 0);
        return res;
    }
    public void backTrack(int[] candidates, int target, int start) {
        if (sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }
        if (sum > target) {
            return;
        }
        for (int i = start; i < candidates.length; i++) {
            // 剪枝
            if (sum + candidates[i] > target) break;

            path.add(candidates[i]);
            sum += candidates[i];
            backTrack(candidates, target, i);
            path.removeLast();
            sum -= candidates[i];
        }
    }
}

我觉得下图更能让我理解：
在这里插入图片描述
这是卡哥的图：

40. 组合总和 II

中等
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
注意：解集不能包含重复的组合。

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 candidates[], int target, int start) {
        if (sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }
       // if (sum > target) return;
        for (int i = start; i < candidates.length; i++) {
            // 剪枝，这是因为数组已排序，后边元素更大，子集和一定超过 target
            if (sum + candidates[i] > target) break;

            // 剪枝逻辑，值相同的树枝，只遍历第一条
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue; //如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
            }

            path.add(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, i + 1);
            path.remove(path.size() - 1);
            sum -= candidates[i];
        }
    }
}

在这里插入图片描述

131. 分割回文串

中等
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。
回文串是正着读和反着读都一样的字符串

难点：s.substring(start, i + 1); // 注意这里是i + 1

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

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

    public void backtrack(String s, int start) {
        // 走到叶子节点,即整个 s 被成功分割为若干个回文子串，记下答案
        if (start == s.length()) {
            res.add(new ArrayList<String>(path));
        }
        for (int i = start; i < s.length(); i++) {
            if (!isPalindrome(s, start, i)) { 
                continue; // 不是回文串，后面也没必要分割了，
                //比如abaa，如果分成ab|aa,前半截已经不是回文了，就continue
            }
            // s[start..i] 是一个回文串，可以进行分割
            // 做选择，把 s[start..i] 放入路径列表中
            path.add(s.substring(start, i + 1)); // 注意这里是i + 1
            // 进入回溯树的下一层，继续切分 s[i+1..]
            backtrack(s, i + 1);
            // 撤销选择
            path.remove(path.size() - 1);
        }
    }

    boolean isPalindrome(String s, int left, int right) {
        while(left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}