回溯算法（组合问题）

leetcode39题

---

前言

给你一个 无重复元素 的整数数组 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
输出: []

---

一、回溯算法

回溯算法的基本思路：

1. 探索和选择：

   • 你会尝试选择一个元素，看看它是否能成为解的一部分。
   • 如果选择了某个元素，就进入下一层递归，尝试在剩下的元素中继续选择。

2. 撤销选择（回溯）：

   • 如果当前选择不符合要求，你需要撤销这个选择，然后尝试其他的选择。
   • 回溯的意思就是在当前选择失败后，返回到之前的状态，然后尝试不同的选择。

通过简单的示例来理解：

假设你要从 {1, 2, 3} 中选择数字，使它们的和等于 4，并且可以重复选择。回溯算法将这样工作：

1. 尝试选择 1：

   • 当前组合是 [1]，剩余目标是 3（即 4 - 1）。
   • 继续递归尝试在 {1, 2, 3} 中选择。

2. 继续选择 1：

   • 当前组合是 [1, 1]，剩余目标是 2（即 3 - 1）。
   • 继续递归。

3. 再选择 1：

   • 当前组合是 [1, 1, 1]，剩余目标是 1（即 2 - 1）。
   • 继续递归。

4. 再选择 1：

   • 当前组合是 [1, 1, 1, 1]，剩余目标是 0（即 1 - 1）。
   • 目标为 0，找到一个有效的组合 [1, 1, 1, 1]，将它加入结果中。

5. 撤销选择：

   • 从 [1, 1, 1, 1] 变为 [1, 1, 1]，尝试其他的选择，比如选择 2。

6. 选择 2：

   • 当前组合是 [1, 1, 2]，剩余目标是 0（即 2 - 2）。
   • 目标为 0，找到另一个有效的组合 [1, 1, 2]，将它加入结果中。

7. 撤销选择：

   • 从 [1, 1, 2] 变为 [1, 1]，继续尝试其他选择，比如选择 3。

8. 选择 3：

   • 当前组合是 [1, 1, 3]，剩余目标是 0（即 3 - 3）。
   • 目标为 0，找到另一个有效的组合 [1, 1, 3]，将它加入结果中。

9. 继续尝试其他起始元素：

   • 你可以继续尝试以 2 和 3 为起始元素的组合。

回溯算法的步骤：

1. 选择：在当前步骤选择一个可能的元素，添加到当前组合中。
2. 递归：递归到下一层，处理下一个问题。
3. 检查：如果达到目标（即解），将结果添加到最终结果集中。
4. 撤销选择：回到上一步，尝试其他可能的选择。

二、问题求解

代码如下：

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<vector<int>>result;//存放最后的组合
        vector<int>combination;//存放当前的组合
        backtrack(candidates,result,target,combination,0);
        return result;
           }
	void backtrack(vector<int>& candidates,vector<vector<int>>& result,int target,vector<int>&combination,int start;){
		if(target==0){
			result.push_back(combination);// 加入最终组合中
			return;  //返回到i-1前的组合
	}
		for(int i=start;i<candidates.size();i++){
			if(candidates[i]>target) break;
			combination.push_back(candidates[i]);
			backtrack(candidates,result,target-candidates[i],combination,i);//递归检查加入candidates里的数字是否符合要求
			combination.pop_back();// 最终的组合回溯前一个（也就是删除前一个），再加入下一个再递归
	}
}
};

如果是每个数字在每个组合中只使用一次：

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<vector<int>>result;//存放最后的组合
        vector<int>combination;//存放当前的组合
        backtrack(candidates,result,target,combination,0);
        return result;
           }
	void backtrack(vector<int>& candidates,vector<vector<int>>& result,int target,vector<int>&combination,int start;){
		if(target==0){
			result.push_back(combination);// 加入最终组合中
			return;  //返回到i-1前的组合
	}
		for(int i=start;i<candidates.size();i++){
			if(candidates[i]>target) break;
			if(i>start&&candidates[i]==candidates[i-1]) continue;  //跳过同一层级中已经选择的组合，比如candidates 为 [1, 1, 2]，target 为 3，在同一层级的回溯中，你可能会得到两次 [1, 2]，因为两个 1 会分别被选择。结果会变成 [1, 2] 和 [1, 2]，即出现了重复的组合。有了这行代码之后：我们在选择第二个 1 时会跳过，从而避免生成重复的组合。
			combination.push_back(candidates[i]);
			backtrack(candidates,result,target-candidates[i],combination,i+1);//递归检查加入candidates里的数字是否符合要求，跳过当前选择的数字
			combination.pop_back();// 最终的组合回溯前一个（也就是删除前一个），再加入下一个再递归
	}
}
};