算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习二（leetcode真题剖析）

01.括号生成

题目链接：https://leetcode.cn/problems/generate-parentheses/

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
1
2

示例 2：

输入：n = 1
输出：["()"]
1
2

提示：

• 1 <= n <= 8

思路

通过从左到右进行递归，可以在每个位置判断放置左右括号的可能性。具体实现中，可以使用以下方法判断括号的合法性：

1. 在放置左括号时，需要判断此时左括号的数量是否小于字符串总长度的一半（如果左括号的数量大于等于字符串长度的一半，继续放置左括号，则左括号的总数量一定大于右括号的总数量）。
2. 在放置右括号时，需要判断此时右括号的数量是否小于左括号的数量。

这样的判断方式确保了在递归的过程中，左括号数量始终大于等于右括号数量，并且左括号的总数量与右括号的总数量相等，保证生成的括号序列是合法的。

代码

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--;
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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],
]
1
2
3
4
5
6
7
8
9
10

示例 2：

输入：n = 1, k = 1
输出：[[1]]
1
2

提示：

• 1 <= n <= 20
• 1 <= k <= n

思路

这道题目要求从1到n中选择k个数的所有组合，其中不考虑顺序，即[1,2]和[2,1]等价。为了找出所有组合，但又避免重复计算相同元素的不同顺序的组合，我们可以按照以下流程进行：

1. 将所有元素分别作为首位元素进行处理。
2. 在之后的位置上同理，选择所有元素分别作为当前位置元素进行处理。
3. 为避免计算重复组合，规定选择之后位置的元素时必须比前一个元素大，这样就不会有重复的组合（例如，[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();
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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
1
2
3
4
5
6
7
8

示例 2：

输入：nums = [1], target = 1
输出：1
1
2

思路

对于每个数，可以选择加上或减去它，逐个枚举每一个数字。在每个数都被选择时，检查得到的和是否等于目标值。如果相等，则记录结果。为了提高时间复杂度，可以事先计算数组中所有数字的和 以及数组的长度。这样可以迅速判断当前和减去剩余的所有数是否已经超过目标值 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]);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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 。
仅有这两种组合。
1
2
3
4
5
6

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
1
2

示例 3：

输入: candidates = [2], target = 1
输出: []
1
2

思路
对于 candidates 数组中的所有元素互不相同，因此在递归状态时，只需要对每个元素进行如下判断：

1. 跳过当前元素，对下一个元素进行判断；
2. 将当前元素添加到当前状态中，选择添加当前元素时，之后仍可以继续选择当前元素（可以重复选择同一元素）。

因此，在选择当前元素并向下传递下标时，应该直接传递当前元素的下标。这样可以确保在递归过程中，每个元素只考虑一次，避免重复计算。

代码

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();
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25