代码随想录算法训练营第27天|39. 组合总和,40. 组合总和 II,131.分割回文串

39. 组合总和

链接: 参考讲解
写完这一题让我对排列组合有了更加深刻的理解

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
            if(candidates == null || candidates.length == 0 ) return res;
            backtrack(candidates,target,0,0);
            return res;
    }

    public void backtrack(int[] candidates, int target, int sum, int startIndex){
        if(sum > target) return;
        
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
		// 如果是求排列则 i=0; 但本题为组合问题不强调元素的顺序
        for(int i= startIndex; i < candidates.length; i++){
            sum += candidates[i];
            path.add(candidates[i]);
            // 因为本题允许有重复的元素所以递归时startIndex = i
            backtrack(candidates,target,sum,i);
            // 回溯
            path.removeLast();
            // 回溯
            sum -= candidates[i];
        }
    }
}

40. 组合总和 II

这道题的难点为去重，需要理解树层去重
链接: 参考讲解

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    int[] used; // 标记数组
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
            if(candidates == null || candidates.length == 0 ) return res;
            used = new int[candidates.length];
            Arrays.sort(candidates);
            backtrack(candidates,target,0,0);
            return res;
    }

    public void backtrack(int[] candidates, int target, int sum, int startIndex){
        if(sum > target) return;
        
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
		// 如果是求排列则 i=0; 但本题为组合问题不强调元素的顺序
        for(int i= startIndex; i < candidates.length; i++){
            // 去重 注意这里的used数组判断的是：重复的元素是否在同一树层，
            // 同一树枝上的元素可以重复，但同一数层上的不能重复
            if(i>0 && candidates[i-1] == candidates[i] && used[i-1] == 0) continue;
            sum += candidates[i];
            path.add(candidates[i]);
            used[i] = 1;
            //
            backtrack(candidates,target,sum,i+1);
            // 回溯
            path.removeLast();
            // 回溯
            sum -= candidates[i];
            // 回溯
            used[i] = 0;
        }
    }
}

131.分割回文串

链接: 参考讲解

• 遇到的困难
  1 不知道回文切割线和startIndex的关系，后面发现startIndex就是回文切割线
  2 切割字符串是需要注意string.substring()这个方法遵循的是左闭右开原则

class Solution {
    List<List<String>> res = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();
    public List<List<String>> partition(String s) {
            if(s == null || s.length() == 0) return res;
            backtrack(s,0);
            return res;
    }

    public void backtrack(String s, int startIndex){
        if(s.length() <= startIndex){
             res.add(new ArrayList<>(path));
             return;
        } 

        for(int i = startIndex; i< s.length();i++){
            if(isPalindrome(s,startIndex,i)){
                String str = s.substring(startIndex,i+1); // 左闭右开
                path.add(str);
            }else{
                continue;
            }
            backtrack(s,i+1);
            path.removeLast();
        }
    }

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