Leetcode刷题笔记(C++)——回溯法
整理一下刷题过程中的思路,在这里进行一下总结与分享。
github地址:https://github.com/lvjian0706/Leetcode-solutions
github项目是刚刚新建的,陆续会将整理的代码以及思路上传上去,代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。
39. 组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明:
所有数字(包括 target)都是正整数。
解集不能包含重复的组合。
示例 1:
输入:candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]
示例 2:
输入:candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]
class Solution {
public:
/*
1. 当当前组合的和大于target时,直接return,等于target时,将组合push到最终答案中;
2. 为了避免重复组合的情况,定义变量i用于记录当前遍历到了哪个元素,之前的元素不再重复遍历;
3. 从第i个元素开始遍历,套用回溯算法模板,将当前元素push到组合中,sum加上当前元素,继续递归;
4. 在组合中删除当前元素,sum减去当前元素后遍历i+1个元素;
*/
void backtrack(vector<int>& candidates, int target, int i, int& sum, vector<vector<int>>& ans, vector<int>& sub_ans){
if(sum>target) return;
if(sum==target){
ans.push_back(sub_ans);
return;
}
for(int j=i; j<candidates.size(); j++){
sub_ans.push_back(candidates[j]);
sum += candidates[j];
backtrack(candidates, target, j, sum, ans, sub_ans);
sub_ans.pop_back();
sum -= candidates[j];
}
}
/*
统计所有可能的排列情况:回溯算法
1. 新建一维数组存储每个组合,新建二维数组存储最终结果;
2. 找出 candidates 中所有可以使数字和为 target 的组合,所以定义sum变量用于存储当前组合的和;
3. 递归遍历数组,不断计算符合条件的组合并push到答案中;
*/
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
vector<vector<int>> ans;
vector<int> sub_ans;
int sum = 0;
backtrack(candidates, target, 0, sum, ans, sub_ans);
return ans;
}
};
46. 全排列
给定一个 没有重复 数字的序列,返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
class Solution {
public:
/*
回溯思想:
1. 当sub_ans中元素个数为nums中的元素个数时,保存;
2. 循环遍历当前层,将遍历到的元素push进子集中;
3. 将遍历到的元素添加到set中;
4. 递归遍历更深层;
5. 将该数在set中删除;
6. 将该数去掉后继续遍历当前层;
*/
void backtrack(vector<int>& nums, vector<int>& sub_ans, vector<vector<int>>& ans, set<int>& Set){
if(sub_ans.size() == nums.size()){
ans.push_back(sub_ans);
return;
}
for(int i=0; i<nums.size(); i++){
if(Set.find(nums[i])==Set.end()){
sub_ans.push_back(nums[i]);
Set.insert(nums[i]);
backtrack(nums, sub_ans, ans, Set);
Set.erase(nums[i]);
sub_ans.pop_back();
}
}
}
/*
所有可能的全排列:使用回溯算法,类似树的遍历
要返回所有全排列,因此应该建立一个二位数组存放答案,其中每个1维数组是各个全排列;
其中,为了避免全排列中包含相同元素,定义set用来记录已经遍历的元素;
1. 递归遍历数组,不断计算新全排列并push到答案中;
*/
vector<vector<int>> permute(vector<int>& nums) {
vector<int> sub_ans;
vector<vector<int>> ans;
set<int> Set;
backtrack(nums, sub_ans, ans, Set);
return ans;
}
};
78. 子集
给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。
说明:解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
class Solution {
public:
/*
回溯思想:
1. 结束条件是遍历到了数组末尾;
2. 每遍历到一个数,push进子集,并将子集push到答案中;
3. 继续递归遍历;
4. 将该数去掉后继续遍历;
*/
void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
if(i>nums.size()-1) return;
sub_ans.push_back(nums[i]);
ans.push_back(sub_ans);
backtrack(nums, i+1, sub_ans, ans);
sub_ans.pop_back();
backtrack(nums, i+1, sub_ans, ans);
}
/*
穷尽所有可能:使用回溯算法,类似树的遍历
要返回所有子集,因此应该建立一个二位数组存放答案,其中每个1维数组是各个子集;
1. 先保存空子集;
2. 递归遍历数组,不断计算新子集并push到答案中;
*/
vector<vector<int>> subsets(vector<int>& nums) {
vector<vector<int>> ans;
vector<int> sub_ans;
ans.push_back(sub_ans);
backtrack(nums, 0, sub_ans, ans);
return ans;
}
};
方法2:
class Solution {
public:
/*
回溯思想:
1. 保存子集;
2. 结束条件是遍历到了数组末尾;
3. 循环遍历当前层,将遍历到的元素push进子集中;
4. 递归遍历更深层;
5. 将该数去掉后继续遍历当前层;
*/
void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
ans.push_back(sub_ans);
if(i==nums.size()) return;
for(int j=i; j<nums.size(); j++){
sub_ans.push_back(nums[j]);
backtrack(nums, j+1, sub_ans, ans);
sub_ans.pop_back();
}
}
/*
穷尽所有可能:使用回溯算法,类似树的遍历
要返回所有子集,因此应该建立一个二位数组存放答案,其中每个1维数组是各个子集;
1. 递归遍历数组,不断计算新子集并push到答案中;
*/
vector<vector<int>> subsets(vector<int>& nums) {
vector<int> sub_ans;
vector<vector<int>> ans;
backtrack(nums, 0, sub_ans, ans);
return ans;
}
};
90. 子集 II
给定一个可能包含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。
说明:解集不能包含重复的子集。
示例:
输入: [1,2,2]
输出:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]
class Solution {
public:
/*
回溯思想:
1. 结束条件是遍历到了数组末尾;
2. 每遍历到一个数,push进子集,
3. 判断Set中是否存在该子集,如果不存在将子集push到答案中,并将子集insert到Set中;
4. 继续递归遍历;
5. 将该数去掉后继续遍历;
*/
void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans, set<vector<int>>& Set){
if(i>nums.size()-1) return;
sub_ans.push_back(nums[i]);
if(Set.find(sub_ans)==Set.end()){
ans.push_back(sub_ans);
Set.insert(sub_ans);
}
backtrack(nums, i+1, sub_ans, ans, Set);
sub_ans.pop_back();
backtrack(nums, i+1, sub_ans, ans, Set);
}
/*
穷尽所有可能:使用回溯算法,类似树的遍历,其中,需要注意数组有重复元素,但是答案不能包含重复子集
要返回所有子集,因此应该建立一个二位数组存放答案,其中每个1维数组是各个子集;
对于不能包含重复子集的情况,使用Set存储子集,用于判断是否重复
1. 先保存空子集;
2. 递归遍历数组,不断计算新子集并push到答案中,其中使用Set存储子集,用于判断是否重复;
*/
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<int> sub_ans;
vector<vector<int>> ans;
ans.push_back(sub_ans);
set<vector<int>> Set;
backtrack(nums, 0, sub_ans, ans, Set);
return ans;
}
};
方法2:
class Solution {
public:
/*
回溯思想:
1. 保存子集;
2. 结束条件是遍历到了数组末尾;
3. 循环遍历当前层,当元素不为重复元素时,将遍历到的元素push进子集中;
4. 递归遍历更深层;
5. 将该数去掉后继续遍历当前层;
*/
void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
ans.push_back(sub_ans);
if(i==nums.size()) return;
for(int j=i; j<nums.size(); j++){
if(j>i && nums[j]==nums[j-1]) continue;
sub_ans.push_back(nums[j]);
backtrack(nums, j+1, sub_ans, ans);
sub_ans.pop_back();
}
}
/*
穷尽所有可能:使用回溯算法,类似树的遍历
要返回所有子集,因此应该建立一个二位数组存放答案,其中每个1维数组是各个子集;
1. 递归遍历数组,不断计算新子集并push到答案中;
*/
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<int> sub_ans;
vector<vector<int>> ans;
backtrack(nums, 0, sub_ans, ans);
return ans;
}
};