算法学习day27

39.组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

• 1 <= candidates.length <= 30
• 2 <= candidates[i] <= 40
• candidates 的所有元素 互不相同
• 1 <= target <= 40

回溯法

• 参考回溯法模板，横向循环，循环中嵌套递归（纵向）
• 本题中和其他组合问题不同在于，开始位置可以和上一层重复，也就是start不用每次都+1了；
• 横向和纵向剪枝条件：在sum>target时都需要剪枝
• 一个列表中找组合，需要用到start，多个列表中找组合不需要用start

import java.util.LinkedList;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    private List<List<Integer>> res = new ArrayList<List<Integer>>();
    private LinkedList<Integer> path = new LinkedList<Integer>();
    private int sum = 0 ;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if(candidates.length== 0) return res ;
        Arrays.sort(candidates);
        combine(candidates, target,0);
        return res ;
    }
    public void combine(int[] candidates, int target,int start) {
        if(sum == target){
            res.add(new ArrayList<Integer>(path));
            return;
        }
        if(sum > target){ return;}
        // 如果 sum + candidates[i] > target 就终止遍历
        for(int i = start ; i<candidates.length && sum + candidates[i] <= target ; i++){
            path.add(candidates[i]);
            sum += candidates[i];
            combine(candidates, target,i);
            sum -=candidates[i];
            path.removeLast();
        }
    }
}

40.组合总和II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

**注意：**解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

• 1 <= candidates.length <= 100
• 1 <= candidates[i] <= 50
• 1 <= target <= 30

回溯

• 先将目标数组排序，方便去重
• 若要避免结果重复，则同一层的数组不能有重复：candidates[i] == candidates[i-1]
  • 那么如何判断同一层呢？
  • 用于判断是否时同一层的数字，当start为0的时候时第一层，当start为1的时候代码已经执行到了第二层，由此规律得知

class Solution {
    private List<List<Integer>> res = new ArrayList<List<Integer>>();
    private LinkedList<Integer> path = new LinkedList<Integer>();
    private int sum = 0 ;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //先将目标数组排序，方便去重
        Arrays.sort(candidates);
        lookback(candidates, target,0);
        return res ;
    }
    private void lookback(int[] candidates, int target,int start){
        if(sum == target){
            res.add(new ArrayList<Integer>(path));
            return ;
        }
        if(sum > target) return ;
        //剪枝条件，因为时排序后的，当同一层已经累加的和大于target，则后面的数字和肯定大于targe，需要剪枝
        for (int i = start; i < candidates.length && sum<=target; i++) {
            //此处的i>start 用于判断是否时同一层的数字，当start为0的时候时第一层，当start为1的时候代码已经执行到了第二层，由此规律得知
            if(i>start && candidates[i] == candidates[i-1]){
                continue;
            }
            sum += candidates[i];
            path.add(candidates[i]);
            lookback(candidates,target,i+1);
            path.removeLast();
            sum -= candidates[i];
        }
    }
}

131.分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

• 1 <= s.length <= 16
• s 仅由小写英文字母组成

回溯

• 横向逐个切割字符串，类似于组合问题，每次选择一个字符

• 纵向切割剩余字符，

  • 终止条件，当开始位置大于等于字符串长度时，相当于完整的切割了一轮，满足条件的值；若不满足条件start肯定小于字符串长度

import java.util.List;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    private  List<List<String>> res = new ArrayList<List<String>>();
    private LinkedList<String> path = new LinkedList<String>();
    public List<List<String>> partition(String s) {
        lookback(s,0);
        return res ;
    }
    private void lookback(String s , int start){
        if(start >= s.length()){
            res.add(new ArrayList<String>(path));
            return ;
        }
        //i 为切割位置，从0开始；横向逐个切割字符
        for (int i = start; i < s.length() ; i++) {
            if(isPaliandrom(s,start,i)){
                path.add(s.substring(start,i+1));
            }else{
                continue;
            }
            //纵向切割剩余字符
            lookback(s,i+1);
            path.removeLast();
        }
    }
    //参数为左闭右闭区间
    public boolean isPaliandrom(String s,int left,int right) {
        while(left <= right){
            if(s.charAt(left) != s.charAt(right)){
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }
}