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

39. 组合总和

题目链接：39. 组合总和，难度：中等
【实现代码】

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(const vector<int>& candidates, int target,int startIndex) {
        if (target == 0) {
            result.push_back(path);
            return ;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            if (candidates[i] > target) {
                return ;
            }
            path.push_back(candidates[i]);
            backtracking(candidates, target - candidates[i], i);
            path.pop_back();
        }
        return ;
    }

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return result;
    }
};

【解题思路】

组合问题使用回溯算法解决。
回溯三步曲：

1. 确定函数参数：一般先写逻辑，用到什么写什么，这里有候选列表、目标值和开始索引
2. 确定结束条件：当总和等于目标值时结束
3. 确定单层逻辑：如果当前值不大于目标值，则存入path，之后进行递归，因为可以重复元素，所以开始索引从当前开始，之后弹出元素。

40.组合总和II

题目链接：40.组合总和II，难度：中等
【实现代码】

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    
    void backtracking(const vector<int>& candidates, int target,int startIndex) {
        if (target == 0) {
            result.push_back(path);
            return ;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            if (candidates[i] > target) {
                return ;
            }
            if (i > startIndex && candidates[i - 1] == candidates[i]) {
                continue;
            }
            path.push_back(candidates[i]);
            backtracking(candidates, target - candidates[i], i + 1);
            path.pop_back();
        }
        return ;
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return result;
    }
};

【解题思路】

组合问题使用回溯算法解决。这一题和上一题基本类似，难点在于去重。
回溯三步曲：

1. 确定函数参数：一般先写逻辑，用到什么写什么，这里有候选列表、目标值和开始索引
2. 确定结束条件：当总和等于目标值时结束
3. 确定单层逻辑：如果当前值不大于目标值，则存入path；接着去重，当开始索引后的值与前一个相同时则直接进行下一个数；之后进行递归，因为元素不能重复，所以开始索引从下一个开始，之后弹出元素。

131.分割回文串

题目链接：131.分割回文串，难度：中等
【实现代码】

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path;
    bool isPalindrome(const string& s, int start, int end) {
        while (start < end) {
            if (s[start] != s[end]) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
    void backtracking(const string& s, int startIndex) {
        if (startIndex >= s.size()) {
            result.push_back(path);
            return ;
        }

        for (int i = startIndex; i < s.size(); i++) {
            //cout << i << " ";
            if (isPalindrome(s, startIndex, i)) {
                path.push_back(s.substr(startIndex, i - startIndex + 1));
            } else {
                continue;
            }
            backtracking(s, i + 1);
            path.pop_back();
        }
        //cout << endl;
        return ;
    }

public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

【解题思路】

切割问题使用回溯算法解决。步骤是先切割再判断回文串
回溯三步曲：

1. 确定函数参数：一般先写逻辑，用到什么写什么，这里有字符串和开始索引
2. 确定结束条件：开始索引大于等于字符串长度时结束
3. 确定单层逻辑：切割（使用开始索引作为切割点），判断是否回文，不是的话继续下一个索引，否则继续切割，递归后弹出当前元素。

可以尝试画出递归的执行过程，或者直接把每一步递归的过程用代码描述出来，非常清楚！
实例为“aab”，打印的结果是
0 1 2
2
1 2
2
即切割的过程为：
a|a|b|
a|ab|
aa|b|
aab|