代码随想录Day27 | 39. 组合总和 40.组合总和II 131.分割回文串

39.组合总和

文档讲解：代码随想录
视频讲解： Leetcode:39. 组合总和讲解
状态

本题和之前的题目主要有两个不同点，一个是终止条件，之前明确说了递归的层数，这道题是使用和来确定终止条件，第二个是同一个数可以重复使用。也就是说每层的父节点可以在子树中存在使用。所以我们的每层递归的起始位置需要有所区别。

1. 终止条件：当和大于等于Target的时候要终止循环，并且和等于target的时候要压入结果数组中

if(sum > target)
{
     return;
}
if(sum == target)
{
  res.push_back(path);
  return;
}

2. 参数：由于需要和来确定终止条件所以需要每层传入当前的和。
3. 单层递归：对每个节点(for循环)使用递归，记得回溯，将压入的元素弹出以及将和复原

具体代码

class Solution {

private:
vector<vector<int>> res;
vector<int> path;

public:
    void getSum(vector<int>& candidates, int target, int sum, int startIndex)
    {

        if(sum > target)
        {
            return;
        }
        if(sum == target)
        {
            res.push_back(path);
            return;
        }

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

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        getSum(candidates,target,0,0);
        return res;
    }
};

40.组合总和II

文档讲解：代码随想录
视频讲解： 回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II
状态

组合结果去重：先排序，同一层相同元素直接跳过，向子树递归出现重复元素可以记录

区分重复元素是在同一层还是在同一个树枝

利用一个数组used来记录当前节点的是否正在被使用，如果正在被使用就记为1，没有被使用就记为0。
这样对于同一层的节点一个时间只有一个值为1，其余值都为0。
而对于一个树枝上的节点，1的个数会逐渐增加，直到满足结果返回，然后1的数量开始减少。
所以首先判断当前数组中的值是否相同，即nums[i-1]==nums[i]如果不相同那可以直接进行下一步，如果相同，那么还需要判断used[i-1]是否为1，如果为1就表示当前在树枝上，可以重复。如果为0，就表示当前在同一层不能够重复。应当舍去这个分枝，对下一个枝进行递归。

具体代码

class Solution {
private:
vector<vector<int>> res;
vector<int> path;

public:
    void getSum(vector<int>& candidates, int target, int startIndex, int sum, vector<int>& used)
    {
        //终止条件
        if(sum > target)
        {
            return ;
        }
        if(sum == target)
        {
            res.push_back(path);
            return ;
        }

        //单层递归
        for(int i = startIndex;i<candidates.size();i++)
        {
            //避免重复
            if(i>0 && candidates[i-1] == candidates[i] && used[i-1] == 0)
            {
                continue ;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = 1;
            getSum(candidates,target,i+1,sum,used);
            used[i] = 0;
            path.pop_back();
            sum -= candidates[i];
        }
        return ;
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int> used(candidates.size());
        sort(candidates.begin(),candidates.end());
        getSum(candidates,target,0,0,used);
        return res;
    }
};

131.分割回文串

文档讲解：代码随想录
视频讲解： 131.分割回文串
状态

分割与组合，主要区别在于加入到路径容器中的是分割符之前的所有值，而不是一个字符。即我们这一层作为下一层的父节点是需要包含从startIndex到i的所有字符，而之前是只需要i就可以了。

1. 获取分割的字符串，控制一层中的index可以作为分割符，那么该层的所有字符串就是startIndex -> i

for(int i = startIndex,i<s.size();i++) // 当前这一层的遍历
{
	//获取这一层的节点 之前就是s[i]
	string str = s.substr(startIndex,i-startIndex+1);
	//如果当前节点是回文串，那么就可以继续向下递归，否则直接跳过
	if(check(str))
	{
		path.push_back(str);
		func1(s,i+1);
		path.pop_back();
	}
	else
	{
		continue;
	}
}

2. 终止条件：当前的startIndex到达原始字符串末尾时，就需要终止递归了。

if(startIndex >= s.size())
{
	res.push_back(path);
	return ;
}

3. 利用双指针判断是否是回文
   具体代码

//path 记录每种分割的方式， 如果path中所有string都是回文，那么添加到res;
//

class Solution {
private:
vector<vector<string>> res;
vector<string> path;

public:
    //检查是否是回文串
    bool rcheck(string s)
    {
        int left = 0;
        int right = s.size()-1;
        while(left<right)
        {
            if(s[left++]!=s[right--])
            {
                return false;
            }
        }
        return true;
    }

    void getres(string s, int startIndex)
    {
        if(startIndex >= s.size())
        {
            res.push_back(path);
            return ;
        }
        for(int i=startIndex;i<s.size();i++)
        {
            string str = s.substr(startIndex, i - startIndex + 1);
            if(rcheck(str))
            {
                path.push_back(str);
                getres(s,i+1);
                path.pop_back();
            }
            else
            {
                continue;
            }
        }
    }
public:
    vector<vector<string>> partition(string s) {
        getres(s,0);
        return res;
    }
};