Day23:39. 组合总和、40.组合总和II、131.分割回文串

39. 组合总和

题目链接

思路

1. 参数
   result：存结果集
   path：存单层路径
   sum：判断和是否符合条件

2. 递归结束条件
   当sum==target则储存结果
   当sum>target则结束递归

3. 单层递归操作
   单层for循环依然是从startIndex开始，和组合总和II一样不一样的点是还可以重新取自身，所以递归传入的startIndex不需要加1

4. 剪枝操作
   对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

代码实现

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

        // 如果 sum + candidates[i] > target 就终止遍历
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();

        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end()); // 需要排序
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

---

40.组合总和II

题目链接

思路

这道题不能重复使用一个元素，但元素集合里可以有重复元素。

1. 参数
   result、path、sum，和上面的题目一样
2. 结束递归条件
   当sum>target，直接回退
   当sum=target，储存结果并回退
3. 单层递归操作
   和上一道题差不多，但多了一个去重操作。
   去重：先排序，排序后的去重和三数之和、四数之和差不多，都需要判断当前元素是否和前一个元素一样且是否已经访问过，如果一样且已访问则需要去重。
   这里有一个很重要的点：
   为什么前一个元素未访问才可以去重呢？因为当前一个元素被访问了，那么当前结点和它就是同一层的递归，如果没有访问则是取新重复元素时的新的递归，这时才能剪枝。
   如当集合元素为{1,1,2}，sum=2。当从第一个1开始访问时{1,1}是符合条件的，不应该去重；但当从第二个1开始访问时，就可以去重了，判断是从哪开始访问的要点就是前一个相同元素是否被访问过了。

if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
        continue;
    }

代码实现

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

---

131.分割回文串

题目链接

思路

1. 参数
2. 终止条件
   遍历到字符串最后位置终止（如果不是回文子串则不可能遍历到最后）
3. 单层递归条件
   startIndex为子串的左边界，i为子串右边界。先判断子串是否为回文子串，如果不是则继续扩大子串右边界，是则存入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();        // 回溯过程，弹出本次已经添加的子串
}

代码实现

class Solution {
public:
    vector<vector<string>> result;
    vector<string> path;
    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)){
                string str=s.substr(startIndex,i-startIndex+1);
                path.push_back(str);
            }
            else continue;
            backtracking(s,i+1);
            path.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s,0);
        return result;
    }
};

---

总结

组合问题：N个数里面按一定规则找出k个数的集合

1. 在有n个无重复元素的数组里找k个和为sum的值（不能重复使用一个元素）组合1
   
2. 在有n个无重复元素的数组里找k个和为sum的值（可以重复用一个元素）组合2
3. 在有n个有重复元素的数组里找k个和为sum的值（不可以重复用一个元素）组合3
   
4. 在n个数组内分别找一个元素，其n个值和为sum组合4
   

---