代码随想录算法训练营第二十七天| 39. 组合总和 40.组合总和II 131.分割回文串

 39. 组合总和  

思路

把它抽象为树的结构，数组的长度为树的宽度，目标和决定了树的深度。

解题方法

1.首先决定，递归函数参数和返回值，一般是void类型。

2.确定终止条件：sum>target,直接return ;sum==target,用result保存path。

3.单层递归逻辑：for循环，遍历集合中的元素。递归时，起始元素是i，因为题目中说“同一个数字可以无限制重复被选取”。

注意第三步可以做剪枝操作，当sum+candiadates[i]>target时，i已经没有必要向后遍历了，所以i遍历范围是i<=sum+candiadates[i]。

复杂度

时间复杂度:

O(n*2^n),剪枝的远小于这个

空间复杂度:

O(target)

Code

class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
    void backtracking(vector<int>&candidates,int target,int sum,int startIndex)
    {
        if(sum>target)return;
        if(sum==target){
            result.push_back(path);
            return;
        }
        for(int i=startIndex;i<candidates.size();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();
        backtracking(candidates,target,0,0);
        return result;
        
    }
};
剪枝版：
class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
    void backtracking(vector<int>&candidates,int target,int sum,int startIndex)
    {
        if(sum>target)return;
        if(sum==target){
            result.push_back(path);
            return;
        }
        for(int i=startIndex;i<candidates.size()&&sum+candidates[i]<=target;i++)//剪枝操作
        {
            path.push_back(candidates[i]);
            sum+=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  

思路

 题目关键：树形结构，两层去重，树层去重，树枝去重

解题方法

树层去重：定义一个bool型的数组，若第i个位置已经使用过标记为used[i]==true,若没有，used[i]==false;要同时满足数组前一个元素和当前元素数值相等，且i>0.

树枝去重：递归从i+1位置开.

回溯：把原先加进path的元素再pop出去，sum加上的元素再减去。

复杂度:

时间复杂度

O(n*2^n)

空间复杂度:

O(n)

Code

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

    }
};

131.分割回文串  

思路

 抽象为树形结构，递归纵向遍历，for循环横向遍历，startIndex表示分割线，当startIndex>=s.size()时，表示遍历到末尾了，可以收集结果了。

解题方法

首先定义俩个全局变量result,path

递归函数参数s,startIndex

终止条件：startIndex>=s.size()

单层递归逻辑：for循环从startIndex开始，如果在s中，从startIndex到i-startIndex+1,是回文串，path就加进去，否则continue,然后递归，path.pop_back()

判断是否回文串，用双指针法，一个在首，一个在尾，如果相同，就是回文串。

Code

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

    }
};