java算法第27天 | ● 39. 组合总和 ● 40.组合总和II ● 131.分割回文串

39. 组合总和

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

class Solution {
    private List<Integer> path = new ArrayList<>();
    private List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtracking(candidates,target,0,0);
        return res;
    }

    public void backtracking(int[] candidates, int target, int sum, int startIndex){
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }
        if(sum>target || startIndex>=candidates.length) return;//注意，这里要做剪枝，不然会栈溢出
        for(int i=startIndex;i<candidates.length;i++){
            path.add(candidates[i]);
            backtracking(candidates,target,sum+candidates[i],i);//可重复
            path.remove(path.size()-1);
        }
    }
}

时间复杂度: O(n * 2^n)，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此
空间复杂度: O(target)

40.组合总和II

这道题的重点是如何去重，参考15.三树之和的思想，需要去掉nums[index]=nums[index-1]的情况。也就是横向遍历中遇到和前一个相同的节点，就直接跳过，但向下递归可以出现重复。
要注意的是这里的去重是在for循环里的，而不是外面。

class Solution {
    private List<List<Integer>> res=new ArrayList<>();
    private List<Integer> path=new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtracking(candidates,target,0,0);
        return res;
    }

    public void backtracking(int[] candidates, int target,int startIndex,int sum){
        if(sum>target) return;
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex;i<candidates.length;i++){
            if(i>startIndex && candidates[i]==candidates[i-1]) continue;//去重
            path.add(candidates[i]);
            backtracking(candidates,target,i+1,sum+candidates[i]);
            path.remove(path.size()-1);
        }
    }
}

时间复杂度: O(n * 2^n)
空间复杂度: O(n)

131.分割回文串

本题主要有以下几个注意点：
1、要明白字符串的分割怎么等同于前面的组合。startIndex表示的是分割的位置。
2、分割时要明确左闭右闭区间。

class Solution {
    private List<List<String>> res=new ArrayList<>();
    private List<String> path=new ArrayList<>(); 
    public List<List<String>> partition(String s) {
        backtracking(s,0);
        return(res);
    }

    public void backtracking(String s,int startIndex){
        if(startIndex>=s.length()){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex;i<s.length();i++){//左闭右闭区间
            if(isPalindrome(s,startIndex,i)){
                path.add(s.substring(startIndex,i+1));
                backtracking(s,i+1);
                path.remove(path.size()-1);
            }else{
                continue;
            }

        }
    }

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

时间复杂度: O(n * 2^n)
空间复杂度: O(n^2)