代码随想录 回溯章节1

1.组合

https://leetcode.cn/problems/combinations/

class Solution {
public:
    //组合问题：需要用回溯算法

    vector<int> path;   //单条路径
    vector<vector<int>> result;     //存放所有组合
    
    void backtracking(int n,int k,int startindex){
        //1.终止条件
        if(path.size() == k){
            result.push_back(path);
            return ;
        }

        //2.处理逻辑
        for(int i = startindex;i <= n-(k-path.size())+1;i++){
            path.push_back(i);
            backtracking(n,k,i+1);
            path.pop_back();
        }

        return;

    }

    
    vector<vector<int>> combine(int n, int k) {
        backtracking(n,k,1);
        return result;
    }
};

2.组合总和iii

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

class Solution {
public:
    
    vector<vector<int>> result; //结果数组
    vector<int> path;   //单条路径
    int sum = 0;    //k个数之和
    void backtracking(int k,int n,int startindex){
        //终止条件
        if(path.size() == k){
            if(sum == n) result.push_back(path);
            return;
        }

        //单层逻辑
        //剪枝操作 已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。
        for(int i = startindex;i <= 9;i++){
            
            path.push_back(i);
            sum += i;   //这一步也可以用减法，然后终止条件哪里判断是否为0
            
            //剪枝：判断当前sum是否已经>n
            if(sum > n){
                path.pop_back();
                sum -= i;  
                return;
            }
            //递归
            backtracking(k,n,i+1);
            //回溯
            path.pop_back();
            sum -= i;

        }
        return ;

    }
    
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return result;
    }
};

3.电话号的字母组合

https://leetcode.cn/problems/letter-combinations-of-a-phone-number/submissions/

class Solution {
public:
  
    const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
    vector<string> result;
    string path;

    void bachtracking(string &digits,int index){
        //终止条件
        if(path.size() == digits.size()){
            result.push_back(path);
            return;
        }

        //单层逻辑
        //下一层的数字编号 并将其的字母取出
        int num1 = digits[index] - '0'; 
        
        for(int j=0;j<letterMap[num1].size();j++){
            path.push_back(letterMap[num1][j]);
            bachtracking(digits,index+1);
            path.pop_back();
            
        }   
        return;

    }
    
    
    vector<string> letterCombinations(string digits) {
        result.clear();
        path.clear();
        if(digits.size()==0){
            return result;
        }

        bachtracking(digits,0);
        return result;

    }
};

4.组合总和

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

class Solution {
public:
    vector<vector<int>> result; //存储各路径
    vector<int> path;   //存储路径

    void backstacking(vector<int>& candidates,int target,int index){
        //终止条件
            //剪枝
        if(target < 0){ 
            return ;
        }
            //终止
        if(target == 0){
            result.push_back(path);
            return ;
        }

        //单层逻辑
        for(int i=index;i<candidates.size();i++){
            target -= candidates[i];
            path.push_back(candidates[i]);
            backstacking(candidates,target,i);  //表示i也可取到
            path.pop_back();
            target += candidates[i];
        }

        return ;
    }
    
    
    
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if(candidates.size() == 0){
            return result;
        }

        backstacking(candidates,target,0);
        return result;
    }
};

5.组合总和ii

https://leetcode.cn/problems/combination-sum-ii/submissions/

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backstacking(vector<int>& candidates, int target,int startindex){
        //终止条件
            //剪枝
        if(target < 0){
            return;
        }
            //终止
        if(target == 0){
            result.push_back(path);
            return ;
        }
        //元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同——要去重
            //首先对给定的数组排序，让其相同的元素挨在一起，然后去重(这一步在主函数中进行)
            //去重条件 同一层间去重
        for(int i = startindex;i<candidates.size();i++){
            //同一层间去重
            if(i > startindex && candidates[i] == candidates[i-1]){
                continue;
            }//若i-1、i节点的值相同，在一个循环中，两者的根节点相同，而i的孩子节点被i-1的孩子节点包含，因此会重复，需要去重
            
            //目标值操作
            target -= candidates[i];
            path.push_back(candidates[i]);
            //递归
            backstacking(candidates,target,i+1);
            //回溯
            target += candidates[i];
            path.pop_back();
        }

        return ;

    }
    
    
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if(candidates.size() == 0){
            return result;
        }
        //对给定的数组排序，相同的元素挨在一起，方便去重
        sort(candidates.begin(),candidates.end());

        backstacking(candidates,target,0);
        return result;

    }
};

6.分割回文子串

https://leetcode.cn/problems/palindrome-partitioning/submissions/

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;
    string str;
    void backstacking(string s,int startIndex){
        //判断是否为回文串
        if(startIndex >= s.size()){//切割线startindex
            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;
            }

            backstacking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back();        // 回溯过程，弹出本次已经填在的子串
        }

        return ;
    }

    
    vector<vector<string>> partition(string s) {
       
        result.clear();
        path.clear();
        if(s.size() == 0){
            return result;
        }

        backstacking(s,0); 
        return result;
    }
};