代码随想录算法训练营第二十七天-回溯算法3｜ 39. 组合总和 40.组合总和II 131.分割回文串

39. 组合总和

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

public class CombinationSum {
    // global parameter
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    int sum = 0;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);//为了剪枝要先排序，要不然得全遍历
        backTracking(candidates, target, 0, 0);
        return result;
    }

    //return value & pa
    public void backTracking(int[] candidate, int target, int sum, int startIndex){
        // if(sum > target){
        //     return;
        // }这部分如果没排序必须有
        if (sum == target){
            result.add(new ArrayList<>(path));
            return;// base case/ terminate condition
        }
        //for loop traversal 横向遍历
        for(int i = startIndex; i < candidate.length; i++){
            // 如果 sum + candidates[i] > target 就终止遍历
            //剪枝 pruning
            if(sum + candidate[i] > target){
                break;
            }
            path.add(candidate[i]);//节点操作
            sum += candidate[i];
            backTracking(candidate,target,sum,i);//recursion
            path.removeLast();// backtracking
            sum -= candidate[i];
        }
    }
}

40.组合总和II

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

在一个集合中解决组合问题还是需要startIndex来控制集合的不重复

当在两个集合中选取元素的时候就不需要startIndex

// startIndex不从i+1开始 表示当前的元素可重复选取

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

public class CombinationSumII {

    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    int sum =0;
    boolean[] used;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        used = new boolean[candidates.length];
        // 加标志数组，用来辅助判断同层节点是否已经遍历
        Arrays.fill(used, false);
        // 为了将重复的数字都放到一起，所以先进行排序
        Arrays.sort(candidates);
        backTracking(candidates, target, 0,0, used);
        return res;
    }
    private void backTracking(int[] candidates, int target, int sum, int startIndex, boolean[]used){
        if(sum > target) return;
        if(sum == target){
            res.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]){//指i-1没被用过
                continue;//同层重复数字中止条件
            }

            //收集元素
            path.add(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            // 每个节点仅能选择一次，所以从下一位开始
            backTracking(candidates,target, sum, i + 1, used);
            path.removeLast();
            sum -= candidates[i];
            used[i] = false;
        }

    }
}

131.分割回文串

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

public class PalindromePartitioning {
    List<List<String>> result = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();

    public List<List<String>> partition(String s) {
        backTracking(s,0);
        return result;
    }

    private void backTracking(String s, int startIndex){
        //如果起始位置大于s的大小，说明找到了一组分割方案
        if(startIndex >= s.length()){//startIndex切割线
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i < s.length(); i++){
            if(isPalindrome(s, startIndex, i)){ //s在startIndex和i的闭区间之间
                //符合条件 把字串加入
                String str = s.substring(startIndex, i+ 1); //i+1 开区间，左闭右开
                path.add(str);
            }else{       // else 可以不写
                continue;//必须continue，不能break，break会排除掉aba形式
            }
            //起始位置后移，保证不重复
            backTracking(s, i + 1);
            path.removeLast();
        }
    }

    //判断是否是回文串
    private boolean isPalindrome(String s, int start, int end){
        for(int i = start, j = end; i < j;  i++, j--){
            if(s.charAt(i) != s.charAt(j)){
                return false;
            }
        }
        return true;
    }

}