Day23||● 39. 组合总和● 40.组合总和II● 131.分割回文串

● 39. 组合总和

这个题在写的时候用了一步剪枝操作，但操作的前提是数组应该是有序的。所以这里先用了sort排序。

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

40.组合总和II

这个题的难点在于去重复操作。我们应该对同一层树去重复而不应该是对一条枝干上的情况去重复，所以应该检测一下我们现在candidates[i]=candidates[i-1]的情况是不是i=index的情况。在这里用used数组也是可以的。

 class Solution {
public:
vector<int> path;
vector<vector<int>> result;

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {

        vector<bool> used(candidates.size(),false);
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0,used);
        return result;


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

       for(int i=startIndex;i<candidates.size()&&sum+candidates[i]<=target;i++)
       {
           if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==false)
           {
               continue;
           }
           sum+=candidates[i];
           path.push_back(candidates[i]);
           used[i]=true;
           backtracking(candidates,target,sum,i+1,used);
           used[i]=false;
           path.pop_back();
           sum-=candidates[i];


       }
    }
    
};

● 131.分割回文串

class Solution {
public:
vector<string> path;
vector<vector<string>> result;
    vector<vector<string>> partition(string s) {

           backtracking(s,0);
           return result;
    }
    bool isHui(string s,int a,int b)
    {
        for(int i=a,j=b;i<=j;i++,j--)
        {
            if(s[i]!=s[j])
            return false;
        }
        return true;

    }
    void backtracking(string s,int index)
    {
        if(index>=s.size())
        {
            result.push_back(path);
            return ;
        }

        for(int i=index;i<s.size();i++)
        {
            if(isHui(s,index,i))
            {
                string str=s.substr(index,i-index+1);
                path.push_back(str);
            }
            else
            continue;

            backtracking(s,i+1);
            path.pop_back();
        }

    }
};