代码随想录算法 Day23 | Ch7 回溯算法(二 )● 39.组合总和 ● 40. 组合总和 Ⅱ ●131. 分割回文串

一、组合总和

        1.题目：给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

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

        2.思路：基本回溯模板

        3.注意：数字可以重复，在递归时startIndex不用 +1，从当前数字开始即可

        4.代码：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

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

        if( target < 0 )
        {
            return;
        }

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

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates, target, 0);
        return result;
    }
};

二、组合总和 Ⅱ

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

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

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

        2.思路：

        3.注意：

        （1）candidates 中每个数字只用使用一次，但集合里会存在重复元素，所以用 sort() 先排序

        （2）区分等值元素是同一树层用过还是同一树枝用过。

        4.代码：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;

    void backtracking(vector<int>& candidates, int target, int startIndex, vector<bool>& used)
    {
        if(target == 0)
        {
            result.push_back(path);
            return;
        }

        if( target < 0) return;

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

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, used);
        return result;
    }
};

三、分割回文串

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

        回文串：从前往后 与 从后往前 字母一致。

        2.思路：

        3.注意：

        4.代码：

class Solution {
public:
    vector<string> path;
    vector<vector<string>> result;

    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(string &s, int startIndex){
        if (startIndex >= s.size()) {
        result.push_back(path);
        return;
        }

        for(int i=startIndex; i<s.size(); i++){
            // 不是回文，跳过
            if ( !isPalindrome(s, startIndex, i)) {   
                continue;
            }
            // 是回文子串
            // 获取[startIndex,i]在s中的子串
            string str = s.substr(startIndex, i - startIndex + 1);
            path.push_back(str);

            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经添加的子串
        }
    }

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