代码随想录算法训练营第27天 | 39.组合总和 17. 电话号码的字母组合

39.组合总和

https://leetcode.cn/problems/combination-sum/description/

        组合总和的这道题的关键在于题目说到元素可以重复利用，所以递归用到的startIndex是i，而不是像前面几道题一样的i+1,剪枝的关键在于排序，由小到大排，那么只要加上一个后总的和大于target那么就可以return掉了。

class Solution {
private:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>candidates,int target,int sum,int startIndex)
    {   if(sum>target) return;
        if(sum==target)
        {
            result.push_back(path);
        }
        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();
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return result;
    }
};

40.组合总和II

        这道题的关键在于题目中提到元素是重复的，即可能有多个1，多个2......但是组合又不能重复，所以去重操作关键在于去重重复元素

if(i>startIndex&&candidates[i]==candidates[i-1])

            {continue;}

这一步就是去重，如图，第二层有两个1，那么假如我们在第二层加入到组合的时候，第二个1也加入组合，那么其实和第一个1加入组合后所产生的各个组合（也就是各个树枝）会发生重复，所以我们需要进行去重，i>startIndex就是确保加入的元素是还没有加入到过组合的元素，这里主要是考虑树枝上的去重，如第三层的组合选择1,1，这里的candidates[2]==candidates[1]，如果没有i>startIndex的限制，那么这个组合就会被剔除掉，为了避免这种情况的发生，我们限制i>startIndex，即每一层只能选取有重复元素的第一个，这里设置得挺妙的（需再体会）。

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

131.分割回文串

        这道题好难啊啊啊啊啊啊啊啊啊啊啊要发癫了我，先简单地总结一波吧。

        首先，需要用到之前的判断回文串的函数，用两个指针分别从首尾移动即可。

        接着，就是解决这道题的关键，分割回文串，其实就是相当于拿一个挡板挡住，看看挡板中间的部分是不是回文部分，注意，挡板的头即是上一次分割部分的尾。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经添加的子串
        }
    }
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};