#LeetCode 39. Combination Sum

#LeetCode 39. 视频讲解：带你学透回溯算法-组合总和（对应「leetcode」力扣题目：39.组合总和）| 回溯法精讲！_哔哩哔哩_bilibili

当建立树的结构的时候，target 可以限制树的深度，一旦大于target 则不会再进行后面的扩展。这个题目需要考虑的是数字可以被重复添加和使用，但是要注意组合的无序性，即：5, 2 = 2, 5。数字可以被重复添加是通过backtracking(candidates, target, sum, i); 这里的i 来实现的，之前的题目是i + 1。

代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int sum = 0;
        backtracking(candidates, target, sum, 0);
        return result;
    }
    public void backtracking (int[] candidates, int target, int sum, int startIndex) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            path.add(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.remove(path.size() - 1);
        }
    }
}

Prune 后的代码：

实现的方式为：在处理candidates 数组之前对其进行排序，在每次在for loop 的添加之前会先与target 进行比较，如果大于target ，则break ，不再进行后面的比较。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        int sum = 0;
        backtracking(candidates, target, sum, 0);
        return result;
    }
    public void backtracking (int[] candidates, int target, int sum, int startIndex) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if (sum + candidates[i] > target) break;
            path.add(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.remove(path.size() - 1);
        }
    }
}

#LeetCode 40. Combination Sum II

#LeetCode 40. 视频讲解：回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II_哔哩哔哩_bilibili

有两个概念，树层（广度）和树枝（深度）。在这里的去重指的是树层去重，如果数组是[1, 1, 2]那么选择两个元素的话，选择第一个1 和2 ，和第二个1 和2 是相同的，这一组就需要去重。

used 数组记录状态很重要，要不然会很混乱以及可能造成树枝去重。区分是递归导致的重复还是遍历导致的重复。在for loop中的if 用于实现树枝去重​​​​​​​，前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {      
        boolean[] used = new boolean[candidates.length];
        Arrays.fill(used, false);
        Arrays.sort(candidates);
        backtracking(candidates, target, 0, used);
        return result;
    }
    public void backtracking(int[] candidates, int target, int startIndex, boolean[] used) {
        if (sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if (sum + candidates[i] > target) {
                break;
            }
            if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
                continue;
            }
            path.add(candidates[i]);
            used[i] = true;
            sum += candidates[i];
            backtracking(candidates, target, i + 1, used);
            used[i] = false;
            sum -= candidates[i];
            path.remove(path.size() - 1);
        }
    }
}

#LeetCode 131. Palindrome Partitioning

#LeetCode 131. 视频讲解：带你学透回溯算法-分割回文串（对应力扣题目：131.分割回文串）| 回溯法精讲！_哔哩哔哩_bilibili

分割其实也是组合的一种方式，具体的过程如图： 

这里的分割回文串，用的是startIndex 来模拟那些切割线的。当遍历到了最后一个字符的时候，就会加入result 二维数组，这样的数组则是一个分割方式。判断是否是回文子串用的是双指针法，一个指针从前向后，一个指针从后向前，如果前后指针所指向的元素是相等的，就返回true（是回文字符串），否则返回flase （非回文字符串）。

代码：

class Solution {
    List<List<String>> result = new ArrayList<>();
    Deque<String> path = new LinkedList<>();
    public List<List<String>> partition(String s) {
        backTracking(s, 0);
        return result;
    }
    public void backTracking(String s, int startIndex) {
        if (startIndex >= s.length()) {
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = startIndex; i < s.length(); i++) {
            if (isPalindrome(s, startIndex, i)) {
                String subString = s.substring(startIndex, i + 1);
                path.addLast(subString);
            }
            else {
                continue;
            }
            backTracking(s, i + 1);
            path.removeLast();
        }
    }
    public boolean isPalindrome(String s, int startIndex, int i) {
        boolean palindrome = true;
        int leftIndex = startIndex;
        int rightIndex = i;
        int length = i - startIndex + 1;
        for (int j = leftIndex; j <= leftIndex + length / 2; j++) {
            if (s.charAt(j) == s.charAt(rightIndex)) {
                rightIndex -= 1;
            }
            else {
                palindrome = false;
                break;
            }
        }
        return palindrome;
    }
}

重启打卡ing...