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

第七章回溯算法part03

39. 组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

思路：和之前做的组合问题解题思路一致，不一样的点在于同一个数字可以被无限重复选取。一开始写的代码回溯函数的参数没有设置startIndex，导致会出现重复数组，只是数组中数组顺序不同。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> group;
    void backtracking(vector<int>& candidates,int target,int sum,int startindex){
        if(sum>target){
            return;             //剪枝
        }
        if(sum==target){
            result.push_back(group);
            return;
        }
        for(int i=startindex;i<candidates.size();i++){
            sum+=candidates[i];
            group.push_back(candidates[i]);
            backtracking(candidates,target,sum,i);      //元素可以多次使用所以这里是i
            sum-=candidates[i];
            group.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates,target,0,0);
        return result;
    }
};

40. 组合总和 II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

思路：与上一题不同之处在于candidate中存在重复数字，导致结果中包含重复集合。自己写的时候是将在满足终止条件时加一个条件即将数组path进行排序后判断存储结果的result二维数组中是否有该数组，没有再添加到结果中，但是得出的结果很奇怪，不知道为什么？

题解比较妙，先将所有元素排序，遇到与前一个相同的元素直接在同一层调用中跳过。

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

此时for循环里就应该做continue的操作。

这块比较抽象，如图：

我在图中将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的情况下：

• used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
• used[i - 1] == false，说明同一树层candidates[i - 1]使用过

可能有的录友想，为什么 used[i - 1] == false 就是同一树层呢，因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。

而 used[i - 1] == true，说明是进入下一层递归，去下一个数，所以是树枝上，如图所示：

这块去重的逻辑很抽象，网上搜的题解基本没有能讲清楚的，如果大家之前思考过这个问题或者刷过这道题目，看到这里一定会感觉通透了很多！

那么单层搜索的逻辑代码如下：

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
    // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
    // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
    // 要对同一树层使用过的元素进行跳过
    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); // 和39.组合总和的区别1：这里是i+1，每个数字在每个组合中只能使用一次
    used[i] = false;
    sum -= candidates[i];
    path.pop_back();
}

 也可以不做标注，直接通过回溯是增加开始索引（i+1）即可不重复使用同一元素。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    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();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return result;
    }
};

131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

看了题解才写出来的，对于分割回溯条件和循环过程还是不是很清楚。才发现只要想明白单层循环就可以了，回溯过程就是重复基本的单层循环，只是可能一些开始节点等条件需要做限制。

class Solution {
public:
    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;
    }
    vector<vector<string>> result;
    vector<string> path;
    void backtracking(string s,int startIndex){
        if(startIndex>=s.size()){
            result.push_back(path);
            return;
        }
        //单层循环
        for(int i=startIndex;i<s.size();i++){
            if(isPalindrome(s,startIndex,i)){
                string str=s.substr(startIndex,i-startIndex+1);
                path.push_back(str);
            }
            else{
                continue;
            }
            backtracking(s,i+1);
            path.pop_back();
        }

    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }
};