算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习二
- 01.括号生成
- 02.组合
- 03.目标和
- 04.组合总和
01.括号生成
题目链接：https://leetcode.cn/problems/generate-parentheses/
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
1 <= n <= 8
思路
通过从左到右进行递归，可以在每个位置判断放置左右括号的可能性。具体实现中，可以使用以下方法判断括号的合法性：
- 在放置左括号时，需要判断此时左括号的数量是否小于字符串总长度的一半（如果左括号的数量大于等于字符串长度的一半，继续放置左括号，则左括号的总数量一定大于右括号的总数量）。
- 在放置右括号时，需要判断此时右括号的数量是否小于左括号的数量。
这样的判断方式确保了在递归的过程中，左括号数量始终大于等于右括号数量，并且左括号的总数量与右括号的总数量相等，保证生成的括号序列是合法的。
代码
class Solution {
int left=0,right=0,n;
string path;
vector<string> ret;
public:
vector<string> generateParenthesis(int _n) {
n=_n;
dfs();
return ret;
}
void dfs(){
if(right==n){
ret.push_back(path);
return;
}
if(left<n){
path.push_back('('); left++;
dfs();
path.pop_back(); left--;
}
if(right<left){
path.push_back(')'); right++;
dfs();
path.pop_back(); right--;
}
}
};
02.组合
题目链接：https://leetcode.cn/problems/combinations/
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
示例 2：
输入：n = 1, k = 1
输出：[[1]]
提示：
1 <= n <= 201 <= k <= n
思路
这道题目要求从1到n中选择k个数的所有组合，其中不考虑顺序，即[1,2]和[2,1]等价。为了找出所有组合，但又避免重复计算相同元素的不同顺序的组合，我们可以按照以下流程进行：
- 将所有元素分别作为首位元素进行处理。
- 在之后的位置上同理，选择所有元素分别作为当前位置元素进行处理。
- 为避免计算重复组合，规定选择之后位置的元素时必须比前一个元素大，这样就不会有重复的组合（例如，[1,2]和[2,1]中[2,1]不会出现）。
这样的流程能够确保生成所有的组合，并且通过限制选择元素的大小顺序，避免了重复计算。
代码
class Solution {
vector<vector<int>> ret;
vector<int> path;
int n,k;
public:
vector<vector<int>> combine(int _n, int _k) {
n=_n,k=_k;
dfs(1);
return ret;
}
void dfs(int start){
if(path.size()==k){
ret.push_back(path);
return;
}
for(int i=start;i<=n;++i){
path.push_back(i);
dfs(i+1);
path.pop_back();
}
}
};
03.目标和
题目链接：https://leetcode.cn/problems/target-sum/
给你一个非负整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：
- 例如，
nums = [2, 1]，可以在2之前添加'+'，在1之前添加'-'，然后串联起来得到表达式"+2-1"。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
示例 1：
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：
输入：nums = [1], target = 1
输出：1
思路
对于每个数，可以选择加上或减去它，逐个枚举每一个数字。在每个数都被选择时，检查得到的和是否等于目标值。如果相等，则记录结果。为了提高时间复杂度，可以事先计算数组中所有数字的和 以及数组的长度。这样可以迅速判断当前和减去剩余的所有数是否已经超过目标值 target，或者当前和加上剩下的数的和是否小于目标值 target。如果满足条件，就可以直接进行回溯。
代码
class Solution {
int ret=0,target;
public:
int findTargetSumWays(vector<int>& nums, int _target) {
target=_target;
dfs(nums,0,0);
return ret;
}
void dfs(vector<int>& nums,int pos,int path){
if(pos==nums.size()){
if(path==target) ret++;
return;
}
dfs(nums,pos+1,path+nums[pos]);
dfs(nums,pos+1,path-nums[pos]);
}
};
04.组合总和
题目链接：https://leetcode.cn/problems/combination-sum/
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
示例 1：
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
示例 2：
输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
示例 3：
输入: candidates = [2], target = 1
输出: []
思路
对于 candidates 数组中的所有元素互不相同，因此在递归状态时，只需要对每个元素进行如下判断：
- 跳过当前元素，对下一个元素进行判断；
- 将当前元素添加到当前状态中，选择添加当前元素时，之后仍可以继续选择当前元素（可以重复选择同一元素）。
因此，在选择当前元素并向下传递下标时，应该直接传递当前元素的下标。这样可以确保在递归过程中，每个元素只考虑一次，避免重复计算。
代码
class Solution {
vector<vector<int>> ret;
vector<int> path;
int target;
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int _target) {
target=_target;
dfs(candidates,0,0);
return ret;
}
void dfs(vector<int>& candidates,int pos,int sum){
if(sum==target){
ret.push_back(path);
return;
}
else if(sum>target||pos==candidates.size()) return;
for(int i=pos;i<candidates.size();++i){
path.push_back(candidates[i]);
dfs(candidates,i,sum+candidates[i]);
path.pop_back();
}
}
};
