【C++编程能力提升】

一、39 组合总和

题目链接：39 组合总和

核心：本题未直接点明组合的个数，但要求组合内元素之和等于target，这是间接说明组合的个数，因此终止条件不再是组合个数满足要求，而是组合内元素总和等于target。
第一，在回溯遍历的搜索过程中，每递归遍历到一个元素需计算sum，并记录该元素到当前组合path；
第二，由于元素允许被重复选取，因此在调用回溯函数时，start无需为i+1，令其为i即可；
第三，剪枝优化：如果组合内sum大于target则退出，但这样设置仍然需要遍历sum大于target的元素，因此可以在for循环中，增加一个条件：sum+candidates[i]<=target，限制不满足要求的元素进入遍历；
第四，主函数需要对candidates排序，才能调用回溯函数，因为排序后剪枝优化才起作用，否则是不能进行剪枝操作的。

    vector<vector<int>> res;    //记录组合集
    vector<int> path;           //记录满足条件的某个组合
    void backtracking(vector<int>& candidates,int target,int sum,int start)
    {
        //if(sum>target)
            //return;
        if(sum==target)
        {//终止条件：某个组合内的和为target，即该组合满足条件，需push到res
            res.push_back(path);
            return;
        }
        //回溯遍历的搜索逻辑：
        for(int i=start;i<candidates.size() && sum+candidates[i]<=target;++i)
        {//剪枝优化：对i进行优化，增加一个条件sum+candidates[i]<=target才进入循环
            path.push_back(candidates[i]);  //处理节点
            sum+=candidates[i];             //累加，sum是组合path内元素之和
            backtracking(candidates,target,sum,i);  //允许重复无需要求i+1
            sum-=candidates[i];             //回溯，撤销处理
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());  //先排序，后面才能进行剪枝优化
        backtracking(candidates,target,0,0);        //从candidates[0]第一个元素开始
        return res;
    }

二、40 组合总和II

题目链接：40 组合总和II

核心：与39 组合总和的区别在于，其一candidates存在重复元素，其二元素只能使用一次，且要求组合不能重复。这就意味着需要去重。比如：candidates=[1,2,2,2,5]，target=5,那么满足的组合有[122]和[5]，也就是说在第一个树枝遍历得到[122]后（第一层是1，第二层是2，第三层是2），第三层实际上还有一个2，但第三层已使用了一个2，因此对这个2去重，同样第二层也存在去重的2.
第一，终止条件依然是组合内元素之和等于target；
第二，剪枝优化同样是for循环增加一个条件：sum+candidates[i]<=target；
第三，for循环调用回溯函数时，由于要求元素不能重复使用，因此start=i+1；
第四，去重，使用一个bool数组used标识元素是否被使用，该bool数组初始化为false，每遍历一个元素令其为true（同一树枝允许存在相同元素，无需去重），回溯处理时令其为false，标识同一层的相同元素已被使用，需要去重。

    vector<vector<int>> res;    //记录组合集
    vector<int> path;           //记录某个组合
    void backtracking(vector<int>& candidates,int target,int sum,int start,vector<bool>& used)
    {
        if(sum==target)
        {//终止条件：
            res.push_back(path);
            return;
        }
        for(int i=start;i<candidates.size() && sum+candidates[i]<=target;++i)
        {
            //去重：对同一层相同元素进行去重，used[i-1]==false说明是在同一层
            if(i>0 && candidates[i]==candidates[i-1] && used[i-1]==false)
                continue;
            path.push_back(candidates[i]);  //处理节点，保存
            sum+=candidates[i];     //计算path元素之和                
            used[i]=true;           //当前层使用过的元素记为true，若递归到下一层，i-1仍为true
            backtracking(candidates,target,sum,i+1,used);   //i+1说明不能重复使用元素
            used[i]=false;          //回溯后记为false，即当前层的i-1为false说明已使用过该元素
            sum-=candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        //初始化所有元素都为false，同一层使用了则为true
        vector<bool> used(candidates.size(),false);      
        backtracking(candidates,target,0,0,used);
        return res;
    }

三、131 分割回文串

题目链接：131 分割回文串

核心：
第一，切割问题，类似组合，以下标start进行切割，从start=0开始，终止条件是start>=字符串长度，表示已经切割完字符串的最后一个元素；
第二，由于切割问题是不允许使用重复元素的，即某元素被切割后就不能再被切割了，因此在for循环调用回溯函数时start=i+1；
第三，判断是否回文串，应使用双指针方法，且额外定义一个函数，只有在子串[start,i]为回文串时，才记录该子串到path；否则continue，继续下一次遍历。

    vector<vector<string>> res;     //记录组合集
    vector<string> path;            //记录某个组合
    void backtracking(string s,int start)
    {
        if(start>=s.size())
        {//终止条件
            res.push_back(path);
            return;
        }
        for(int i=start;i<s.size();++i)
        {
            if(isPalindrome(s,start,i))
            {//在s的子串start-i是回文串时push到path
                string str=s.substr(start,i-start+1);   //截取子串start-i
                path.push_back(str);    //处理节点
            }
            else
                continue;       //不是回文子串则无需记录，继续搜索
            backtracking(s,i+1);    //当前元素切割后就不能再重复切割，递归搜索时设置i+1
            path.pop_back();    //回溯，撤销处理
        }
    }
    bool isPalindrome(const string& s,int left,int right)
    {//判断字符串s从left到right（s[left-right]）是否为回文子串
        for(int i=left,j=right;i<j;++i,--j)
        {//双指针，从left和right开始往中间移动，逐个比较，只要存在不等则不是回文串
            if(s[i]!=s[j])
                return false;
        }
        return true;
    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return res;
    }