数据结构与算法 leetcode刷题013 递归和回溯的使用

今天的刷题内容是递归和回溯的应用，递归问题除了在树中的使用外，还有比较常用的使用方式是递归和回溯的使用；

废话不多说直接开始刷题，在刷题中体会相应的算法的使用；

leetcode17：手机键盘的组合问题

class Solution {//C++中没有public和private关键字都是私有变量
private:
    vector<string> digitstring={""," ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    //p中保存的是到index为止的的字符串，digits是原始输入的数字字符串，index表示digits中的index
    void generateString(string digits,int index,string p,vector<string>& result){
        if(index==digits.size()){
            result.push_back(p);
            return;
        }
        string temp=digitstring[digits[index]-'0'];
        for(int i=0;i<temp.size();i++){
            p.push_back(temp[i]);
            generateString(digits,index+1,p,result);//这里循环退出的条件是return出来;
            p.pop_back();//回溯的过程 进入下一次的过程
        }
        
}
public:
    vector<string> letterCombinations(string digits) {
        //采用树形结合的方式来进行解题;如何设置一个递归的函数是关键
        vector<string> ans;
        int size=digits.size();
        if(size==0){
            return ans;
        }
        //定义一个生成字符串的元素
        string p="";
        generateString(digits,0,p,ans);
        return ans;
    }
};

类似的题型还有leetcode48: 求一个数组的全排列；

class Solution {
public:
    vector<bool> used;
    //index 表示p中的保存的元素的个数
    void generator(vector<int>& nums,int index,vector<int>& p,vector<vector<int>>& ans ){
        //递归停止的条件是p中含有了和nums中一样的数据的个数
        if(index==nums.size()){
            ans.push_back(p);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(!used[i]){
                used[i]=true;
                p.push_back(nums[i]);
                generator(nums,index+1,p,ans);
                p.pop_back();
                used[i]=false;
            }
        }
        
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        if(nums.size()==0){
            return ans;
        }
        used=vector<bool>(false,nums.size());
        vector<int> p;
        generator(nums,0,p,ans);
        return ans;
    }
};

还有类似的leetcode77：求解从n个数中提取出k个数的组合方式；

实现的方式也是递归加回溯的方式：

class Solution {
public:
    void generate(int n,int index,int k,vector<int>&temp, vector<vector<int>>& ans){
        if(temp.size()==k){//k表示temp数组中有多少个元素
            ans.push_back(temp);
            return;
        }
        for(int i=index;i<=n;i++){
            temp.push_back(i);
            generate(n,i+1,k,temp,ans);
            temp.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        //使用回溯和递归的算法来实现
        vector<vector<int>> ans;
        if(n<k){
            return ans;
        }
        vector<int> temp;
        generate(n,1,k,temp,ans);
        return ans;
    }
};

leetcode39: 求解路径和；数组中的元素可以重复使用

class Solution {
public:
    void generate(vector<int>& candidates,int target,int index,int sum,vector<int>& temp,vector<vector<int>>& ans){
        //参数中用sum来保存相应的数组的和 index表示开始
        if(sum==target){
            ans.push_back(temp);
            return;
        }
        if(sum>target){
            return;
        }
        for(int i=index;i<candidates.size();i++){
            temp.push_back(candidates[i]);
            generate(candidates,target,i,sum+candidates[i],temp,ans);
            temp.pop_back();//这里的pop表示的是回溯到循环开始的时候，否则temp中包含前一个数;
        }
       
        
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        //求解相应的和 数字可以重复出现 还是使用递归和回溯的思想来进行相应的解题
        vector<vector<int>> ans;
        if(candidates.size()==0){
            return ans;
        }
        //否则生成相应的递归函数解析式
        vector<int> p;
        //前提是有序
        generate(candidates,target,0,0,p,ans);//传递的参数有相应的数组,
        return ans;
        
    }
    // int SUM(vector<int> nums){
    //     int SUM=0;
    //     for(int i=0;i<nums.size();i++){
    //         SUM+=nums[i];
    //     }
    //     return SUM;
    // }
};

leetcode40:类似于leetcode39，但是不知对于重复的数，没有去除掉，这是个问题，留下以后再修改；

leetcode78:求解一个数组的子集，还是通过深度优先遍历，递归和回溯的问题，只不过每次前进的值都要保存到ans中

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        //还是使用递归和回溯算法 也是基于深度优先的回溯算法;
        vector<vector<int>> ans;
        vector<int> path;//还是使用路径的方式比较靠谱
        ans.push_back(path);
        generate(nums,0,path,ans);
        return ans;
    }
    void generate(vector<int>& nums,int index,vector<int>& path,vector<vector<int>>& ans){
        if(index==nums.size()){
            return;
        }
        for(int i=index;i<nums.size();i++){
            path.push_back(nums[i]);
            ans.push_back(path);
            generate(nums,i+1,path,ans);
            path.pop_back();
        }
    }
};