代码随想录训练营第27天|39.组合总和、40.组合总和Ⅱ、131.分割回文串

39.组合总和、40.组合总和Ⅱ、131.分割回文串

39.组合总和

这个问题，与以往不同的点在于，这些元素可以重复包含，因此，我们可以每次在递归时，带上本次元素，这样可以包含重复的元素，同时也可以避免结果中，数组的重复。

首先，我们定义一个一些全局变量
结果数组，result，用来记录结果。
临时数组，temp，用来记录当前数组中的元素，如果递归时满足条件，就把该temp加入到result中。
临时数组的和，sum，用来记录当前数组中的元素和，如果递归时满足sum==target，我们就将temp放入result。
如果sum>temp，我们就不再处理，直接返回上一级。
对问题进行递归回溯即可。
同时，我们可以先将数组进行排序，这样当sum>target时，我们就可以直接在本次循环中截止。

代码

class Solution {
public:
vector<vector<int>> result;
vector<int>temp;
int num;
void backtracking(vector<int>& candidates, int target,int start)
{
    if(num==target) result.push_back(temp);
    else if(num<target)
    {
        for(int i =start;i<candidates.size();i++)
        {
            num+=candidates[i];
            temp.push_back(candidates[i]);
            backtracking(candidates,target,i);
            temp.pop_back();
            num-=candidates[i];
        }
        
    }
}
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if(candidates.empty()) return result;
        backtracking(candidates,target,0);
        return result;
        
    }
};

40.组合总和Ⅱ

对于该问题，首先比较困难的是，数组中具有重复元素，并且结果中不能重复，因此，我们需要对元素进行去重，方便起见，可以先对数组进行排序，使其从小到大排列。

暴力去重

排列之后，我们可以定义一个函数用来判断此次要加入的数组与上次加入的数组是否相同，
如果result是空的，直接加入就行，如果不为空，我们就让result尾数组与temp进行比较，如果不一样，就加入到result。
同时，在遍历的时候，我们可以稍微做些剪枝，如果for循环的本次元素与上次元素相同（此处需要使得下标大于0，否则会越界报错），我们就while循环，让循环元素后移（需要避免越界），防止反复判断同一个元素。

代码

class Solution {
public:
vector<vector<int>> result;
vector<int>temp;
int sum=0;
bool compare(vector<int>& nums1,vector<int>& nums2)
{
    if(nums1.size()!=nums2.size())
    return false;
    for(int ii = 0;ii<nums1.size();ii++)
        if(nums1[ii]!=nums2[ii])
        return false;
    return true;
}
void backtracking(vector<int>& candidates, int target,int start)
{
    if(sum == target) 
    {
        if(result.empty())
            result.push_back(temp);
        else
        {
            int k =result.size()-1;
            if(!compare(result[k],temp))
                result.push_back(temp);
        }
    }
    
    for(int ii = start;ii<candidates.size()&&sum+candidates[ii]<=target;ii++)
    {
        if(ii>0)
        {
            while(candidates[ii]==candidates[ii-1]&&ii<candidates.size()-1&&ii>start)
            ii++;
        }
        sum+=candidates[ii];
        temp.push_back(candidates[ii]);
        backtracking(candidates,target,ii+1);
        temp.pop_back();
        sum-=candidates[ii];
    }
}
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if(candidates.empty()) return result;
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0);
        return result;
    }
};

剪枝去重

对于每一层的for循环，我们可以判断该元素是不是for循环的start元素，如果不是首元素，就要避免这个循环的元素与前面的元素相同，我们用while循环让ii++，同时避免越界，当ii越界时候，就break掉for循环，这样也可以进行去重。

代码

class Solution {
public:
vector<vector<int>> result;
vector<int>temp;
int sum=0;
void backtracking(vector<int>& candidates, int target,int start)
{
    if(sum == target) result.push_back(temp);
    else
    {
    for(int ii = start;ii<candidates.size()&&sum+candidates[ii]<=target;ii++)
        {
            if(ii>start)
            {
                while(ii<candidates.size()&&candidates[ii]==candidates[ii-1])
                ii++;
            }
            if(ii == candidates.size())
            break;
            sum+=candidates[ii];
            temp.push_back(candidates[ii]);
            backtracking(candidates,target,ii+1);
            temp.pop_back();
            sum-=candidates[ii];
    }
    }
    
}
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if(candidates.empty()) return result;
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0);
        return result;
    }
};

131.分割回文串

很显然，我们可以用回溯算法来处理这道题。也不是那么显然，刚开始我也不知道逻辑。
首先，我们要是保证我们分割出来的子串是回文串，最好创建一个函数来判断这个字串。

bool is_partition(string& s,int start,int end)
{

    while(start<end)
    {
            if(s[start]!=s[end])
                return false;
            start++;
            end--;
    }      
    return true;
}

从两边向中间遍历，如果两边都相等，就是回文子串。
首先，我们创建一个回溯的函数
void backtracking
用于进行递归和回溯。
参数有 字符串和起始下标。
如果起始下标等于了字符串长度，就把temp放入result中。
如果起始下标不等于字符串长度，就进行for循环，从起始下标startindex到字符串长度，进行遍历。
如果从startindex到循环的ii是回文子串，就先把这个子串放入到temp中，并进行下一步递归，递归结束，弹出子串。

最后，返回result即可。

class Solution {
public:
vector<vector<string>>result;
vector<string>temp;
bool is_partition(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 startindex)
{
    if(startindex==s.size()) result.push_back(temp);
    else
    {
        for(int ii =startindex;ii<s.size();ii++)
        {
            if(is_partition(s,startindex,ii))
            {
                string str = s.substr(startindex,ii-startindex+1);
                temp.push_back(str);
                backtracking(s,ii+1);
                temp.pop_back();
            }
            
        }
    }

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