代码随想录算法训练营day27|39. 组合总和40.组合总和II131.分割回文串

问题1：39. 组合总和 - 力扣（LeetCode）

思路：题目要求一个数组中元素和等于target的子数组，元素可以重复使用。这个题的难点就在于元素可以重复使用，实际上就相当于每层的重复循环遍历。终止条件为当sum等于target时，将子数组存入result中，大于时则直接ruturn，而单层循环逻辑则注意加回溯，代码如下：

class Solution {
public:
    vector<vector<int>> result;
    int sum=0;
    vector<int> zh;
    void traversal(vector<int>&candidates,int target,int index){
        int s=candidates.size();
        if(sum == target) {
            result.push_back(zh);
            return;
        }
        if(sum>target) return;
        if(sum<target){
            for(index;index<s;index++){
                sum+=candidates[index];
                zh.push_back(candidates[index]);
                traversal(candidates,target,index);
                sum-=candidates[index];
                zh.pop_back();
            }
        }
        }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        traversal(candidates,target,0);
        return result;
    }
};

问题2：40. 组合总和 II - 力扣（LeetCode）

思路：该题要求子数组中不能有重复元素，但原数组在可能会存在重复元素，从而导致递归的过程中出现重复数组，因此需要先对原数组进行排序，同时定义一个used用于判断是否出现重复元素，代码如下：

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

问题3：131. 分割回文串 - 力扣（LeetCode）

思路：题目要求分割回文串，首先定义一个判定回文串的函数，然后再确定递归逻辑。该题由于是对数组进行划分，需要重复进行，所以采用索引与数组大小的比较来确定是否终止，代码如下：

class Solution {
public:
    vector<vector<string>> result;
    vector<string> path;
    bool IsHuiWen(const string& t,int left,int right){
        while(left<right){
            if(t[left] != t[right]) return false;
            left++;
            right--;
        }
        return true;
    }
    void trackback(const string& s,int index){
        if(index>=s.size()) {
        result.push_back(path);
        return;
        }
        for(int i=index;i<s.size();i++){
            if(IsHuiWen(s,index,i)){
                string str=s.substr(index,i-index+1);
                path.push_back(str);
            }
            else{
                continue;
            }
            trackback(s,i+1);
            path.pop_back();
                    }

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

// 对称的字符串