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

39. 组合总和

题目链接

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

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

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

**思路：**回溯模板解决：
1、求组合问题可以用回溯法直接套模板改终止条件和相关的条件即可
2、因为元素可以被重复选取，那么模板中的startIndex的位置，在递归的时候直接用 i 即可，多次调用

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

        for (int i = startIndex; i < nums.size(); i++) {
            sum += nums[i];
            path.push_back(nums[i]);
            backtracking(nums, target, i);// 关键点:不用i+1了，表示可以重复读取当前的数
            sum -= nums[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return result;
    }
};

剪枝操作，数组排完序后，如果相加的和大于了target，那么就不再继续循环了

// 如果 sum + candidates[i] > target 就终止遍历
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

总结：

组合没有数量要求
元素可无限重复选取

**关键点:**不用i+1了，表示可以重复读取当前的数
在求和问题中，排序之后加剪枝是常见的套路！

组合总和II

题目链接

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

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

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

思路： 回溯 + 去重

1、拿到本题，和上一题不一样，本题不能够出现相同的组合，并且每个元素只能使用依次，所以关键的点在于去重
2、根据代码随想录卡哥的 “树层去重和树枝去重”，构建一个used数组

class Solution {
public:
    // 去重是大难点
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& nums, int target, int startIndex, vector<bool> & used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < nums.size() && sum + nums[i] <= target; i++) {
            if (i > 0 && nums[i] == nums[i-1] && used[i-1] == false) {
                continue;
            }

            sum += nums[i];
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, target, i+1, used);
            sum -= nums[i];
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<bool> used(candidates.size(), false);
        backtracking(candidates, target, 0, used);
        return result;
    }
};

总结： used数组最开始不是很好理解，还要多看代码随想录的案例，这样才能够AC这道题。

131.分割回文串

题目链接

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

思路： 这题属于切割问题，第一次做没有那么简单，但是套回溯模板还是能做一部分

本题这涉及到两个关键问题：
1、切割问题，有不同的切割方式
2、判断回文

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

回溯三部曲：
1、递归函数参数
本题递归函数参数还需要startIndex，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。

vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {

2、递归函数终止条件

切割线是关键

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

3、单层搜索的逻辑
首先判断这个子串是不是回文，如果是回文，就加入在vector path中，path用来记录切割过的回文子串。

for (int i = startIndex; i < s.size(); i++) {
    if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }
    backtracking(s, i + 1); // 寻找i+1为起始位置的子串
    path.pop_back();        // 回溯过程，弹出本次已经填在的子串
}

注意切割过的位置，不能重复切割，所以，backtracking(s, i + 1); 传入下一层的起始位置为i + 1。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经填在的子串
        }
    }
    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;
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

总结：这道题在卡哥代码随想录上有优化版本，在二刷的时候做完动态规划可以继续看看。我做这道题只会了模板，很害怕下次再遇到这种题目又不会做了，所以还要加强练习和学习。