Leetcode brushing notes (C++) - backtracking method
Sort out the ideas in the process of brushing the questions, and summarize and share them here.
github address: https://github.com/lvjian0706/Leetcode-solutions
The github project is just newly created, and the organized code and ideas will be uploaded one after another. The code is based on C++ and python. At the same time, the basic sorting algorithm will also be sorted and uploaded.
39. Combined sum
Given an array candidates without repeated elements and a target number target, find out all combinations in candidates that can make the sum of numbers into target.
The numbers in candidates can be selected repeatedly without limit.
Explanation:
All numbers (including target) are positive integers.
A solution set cannot contain duplicate combinations.
Example 1:
Input: candidates = [2,3,6,7], target = 7,
the solution set is:
[
[7],
[2,2,3]
]
Example 2:
Input: candidates = [2,3 ,5], target = 8,
the solution set is:
[
[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. Full Arrangement
Given a sequence with no repeating numbers, return all possible full permutations of it.
Example:
Input: [1,2,3]
Output:
[
[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. Subset
Given a set of integer array nums with no repeated elements, return all possible subsets (power sets) of that array.
Explanation: The solution set cannot contain duplicate subsets.
Example:
Input: nums = [1,2,3]
Output:
[
[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. Subset II
Given an integer array nums that may contain duplicate elements, return all possible subsets (power sets) of that array.
Explanation: The solution set cannot contain duplicate subsets.
Example:
Input: [1,2,2]
Output:
[
[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;
}
};