代码随想录Day27——39. 组合总和 40.组合总和II 131.分割回文串

39. 组合总和

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

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

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

• 数据可以重复选取即backtrack的第三个参数不需要每次迭代都+1，可以一直选这个元素，直至sum超过target结束该次组合。

40.组合总和II

给定一个候选人编号的集合 candidates（包含重复元素） 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

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

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

• 我的思路，通过start与i判断两个数重复出现是并列关系还是一个纵向循环，前者需要跳过以去重而后者不需要。

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

• 通过一个新的数组指标判断两个数重复出现是并列关系还是一个纵向循环，前者需要跳过以去重而后者不需要。

131.分割回文串

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

class Solution {
public:
    vector<vector<string>> result;
    vector<string> v;
    string temp,tem;
    void backtracking(string s,int start)
    {
        if(start >= s.size())
        {
            result.push_back(v);
            return;
        }
        for(int i = start;i<s.size();i++)
        {
            temp = s.substr(start, i - start +1);
            tem = temp;
            reverse(tem.begin(),tem.end());
            if(temp.compare(tem)) continue;
            v.push_back(temp);
            backtracking(s,i+1);
            v.pop_back();
        }
        return;
    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }
};

• 选择在哪切割其实就是选择哪个字符，所以和组合问题类似，详细思路看代码随想录。