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

组合总和

39. 组合总和 - 力扣（LeetCode）

组合总和，这里有几点需要考虑，一是允许数字的重复使用，即相比于之前的组合，我们的start无需从索引的下一位开始，二是回溯中的返回，当总和等于target时，收获currentPath 需要返回，其次，若总和大于target时也要返回。三是考虑到要求和，尽量需要先将比较小的数字加入，所以在回溯前，考虑对数组进行排序，方便回溯。具体代码如下。

class Solution {
public:
    vector<int> currentPath;
    vector<vector<int>> allPaths;

    void backtracking(vector<int>& candidates, int target, int start, int sum) {
        if (sum > target) {
            return; // 当前路径和超过目标值，回溯
        }
        if (sum == target) {
            allPaths.push_back(currentPath); // 找到一个有效的组合，添加到结果中
            return;
        }
        for (int i = start; i < candidates.size(); i++) {
            currentPath.push_back(candidates[i]); // 添加当前候选项到路径中
            sum += candidates[i]; // 更新路径和
            backtracking(candidates, target, i, sum); // 递归回溯，注意从当前索引开始
            sum -= candidates[i]; // 回溯
            currentPath.pop_back();
        }
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 先对候选数组排序
        backtracking(candidates, target, 0, 0); // 从索引0和路径和0开始回溯
        return allPaths; // 返回所有可能的组合
    }
};

算法的时间复杂度为O(n * 2^n)，最坏的情况下，我们需要遍历所有可能的组合。对于每个数字，我们可以选择它或者不选择它，所以，总的组合数为2^n，此外，对每个组合，我们需要判断其是否等于目标值，这需要O(n)的时间，此外，排序所需的O(nlogn)相比之下量级太小，总的时间复杂度为O(n*2^n)。

空间复杂度为每次维护的currentPath，为O(n)。

组合总和II

40. 组合总和 II - 力扣（LeetCode）

        和上题类似，但要考虑不能有重复，参考之前的剪枝操作，在回溯的循环中，加入一下代码，让每次循环回溯时，若存在与之前相同项，continue，而不是重复添加组合。

if (i > start && candidates[i] == candidates[i - 1]) {
       continue; // 避免重复使用相同的候选项
      }

        具体代码是在上题的基础上改动了一些，首先是加入上述的判断，其次，每次回溯参数要选择当前索引的下一位。

class Solution {
public:
    vector<int> currentPath;
    vector<vector<int>> allPaths;

    void backtracking(vector<int>& candidates, int target, int start, int sum) {
        if (sum > target) {
            return; // 当前路径和超过目标值，回溯
        }
        if (sum == target) {
            allPaths.push_back(currentPath); // 找到一个有效的组合，添加到结果中
            return;
        }
        for (int i = start; i < candidates.size(); i++) {
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue; // 避免重复使用相同的候选项
            }
            currentPath.push_back(candidates[i]); // 添加当前候选项到路径中
            sum += candidates[i]; // 更新路径和
            backtracking(candidates, target, i+1, sum); // 递归回溯，注意从当前索引的下一个索引开始
            sum -= candidates[i]; // 回溯
            currentPath.pop_back();
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 先对候选数组排序
        backtracking(candidates, target, 0, 0); // 从索引0和路径和0开始回溯
        return allPaths; // 返回所有可能的组合
    }
};

算法的时间复杂度为O(n * 2^n)，最坏的情况下，我们需要遍历所有可能的组合。对于每个数字，我们可以选择它或者不选择它，所以，总的组合数为2^n，此外，对每个组合，我们需要判断其是否等于目标值，这需要O(n)的时间，此外，排序所需的O(nlogn)相比之下量级太小，总的时间复杂度为O(n*2^n)。

空间复杂度需要维护的是每个临时路径的结果，最大为O(n)

分割回文串

131. 分割回文串 - 力扣（LeetCode）

 

class Solution {
public:
    vector<string> path;
    vector<vector<string>> paths;
    
    // 判断字符串s从start到end的部分是否是回文串
    bool isPalindrome(const 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;
    }
    void backtracking(const string &s, int startofindex){
        // 如果起始索引大于等于字符串长度，说明找到了一个有效的分割
        if(startofindex>=s.size()){
            paths.push_back(path);
            return;
        }
        for(int i = startofindex; i < s.size(); i++){
            // 如果s[startofindex...i]是回文串，则加入当前路径
            if(isPalindrome(s,startofindex,i)){
                string str = s.substr(startofindex, i - startofindex + 1);
                path.push_back(str);
                // 继续递归尝试下一个子串
                backtracking(s, i + 1);
                // 回溯，移除路径上的最后一个子串，尝试其他可能的分割
                path.pop_back();
            }
            // 如果不是回文串，则跳过当前循环，尝试下一个索引
        }
    }
    vector<vector<string>> partition(const string &s) {
        backtracking(s,0);
        return paths;
    }
};

对于每个起点startofindex，需要尝试所有可能的终点i，并检查该子串是否为回文串，这个检查过程的时间复杂度为O(n)，此外有n个可能的起点，每个起点有n个可能的重点，所以总的检查次数为O(n^2)，此外，对于每个检查成功的回文串，还需要进行一次递归调用。在最坏的情况下，每次递归调用都会检查到字符串s的末尾，因此递归深度也是O(n)。算法的时间复杂度为O(n^3)。

空间复杂度考虑栈深度和存储分割的空间，栈深度最差为O(n)，存储分割结果的空间取决于所有分割中的回文串数量，最坏情况下，每个字符都是一个回文串，所以是O(n^2)。因此空间复杂度为O(n^2)。