今天的刷题内容是递归和回溯的应用，递归问题除了在树中的使用外，还有比较常用的使用方式是递归和回溯的使用；
废话不多说直接开始刷题，在刷题中体会相应的算法的使用；
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();
}
}
};