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

目录

一、39. 组合总和

二、40. 组合总和 II

三、131. 分割回文串

---

一、39. 组合总和

题目链接：力扣

文章讲解：代码随想录

视频讲解： Leetcode:39. 组合总和讲解

题目：

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

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

代码：

class Solution {
public:
    void dfs(vector<vector<int>> &ans, vector<int> &candidates, int &target, int sum, vector<int> path, int begin){
        if (sum >= target){
            if(sum == target) ans.push_back(path);
            return;
        }
        for(int i = begin; i < candidates.size() && sum+candidates[i] <= target; i++){
            int x = candidates[i];
            path.push_back(x);
            dfs(ans, candidates, target, sum+x, path, i);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> path;
        sort(candidates.begin(), candidates.end());
        dfs(ans, candidates, target, 0, path, 0);
        return ans;
    }
};

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

⏲：6:30

总结：1.在求和问题中，排序之后加剪枝是常见的套路。排序时间复杂度远低于回溯，能用则用吧。

二、40. 组合总和 II

题目链接：力扣

文章讲解：代码随想录

视频讲解：回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II

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

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

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

代码：

class Solution {
public:
    void dfs(vector<vector<int>> &ans, vector<int>& candidates, int target, vector<int> path, int sum, int begin){
        
        if(sum == target) {
            ans.push_back(path);
            return;
        }
        for (int i = begin; i < candidates.size() && target >= sum+candidates[i]; i++){
            if(i > begin && candidates[i-1] == candidates[i] ) continue;
            path.push_back(candidates[i]);
            dfs(ans, candidates, target, path, sum+candidates[i], i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<vector<int>> ans;
        vector<int> path;
        dfs(ans, candidates, target, path, 0, 0);
        return ans;
    }
};

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

⏲：8:12

总结：层级去重：排序后，相邻相同，后者跳过。理解为，当两者相同时，后序的可能性也相同，只选一个即可，而前者拥有包含后者的情况，故选前者。

           回溯的问题都可抽象成为树，而树有层级重复与枝级(指元素可重复选取)重复，层级靠排序去重，值级靠递归时i+1来避免重复。

三、131. 分割回文串

题目链接：力扣

文章讲解：代码随想录

视频讲解：131.分割回文串

题目：给你一个字符串 s，请你将 s分割成一些子串，使每个子串都是 回文串 。返回 s所有可能的分割方案。回文串 是正着读和反着读都一样的字符串。

代码：

//切割问题

class Solution {
public:
    //双指针
    /*bool ispalindrome(string &s, int start, int end)
    {
        for (int i = start, j = end; i <= j; i++, j--)
            if (s[i] != s[j]) return false;
        return true;
    }*/
    //dp
    void palindrome(const string& s, vector<vector<bool>> &ispalindrome) //左闭右闭
    { 
        for (int i = s.size()-1; i >= 0; i--) { 
            //需要倒序计算, 保证在i行时, i+1行已经计算好了
            //两个顺序，一个时第i行时i+1行已有，一个是左到右(少到多)
            for (int j = i; j < s.size(); j++) 
            {
                if (j == i) 
                    ispalindrome[i][j] = true;
                else if (j - i == 1) 
                    ispalindrome[i][j] = (s[i] == s[j]);
                else 
                    ispalindrome[i][j] = (s[i] == s[j] && ispalindrome[i+1][j-1]);//s[0] == s[n-1]且s[1:n-1]
            }
        }
    }
    void backtracking(int start, vector<vector<string>> &ans, vector<string> &path, string &s, vector<vector<bool>> &ispalindrome)
    {
        if (start >= s.size())
        {
            ans.push_back(path);
            return;
        }
        for (int i = start; i < s.size(); i++)
        {
            if (/*ispalindrome(s, start, i)*/ispalindrome[start][i])//判断回文
            {
                string str = s.substr(start, i - start + 1);//复制字符串suber(起始，数量)
                path.push_back(str);
                backtracking(i+1, ans, path, s, ispalindrome);
                path.pop_back();

            }
        }

    }
    vector<vector<string>> partition(string s) {
        vector<vector<string>> ans;
        vector<vector<bool>> ispalindrome(s.size(), vector<bool>(s.size(), false));
        vector<string> path;
        palindrome(s, ispalindrome);
        backtracking(0, ans, path, s, ispalindrome);
        return ans;
    }
};

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

⏲：11:42

总结：

1.切割问题可以抽象为组合问题：每层从左到右，切割成左右两部分，下一层从切割点往右切割。

2.切割问题中递归如何终止：切割线的下标（即start），到了最后一位后面（即等于size）。

3.在递归循环中如何截取子串：suber函数，.suber（起始，数量）。

4.如何判断回文：（1）双指针（2）dp：倒序计算   s[0] == s[n-1]且s[1:n-1]