代码随想录算法学习心得23 | 39.组合总和、40.组合总和II、 131.分割回文串

一、组合总和

链接：力扣

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

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

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

---

思路如下：

本题需要注意取5的时候，需要在5和3当中取数，这是防止出现与2开头重复的组合，注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！

回溯三部曲：

1、确定函数的参数和返回值。

定义两个全局变量，二维数组result存放结果集，数组temp存放符合条件的结果。

首先是题目中给出的参数，集合candidates, 和目标值target，定义了int型的sum变量来统计单一结果temp里的总和，还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？如果是一个集合来求组合的话，就需要startIndex，如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex。

2、确定终止条件

当sum>target时，直接return，当sum等于target时收集结果并return。

3、确定单层递归的逻辑

注意递归调用中下一层递归是从i开始的。

 剪枝操作：对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。在求和问题中，排序之后加剪枝是常见的套路！

---

代码如下：

#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
    vector<vector<int>>result;//存放最终的结果
    vector<int>temp;//存储单个数组
    void backtracking(vector<int>& candidates, int target,int sum,int start)
    {
        //sum用于记录temp里的元素总和
        if (sum>target)
        {
            return;
        }
        //判断temp的和是否是target
        if (sum == target)
        {
            result.push_back(temp);
            return;
        }

        //单层递归的逻辑
        for (int i = start; i < candidates.size(); i++)
        {
            temp.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target,sum,i);
            temp.pop_back();
            sum -= candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target)
    {
        backtracking(candidates, target,0,0);
        return result;
    }
};
int main()
{
    Solution s;
    vector<int>v{ 2,3,5 };
    s.combinationSum(v, 8);
    return 0;
}

运行如下：

---

二、组合总和II

链接：力扣

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

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

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

---

思路如下：本题与前面类似的题不一样的是candidate中有重复元素，所以需要进行去重操作，去重分为树层去重和树枝去重，本题是进行树层去重，先对原数组进行排序，在树层中时，当第一次遇到重复的元素时，不应该进行去重，而是第二次遇到相同的元素时，应该进行去重，因此需要引入一个used数组来记录是否出现重复元素。

 回溯三部曲：

1、确定函数的参数和返回值。

定义两个全局变量，二维数组result存放结果集，数组temp存放符合条件的结果。used数组用于记录重复元素的出现情况

注意去重操作如下：used[i-1]==0必不可少，因为当第一次取到某一元素时，是不需要进行去重的，也就是树枝里可以出现相同元素，所以需要加这个条件进行去重。

2、确定终止条件

当sum>target时，直接return，当sum等于target时收集结果并return。

3、确定单层递归的逻辑

注意递归调用中下一层递归是从i+1开始的。因为一个元素只能使用一次。

---

代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
    vector<int>temp;//存放单个结果
    vector<vector<int>>result;//存放最终的结果集
    int used[50] = { 0 };//用于记录使用过的元素
    void backtracking(vector<int>& candidates, int target, int sum, int start)
    {
        if (sum > target)
        {
            return;
        }
        if (sum == target)
        {
            result.push_back(temp);
            return;
        }
        for (int i = start; i < candidates.size(); i++)
        {
            if (i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0)
            {//进行去重操作
                continue;
            }
            used[i] += 1;
            temp.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i + 1);
            temp.pop_back();//回溯
            sum -= candidates[i];
            used[i] -= 1;
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target)
    {
        //先进行排序
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

运行如下：

---

 三、分割回文串

链接：力扣

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

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

---

思路如下：

回溯三部曲：

1、确定函数的参数和返回值。

定义两个全局变量，二维数组result存放结果集，全局变量数组temp存放切割后回文的子串，二维数组result存放结果集

本题递归函数参数还需要start，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。

2、确定终止条件

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

 

3、确定单层递归的逻辑

注意递归调用中下一层递归是从i+1开始的。首先判断这个子串是不是回文，如果是回文，就加入在vector<string> temp中，省去麻烦，截取子串的方法：

---

 

代码如下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Solution {
public:
    vector<string>temp;//存放单个字符串
    vector<vector<string>>result;//存放最终的结果
    bool istrue(string s,int start,int end)
    {
        //判断是否是回文串
        while (start <= end)
        {
            if (s[start] != s[end])
            {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
    void backtracking(string s, int start)
    {
        //start相当于分割线
        if (start >= s.size())
        {
            //当切割完毕到末尾时，需要收集结果
            result.push_back(temp);
            return;
        }
        //单层逻辑
        for (int i = start; i < s.size(); i++)
        {
            if (istrue(s,start,i))
            {
                //是回文串,start是起始位置，end是终止位置
                temp.push_back(s.substr(start,i-start+1));
            }
            else
            {
                continue;
            }
            backtracking(s, i + 1);回溯
            temp.pop_back();
        }
    }
    vector<vector<string>> partition(string s)
    {
        backtracking(s, 0);
        return result;
    }
};
int main()
{
    Solution s;
    s.partition("aab");
    return 0;
}

运行如下：