代码随想录算法训练营第二十天| 39. 组合总和、40. 组合总和Ⅱ、131. 分割回文串

news2024/11/14 15:38:46

今日内容

leetcode. 39 组合总和
leetcode. 40 组合总和Ⅱ
leetcode. 131 分割回文串

Leetcode. 39 组合总和

文章链接：代码随想录 (programmercarl.com)

题目链接：39. 组合总和 - 力扣（LeetCode）

本题不太一样的是可以对同一个数字进行无限制的重复选取，因此进行递归时，startIndex应该不变，从而保证对同个元素进行重复选取。

题目中还说：如果至少一个数字的被选数量不同，则两种组合是不同的。因为题目中给出的candidates数组有序，按照回溯的正常流程，某个数字的被选择次数按照流程走的话，肯定会是不同的。

基于回溯模板和抽象树形结构，我们写出如下代码：

class Solution {
    List<Integer> elem = new LinkedList<>();
    List<List<Integer>> result = new LinkedList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtracking(candidates, target, 0);
        return result;
    }
    public void backtracking(int[] candidates, int target, int startIndex){
        if (sum > target){
            return;
        }
        if (sum == target){
            result.add(new LinkedList<>(elem));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++){
            sum += candidates[i];
            elem.add(candidates[i]);
            backtracking(candidates, target, i); // 注意不是 i + 1 了
            sum -= candidates[i];
            elem.remove(elem.size() - 1);
        }

    }
}

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

Leetcode. 40 组合总和Ⅱ

文章链接：代码随想录 (programmercarl.com)

题目链接：40. 组合总和 II - 力扣（LeetCode）

本题基于组合总和这道题目，加了个去重的限制。现在每个数字在每个组合中只能使用一次。

实际上如果按照最普通的回溯模板来写这道题，最后会发现题目中所说的重复和前面哈希法专题中的 15. 三数之和 - 力扣（LeetCode）比较类似，所以去重思路也可以向三数之和看齐，即先将数组进行排序，把第一个元素按照正常流程进行处理，若后一个元素和其前一个元素一样，则跳过该元素。

注意，这里的排序非常重要！没有排序的话，就无法使用这样的去重思路。

根据思路、回溯模板和抽象树形图，写出如下代码：

class Solution {
    List<Integer> elem = new LinkedList<>();
    List<List<Integer>> result = new LinkedList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtracking(candidates, target, 0);
        return result;
    }
    public void backtracking(int[] candidates, int target, int startIndex){
        if (sum == target){
            result.add(new LinkedList<>(elem));
            return;
        }
        // 加入了剪枝操作
        for (int i = startIndex; i < candidates.length && sum + candidates[i] <= target; i++){
            // 剔除同一层中用过的元素
            if (i > startIndex && candidates[i] == candidates[i - 1]){
                continue;
            }
            sum += candidates[i];
            elem.add(candidates[i]);
            backtracking(candidates, target, i + 1);
            sum -= candidates[i];
            elem.remove(elem.size() - 1);
        }
    }
}

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

Leetcode. 131 分割回文串

文章链接：代码随想录 (programmercarl.com)

题目链接：131. 分割回文串 - 力扣（LeetCode）

前面做的都是回溯问题中的组合问题，本题就是回溯问题中的另一类：分割问题。

实际上分割问题与组合问题非常类似，比如对于字符串 abcdef：

组合问题：选取 a 之后，在 bcdef 中再去选取第二个。选取 b 之后再去 cdef 中选取第三个……
分割问题：分割 a 之后，在 bcdef 中再去分割第二个。分割 b 之后再去 cdef 中分割第三个……

因此将本题的分割问题抽象为树形结构图后，结果如下：

从抽象树形图中可以看出，分割问题与组合问题的回溯搜索过程基本无异。

基于此写出代码：

class Solution {
    List<String> elem = new LinkedList<>();
    List<List<String>> result = new LinkedList<>();

    public List<List<String>> partition(String s) {
        backtracking(s, 0);
        return result;
    }
    public void backtracking(String s, int startIndex){
        /*
        这里的startIndex表示分割线，
        分割线如果超过了字符串长度，则说明已经到头，可以停止了
        */
        if (startIndex >= s.length()){
            result.add(new LinkedList<>(elem));
            return;
        }
        for (int i = startIndex; i < s.length(); i++){
            if (isPalindrome(s, startIndex, i)){
                String str = s.substring(startIndex, i + 1);
                elem.add(str);
            } else {
                continue;
            }
            backtracking(s, i + 1);
            elem.remove(elem.size() - 1);
        }
    }
    // 判断字符串是否回文
    public boolean isPalindrome(String s, int start, int end){
        while (start < end){
            if (s.charAt(start) == s.charAt(end)){
                start++;
                end--;
            } else {
                return false;
            }
        }
        return true;
    }
}