day25|● 216.组合总和III● 17.电话号码的字母组合● 39. 组合总和● 40.组合总和II● 131.分割回文串

 216.组合总和III 

常规题

第一个特判处理不合理情况

第二个特判处理加入答案

仅使用1-9数字

class Solution {
public:
    vector<vector<int>> results;
    vector<int> cur;
    void traverse(int k,int n,int start){
        if(n<0||cur.size()>k) return;
        if(n==0){
            if(cur.size() == k) results.push_back(cur);
            return;
        }
       for(int i = start;i<=9;i++){
        cur.push_back(i);
        traverse(k,n-i,i+1);
        cur.pop_back();
       }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        if(n<=0) return results;
        traverse(k,n,1);
        return results;
    }
};

题目链接/文章讲解：代码随想录

视频讲解：和组合问题有啥区别？回溯算法如何剪枝？| LeetCode：216.组合总和III_哔哩哔哩_bilibili

 17.电话号码的字母组合 

每一层代表一些option，这道题每一层的option不一样，一个小小的变形，但无太大差别。

class Solution {
public:
    vector<string> results;
    string s = "";
    void traverse(vector<vector<string>> options,int level,int current){
        if(current > level) return;
        if(current == level){
            for(int i = 0;i<options[current-1].size();i++){
                s += options[current-1][i];
                results.push_back(s);
                s.pop_back();
            }
        }
        else{
            for(int i = 0;i<options[current-1].size();i++){
                s += options[current-1][i];
                traverse(options,level, current+1);
                s.pop_back();
            }
    }
    }
    vector<string> letterCombinations(string digits) {
        
        vector<vector<string>> chars;
        chars.push_back({"a","b","c"});
        chars.push_back({"d","e","f"});
        chars.push_back({"g","h","i"});
        chars.push_back({"j","k","l"});
        chars.push_back({"m","n","o"});
        chars.push_back({"p","q","r","s"});
        chars.push_back({"t","u","v"});
        chars.push_back({"w","x","y","z"});
        if(digits.size() == 0) return results;
        vector<vector<string>> options;
        int dgt = stoi(digits);
        int remainder;
        while(dgt!=0){
            remainder = dgt%10;
            options.push_back(chars[remainder-2]);
            dgt = dgt/10;
        }
        reverse(options.begin(),options.end());
        traverse(options,options.size(),1);
        return results;
    }
};

 39. 组合总和 

本题是 集合里元素可以用无数次，那么和组合问题的差别 其实仅在于 startIndex上的控制

（说的对啊我第一次就写错了）

class Solution {
public:
    vector<vector<int>> results;
    vector<int> cur;
    vector<bool> used;
    void backtrack(vector<int>& candidates, vector<int> cur,int target,int index){
        if(index >= candidates.size()) return;
        if(target <0) return;
        if(target == 0){
            results.push_back(cur);
        }
        for(int i=index;i<candidates.size();i++){
            if(i>=1 && !used[i-1] && candidates[i-1]==candidates[i]) continue;
            cur.push_back(candidates[i]);
            used[i] = true;
            backtrack(candidates,cur,target-candidates[i],i);
            cur.pop_back();
            used[i] = false;
        }
        

    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if(candidates.size()==0) return {};
        sort(candidates.begin(),candidates.end());
        used = vector(candidates.size(),false);
        backtrack(candidates,cur,target,0);
        return results;
    }
};

题目链接/文章讲解：代码随想录

视频讲解：带你学透回溯算法-组合总和（对应「leetcode」力扣题目：39.组合总和）| 回溯法精讲！_哔哩哔哩_bilibili

 40.组合总和II 

本题开始涉及到一个问题了：去重。

注意题目中给我们 集合是有重复元素的，那么求出来的 组合有可能重复，但题目要求不能有重复组合。 

不合法情况：target < 0, 访问越界，

添加情况：target = 0

used要用上啊

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

题目链接/文章讲解：代码随想录

视频讲解：回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II_哔哩哔哩_bilibili

 131.分割回文串  

本题较难，大家先看视频来理解 分割问题，明天还会有一道分割问题，先打打基础。 

substr分割字符串，

判断回文

class Solution {
public:
    vector<vector<string>> results;
    vector<string> cur;
    bool isPalindrome(string s){
        int start = 0, end = s.size()-1;
        while(start<=end){
            if(s[start]!=s[end]) return false;
            start++;
            end--;
        }
        return true;
    }
    void traverse(string s){
        if(s.size() == 0){
            results.push_back(cur);
            return;
        }
        int len = s.size();
        for(int i = 0;i<len;i++){
            string subs = s.substr(0,i+1);
            if(isPalindrome(subs)){
                cur.push_back(subs);
                traverse(s.substr(i+1,len-i-1));
                cur.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        traverse(s);
        return results;
    }
};

代码随想录

视频讲解：

带你学透回溯算法-分割回文串（对应力扣题目：131.分割回文串）| 回溯法精讲！_哔哩哔哩_bilibili