【代码随想录day23】【C++复健】39. 组合总和；40.组合总和II； 131.分割回文串

39. 组合总和

本题一开始做的时候没想明白要不要先进行一下排序，没排序的代码试着提交了一下就直接过了。仔细想了一下首先这道题的元素可以无限取，其次每个元素只会出现一次，也就是说不会出现重复。而排序的目的实际是为了去重，所以本题不需要进行排序。

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> result;
        vector<int> path;
        int startindex = 0;
        comb(result, path, candidates, target, startindex);
        return result;
    }
    void comb(vector<vector<int>>& result, vector<int>& path, vector<int>& candidates, int target, int startindex){
        if(target == 0){
            if(!path.empty()){
                result.push_back(path);
            }
            return ;
        }
        else if(target < 0){
            return ;
        }
        for(int i = startindex; i < candidates.size(); i++){
            path.push_back(candidates[i]);
            comb(result, path, candidates, target - candidates[i], i);
            path.pop_back();
        }
    }
};

40.组合总和II

本题来说还是遇到了较多的问题的，一一列举记录一下：
1 c++的sort方法不会用，写成了sort(candidates);，但实际上正确的写法是sort(candidates.begin(), candidates.end());，也就是说要传两个迭代器而不是整个vector。

2 在写循环逻辑的时候写成了：

while(candidates[i] == candidates[startindex]){
    i++;
}

但实际正确的逻辑是：

if (i > startindex && candidates[i] == candidates[i - 1]) continue;

为什么第一种是对的，第二种就是错的呢？

第一种实际上存在两个问题：
1 我用while循环找到第一个不同的元素，但其实外面还嵌套了一层for循环，在下一个循环的时候还会++，导致跳过一个不同的元素。

2 不应该与candidates[startindex]而应该是与candidates[i]进行比较，这是因为：startindex只是这个for循环的起始节点，但是在后续的for循环当中，也需要进行去重操作，如果与startindex进行比较的话，相当于只与开头的元素进行比较，在逻辑上是错的。

所以最终补全了逻辑的for循环其实得这么写：

        for(int i=startindex; i<candidates.size();){
            // if (i > startindex && candidates[i] == candidates[i - 1]) continue;
            path.push_back(candidates[i]);
            comb(candidates, target - candidates[i], i+1, result, path);
            path.pop_back();
            int p = 0;
            int current = candidates[i];
            while(i+p <candidates.size() && candidates[i+p] == current){
                p++;
            }
            if(p > 0){
                i += p;
            }
            else{
                i += 1;
            }
        }

在这个逻辑当中，相当于去掉了有重复元素的时候的自动++操作，并且也正确的将比较对象调成了candidates[i]。

相比之下其实卡哥的代码就简单很多了，首先是只和前一个元素进行比较，不用纠结到底是startindex还是i，其次是每次只会在满足条件时跳过当前循环，不会像我一样算半天需要跳过几个循环，然后跳错，是负担较低且好写的写法。至于我为什么没想到，是因为这种去重逻辑其实正着想还挺难的（个人认为），看到代码之后倒推反而是好理解的。

卡哥解析里面那个同一树层什么的给我看挺懵逼的，从代码倒退回去讲的话，其实就是相同的数字第二次出现，其实就已经重复了，因为它的上一个元素不取它这一个其实就和从它这里开始，得到的结果是一样的。那所以此时需要判断两件事：

1 现在的这个元素并非起始元素，也就是i>startindex

2 此时的元素是第二次及以上出现，也就是和前一个元素相等了

满足上述的两个条件之后，执行跳过逻辑，最终写出来的代码如下。

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        int startindex = 0;
        vector<vector<int>> result;
        vector<int> path;
        comb(candidates, target, startindex, result, path);
        return result;
    }
    void comb(vector<int>& candidates, int target, int startindex, vector<vector<int>>& result, vector<int>& path){
        if(target == 0){
            if(!path.empty()){
                result.push_back(path);
            }
            return ;
        }
        else if(target < 0){
            return ;
        }
        for(int i=startindex; i<candidates.size();){
            if (i > startindex && candidates[i] == candidates[i - 1]) continue;
            path.push_back(candidates[i]);
            comb(candidates, target - candidates[i], i+1, result, path);
            path.pop_back();
            int p = 0;
            int current = candidates[i];
        }
    }
};

131.分割回文串

回溯的部分其实我一周目并没做过，这题也并没有思路。看了卡哥的解析才知道得划为两个部分：

1 找切割点

2 判断回文

我就属于想要用一段代码把两件事都做了，其实这个是不太现实的，饭要一口一口的吃。

那看完解析之后自己去实现，相对来说就简单很多了，不过也遇到了一些问题：
1 substr又忘了怎么用了，这回倒是记得传下标了，但又忘记第二个参数要传长度了，传了俩下标进去，自然是错的。

2 边界条件写成startindex >= s.size()了，这样其实是会导致越界问题的。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> result;
        vector<string> path;
        int startindex = 0;
        part(s, startindex, result, path);
        return result;
    }
    void part(string s, int startindex, vector<vector<string>>& result, vector<string>& path){
        if(startindex >= s.size()){
            if(!path.empty()){
                result.push_back(path);
            }
            return;
        }
        for(int i=startindex; i<s.size();i++){
            if(judge(s, startindex, i)){
                path.push_back(s.substr(startindex, i - startindex + 1));
                part(s, i+1, result, path);
                path.pop_back();
            }
            else{
                continue;
            }
        }
    }
    bool judge(string s, int left, int right){
        for(int i=left, j = right; i <= j;i++,j--){
            if(s[i] != s[j]){
                return false;
            }
        }
        return true;
    }
};