代码随想录第27天 ● 39. 组合总和● 40.组合总和II● 131.分割回文串

39. 组合总和 

本题是 集合里元素可以用无数次，那么和组合问题的差别 其实仅在于 startIndex上的控制

题目链接/文章讲解：代码随想录

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

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
//candidates 中的数字可以无限制重复被选取。
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        //记录结果

        Arrays.sort(candidates); // 先进行排序
        backtracking(candidates, target, 0, 0);
        return result;
    }

    public void backtracking(int[] candidates, int target, int sum, int startIndex) {
        //终止条件 sum>target
        if (sum == target) { //找到组合
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {//之前的sum+本次的值大于target则可以进行剪枝
            if (sum + candidates[i] > target) break;
            sum += candidates[i];
            path.add(candidates[i]);
            backtracking(candidates, target, sum, i);//数字可以重复利用，不需要i+1了
            sum -= candidates[i];
            path.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)

 40.组合总和II 

本题开始涉及到一个问题了：去重。

注意题目中给我们 集合是有重复元素的，那么求出来的 组合有可能重复，但题目要求不能有重复组合。 

题目链接/文章讲解：代码随想录

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

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

class Solution {
    //记录结果
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;
    int sum = 0;
    //需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        used = new boolean[candidates.length];//在Java中，赋值时写上变量类型会导致编译错误，
        // 因为这样做会被视为重复声明变量。一旦变量已经在作用域中声明，再次写上变量类型将被认为是错误的语法。
        Arrays.fill(used, false);//初始值全部置为false表示还没访问过相同数字
        Arrays.sort(candidates); // 先进行排序
        backtracking(candidates, target, 0);
        return result;
    }

    public void backtracking(int[] candidates, int target, int startIndex) {
        //终止条件 sum>target
        if (sum == target) { //找到组合
            result.add(new LinkedList<>(path));
            return;
        }

        for (int i = startIndex; i < candidates.length; i++) {//之前的sum+本次的值大于target则可以进行剪枝
            if (sum + candidates[i] > target) break;
            // 出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
            if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
                continue;
            }
            used[i] = true;
            sum += candidates[i];
            path.add(candidates[i]);
            // 每个节点仅能选择一次，所以从下一位开始
            backtracking(candidates, target, i + 1);
            used[i] = false;
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

 131.分割回文串  

本题较难，大家先看视频来理解 分割问题，明天还会有一道分割问题，先打打基础。 

代码随想录

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

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

//leetcode submit region begin(Prohibit modification and deletio
class Solution {
    //记录结果
    LinkedList<String> deque = new LinkedList<>();
    //Deque<String> deque = new LinkedList<>();
    List<List<String>> result = new ArrayList<>();
    int startIndex;//切割过的地方，不能重复切割

    //下一轮递归遍历的起始位置，也就是我们需要的切割线
    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));
            result.add(new ArrayList(deque));
            return;
        }
        //单层递归搜索
        for (int i = startIndex; i < s.length(); i++) {
            //判断是回文子串
            if (isPalindrome(s, startIndex, i)) {
                String str = s.substring(startIndex, i + 1); //substring这个方法是左闭右开，因此是i+1
                deque.addLast(str);
            } else {//如果不是回文子串，跳出此次递归
                continue;
            }
            backtracking(s, i + 1);//下一次递归的开始是i+1
            deque.removeLast();//回溯
        }
    }

    //设计回文子串函数
    private boolean isPalindrome(String s, int startIndex, int end) {
        for (int i = startIndex, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}

//leetcode submit region end(Prohibit modification and deletion)