C++ 回溯法模板：排列 / 子集 / 组合
回溯法是解决这三类问题的核心思路，下面给出通用模板和具体实现。
🧩 核心回溯框架
void backtrack(参数) {
if (终止条件) {
收集结果;
return;
}
for (选择 : 选择列表) {
做选择;
backtrack(下一层);
撤销选择;
}
}
一、子集问题
1.1 无重复元素的子集（LeetCode 78）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtrack(vector<int>& nums, int startIndex) {
result.push_back(path); // 每个节点都是一个子集
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
backtrack(nums, i + 1);
path.pop_back();
}
}
vector<vector<int>> subsets(vector<int>& nums) {
backtrack(nums, 0);
return result;
}
};
1.2 有重复元素的子集（LeetCode 90）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtrack(vector<int>& nums, int startIndex) {
result.push_back(path);
for (int i = startIndex; i < nums.size(); i++) {
// 🔑 关键：同层去重
if (i > startIndex && nums[i] == nums[i - 1]) continue;
path.push_back(nums[i]);
backtrack(nums, i + 1);
path.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(), nums.end()); // 必须先排序
backtrack(nums, 0);
return result;
}
};
二、组合问题
2.1 基本组合（LeetCode 77）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtrack(int n, int k, int startIndex) {
if (path.size() == k) {
result.push_back(path);
return;
}
// 🔑 剪枝优化：剩余元素不足时提前终止
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
path.push_back(i);
backtrack(n, k, i + 1);
path.pop_back();
}
}
vector<vector<int>> combine(int n, int k) {
backtrack(n, k, 1);
return result;
}
};
2.2 组合总和（元素可重复使用，LeetCode 39）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtrack(vector<int>& candidates, int target, int sum, int startIndex) {
if (sum == target) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size(); i++) {
if (sum + candidates[i] > target) break; // 剪枝（需排序）
path.push_back(candidates[i]);
backtrack(candidates, target, sum + candidates[i], i); // i不+1，可重复
path.pop_back();
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
sort(candidates.begin(), candidates.end());
backtrack(candidates, target, 0, 0);
return result;
}
};
2.3 组合总和（元素不可重复，LeetCode 40）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtrack(vector<int>& candidates, int target, int sum, int startIndex) {
if (sum == target) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size(); i++) {
if (sum + candidates[i] > target) break;
// 🔑 同层去重
if (i > startIndex && candidates[i] == candidates[i - 1]) continue;
path.push_back(candidates[i]);
backtrack(candidates, target, sum + candidates[i], i + 1);
path.pop_back();
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(), candidates.end());
backtrack(candidates, target, 0, 0);
return result;
}
};
三、排列问题
3.1 无重复元素的全排列（LeetCode 46）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
vector<bool> used;
void backtrack(vector<int>& nums) {
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
if (used[i]) continue; // 同一元素不重复使用
used[i] = true;
path.push_back(nums[i]);
backtrack(nums);
path.pop_back();
used[i] = false;
}
}
vector<vector<int>> permute(vector<int>& nums) {
used.assign(nums.size(), false);
backtrack(nums);
return result;
}
};
3.2 有重复元素的全排列（LeetCode 47）
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
vector<bool> used;
void backtrack(vector<int>& nums) {
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
// 🔑 去重核心逻辑
if (used[i]) continue;
if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
used[i] = true;
path.push_back(nums[i]);
backtrack(nums);
path.pop_back();
used[i] = false;
}
}
vector<vector<int>> permuteUnique(vector<int>& nums) {
sort(nums.begin(), nums.end()); // 必须排序
used.assign(nums.size(), false);
backtrack(nums);
return result;
}
};
四、三类问题对比总结
| 特性 | 子集 | 组合 | 排列 |
|---|---|---|---|
| 结果收集时机 | 每个节点 | 叶子节点 | 叶子节点 |
| 是否用 startIndex | ✅ 是 | ✅ 是 | ❌ 否 |
| 是否用 used 数组 | ❌ 否 | ❌ 否 | ✅ 是 |
| 顺序是否有影响 | 无影响 | 无影响 | 有影响 |
| 去重方式 | 排序+同层跳过 | 排序+同层跳过 | 排序+used判断 |
五、去重口诀 🔑
有重复元素 → 先排序
同层去重 → if (i > startIndex && nums[i] == nums[i-1]) continue;
同枝去重 → if (used[i-1] == false && nums[i] == nums[i-1]) continue;
💡 记忆技巧：
- 子集/组合 用
startIndex控制起点，避免重复选择之前的元素- 排列 每次从头遍历，用
used[]标记已用元素
为什么是 !used[i-1]？
这是排列去重中最难理解的一行，我来彻底讲清楚。
先理解去重的目标
对于 nums = [1, 1, 2]（排序后），全排列结果应该是：
[1,1,2] [1,2,1] [2,1,1]
而不是出现两个 [1,1,2]（因为有两个1）
两种情况分析
当遇到 nums[i] == nums[i-1] 时，分两种情况：
情况一：used[i-1] == true（前一个1在当前枝上已使用）
当前路径：[1(index0), ...]
现在选 index1 的 1
树形结构：
├── 选 index0 的1
│ ├── 选 index1 的1 ← used[i-1]=true，说明是"同一树枝"的不同位置
│ │ └── 选 2 → [1,1,2] ✅ 合法！应该保留
used[i-1] = true意味着：index0的1已经在路径中了，现在再选index1的1，是在构造 [1,1,...] 这种包含两个1的排列，合法！
情况二：used[i-1] == false（前一个1没有在当前枝上）
树形结构：
├── 选 index0 的1
│ └── ... → 产生了 [1,1,2]
├── 选 index1 的1 ← used[i-1]=false，index0的1没被用
│ └── ... → 也会产生 [1,1,2] ❌ 重复！应该跳过
used[i-1] = false意味着：index0的1已经被回溯撤销了，现在用index1的1作为起点，会产生和之前完全相同的排列，重复！
画出完整的树
nums = [1(0), 1(1), 2(2)]
root
/ | \
选1(0) 选1(1) 选2(2)
/ \ / \ / \
选1(1) 选2(2) 选1(0) 选2(2) 选1(0) 选1(1)
| | | | | |
选2(2) 选1(1) 选2(2) 选1(0) 选1(1) 选1(0)
[1,1,2] [1,2,1] [1,1,2] [1,2,1] [2,1,1] [2,1,1]
❌重复↗ ❌重复↗
加上 !used[i-1] 条件后，剪掉 选1(1) 和 选2(2) 作为根的重复分支：
root
/ | \
选1(0) ~~选1(1)~~ 选2(2)
/ \ (剪掉) / \
选1(1) 选2(2) 选1(0) 选1(1)
| | | |
选2(2) 选1(1) 选1(1) 选1(0)
[1,1,2] [1,2,1] [2,1,1] ~~[2,1,1]~~
(也被剪掉)
if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
| 条件 | 含义 |
|---|---|
nums[i] == nums[i-1] |
当前元素和前一个相同（可能重复） |
!used[i-1] |
前一个相同元素没在当前路径中 → 说明是同层的重复选择 → 剪掉 |
used[i-1] |
前一个相同元素在当前路径中 → 说明是同枝的不同位置 → 保留 |
💡 核心逻辑：
used[i-1] = true→ 同一树枝，位置不同 → 合法，保留used[i-1] = false→ 同一树层，换了个相同的数重新开始 → 重复，剪掉
浙公网安备 33010602011771号