13.3 子集和问题¶
13.3.1 无重复元素的情况¶
Question
给定一个正整数数组 nums 和一个目标正整数 target ,请找出所有可能的组合,使得组合中的元素和等于 target 。给定数组无重复元素,每个元素可以被选取多次。请以列表形式返回这些组合,列表中不应包含重复组合。
例如,输入集合 \(\{3, 4, 5\}\) 和目标整数 \(9\) ,解为 \(\{3, 3, 3\}, \{4, 5\}\) 。需要注意以下两点。
- 输入集合中的元素可以被无限次重复选取。
- 子集不区分元素顺序,比如 \(\{4, 5\}\) 和 \(\{5, 4\}\) 是同一个子集。
1. 参考全排列解法¶
类似于全排列问题,我们可以把子集的生成过程想象成一系列选择的结果,并在选择过程中实时更新“元素和”,当元素和等于 target 时,就将子集记录至结果列表。
而与全排列问题不同的是,本题集合中的元素可以被无限次选取,因此无须借助 selected 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改,初步得到解题代码:
def backtrack(
state: list[int],
target: int,
total: int,
choices: list[int],
res: list[list[int]],
):
"""回溯算法:子集和 I"""
# 子集和等于 target 时,记录解
if total == target:
res.append(list(state))
return
# 遍历所有选择
for i in range(len(choices)):
# 剪枝:若子集和超过 target ,则跳过该选择
if total + choices[i] > target:
continue
# 尝试:做出选择,更新元素和 total
state.append(choices[i])
# 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res)
# 回退:撤销选择,恢复到之前的状态
state.pop()
def subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:
"""求解子集和 I(包含重复子集)"""
state = [] # 状态(子集)
total = 0 # 子集和
res = [] # 结果列表(子集列表)
backtrack(state, target, total, nums, res)
return res
/* 回溯算法:子集和 I */
void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
// 子集和等于 target 时,记录解
if (total == target) {
res.push_back(state);
return;
}
// 遍历所有选择
for (size_t i = 0; i < choices.size(); i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.push_back(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.pop_back();
}
}
/* 求解子集和 I(包含重复子集) */
vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
vector<int> state; // 状态(子集)
int total = 0; // 子集和
vector<vector<int>> res; // 结果列表(子集列表)
backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
void backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {
// 子集和等于 target 时,记录解
if (total == target) {
res.add(new ArrayList<>(state));
return;
}
// 遍历所有选择
for (int i = 0; i < choices.length; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.remove(state.size() - 1);
}
}
/* 求解子集和 I(包含重复子集) */
List<List<Integer>> subsetSumINaive(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状态(子集)
int total = 0; // 子集和
List<List<Integer>> res = new ArrayList<>(); // 结果列表(子集列表)
backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
void Backtrack(List<int> state, int target, int total, int[] choices, List<List<int>> res) {
// 子集和等于 target 时,记录解
if (total == target) {
res.Add(new List<int>(state));
return;
}
// 遍历所有选择
for (int i = 0; i < choices.Length; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.Add(choices[i]);
// 进行下一轮选择
Backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.RemoveAt(state.Count - 1);
}
}
/* 求解子集和 I(包含重复子集) */
List<List<int>> SubsetSumINaive(int[] nums, int target) {
List<int> state = []; // 状态(子集)
int total = 0; // 子集和
List<List<int>> res = []; // 结果列表(子集列表)
Backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
func backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时,记录解
if target == total {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
for i := 0; i < len(*choices); i++ {
// 剪枝:若子集和超过 target ,则跳过该选择
if total+(*choices)[i] > target {
continue
}
// 尝试:做出选择,更新元素和 total
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)
// 回退:撤销选择,恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 I(包含重复子集) */
func subsetSumINaive(nums []int, target int) [][]int {
state := make([]int, 0) // 状态(子集)
total := 0 // 子集和
res := make([][]int, 0) // 结果列表(子集列表)
backtrackSubsetSumINaive(total, target, &state, &nums, &res)
return res
}
/* 回溯算法:子集和 I */
func backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {
// 子集和等于 target 时,记录解
if total == target {
res.append(state)
return
}
// 遍历所有选择
for i in choices.indices {
// 剪枝:若子集和超过 target ,则跳过该选择
if total + choices[i] > target {
continue
}
// 尝试:做出选择,更新元素和 total
state.append(choices[i])
// 进行下一轮选择
backtrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)
// 回退:撤销选择,恢复到之前的状态
state.removeLast()
}
}
/* 求解子集和 I(包含重复子集) */
func subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {
var state: [Int] = [] // 状态(子集)
let total = 0 // 子集和
var res: [[Int]] = [] // 结果列表(子集列表)
backtrack(state: &state, target: target, total: total, choices: nums, res: &res)
return res
}
/* 回溯算法:子集和 I */
function backtrack(state, target, total, choices, res) {
// 子集和等于 target 时,记录解
if (total === target) {
res.push([...state]);
return;
}
// 遍历所有选择
for (let i = 0; i < choices.length; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I(包含重复子集) */
function subsetSumINaive(nums, target) {
const state = []; // 状态(子集)
const total = 0; // 子集和
const res = []; // 结果列表(子集列表)
backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
function backtrack(
state: number[],
target: number,
total: number,
choices: number[],
res: number[][]
): void {
// 子集和等于 target 时,记录解
if (total === target) {
res.push([...state]);
return;
}
// 遍历所有选择
for (let i = 0; i < choices.length; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I(包含重复子集) */
function subsetSumINaive(nums: number[], target: number): number[][] {
const state = []; // 状态(子集)
const total = 0; // 子集和
const res = []; // 结果列表(子集列表)
backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
void backtrack(
List<int> state,
int target,
int total,
List<int> choices,
List<List<int>> res,
) {
// 子集和等于 target 时,记录解
if (total == target) {
res.add(List.from(state));
return;
}
// 遍历所有选择
for (int i = 0; i < choices.length; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 I(包含重复子集) */
List<List<int>> subsetSumINaive(List<int> nums, int target) {
List<int> state = []; // 状态(子集)
int total = 0; // 元素和
List<List<int>> res = []; // 结果列表(子集列表)
backtrack(state, target, total, nums, res);
return res;
}
/* 回溯算法:子集和 I */
fn backtrack(
state: &mut Vec<i32>,
target: i32,
total: i32,
choices: &[i32],
res: &mut Vec<Vec<i32>>,
) {
// 子集和等于 target 时,记录解
if total == target {
res.push(state.clone());
return;
}
// 遍历所有选择
for i in 0..choices.len() {
// 剪枝:若子集和超过 target ,则跳过该选择
if total + choices[i] > target {
continue;
}
// 尝试:做出选择,更新元素和 total
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I(包含重复子集) */
fn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec<Vec<i32>> {
let mut state = Vec::new(); // 状态(子集)
let total = 0; // 子集和
let mut res = Vec::new(); // 结果列表(子集列表)
backtrack(&mut state, target, total, nums, &mut res);
res
}
/* 回溯算法:子集和 I */
void backtrack(int target, int total, int *choices, int choicesSize) {
// 子集和等于 target 时,记录解
if (total == target) {
for (int i = 0; i < stateSize; i++) {
res[resSize][i] = state[i];
}
resColSizes[resSize++] = stateSize;
return;
}
// 遍历所有选择
for (int i = 0; i < choicesSize; i++) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试:做出选择,更新元素和 total
state[stateSize++] = choices[i];
// 进行下一轮选择
backtrack(target, total + choices[i], choices, choicesSize);
// 回退:撤销选择,恢复到之前的状态
stateSize--;
}
}
/* 求解子集和 I(包含重复子集) */
void subsetSumINaive(int *nums, int numsSize, int target) {
resSize = 0; // 初始化解的数量为0
backtrack(target, 0, nums, numsSize);
}
/* 回溯算法:子集和 I */
fun backtrack(
state: MutableList<Int>,
target: Int,
total: Int,
choices: IntArray,
res: MutableList<MutableList<Int>?>
) {
// 子集和等于 target 时,记录解
if (total == target) {
res.add(state.toMutableList())
return
}
// 遍历所有选择
for (i in choices.indices) {
// 剪枝:若子集和超过 target ,则跳过该选择
if (total + choices[i] > target) {
continue
}
// 尝试:做出选择,更新元素和 total
state.add(choices[i])
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res)
// 回退:撤销选择,恢复到之前的状态
state.removeAt(state.size - 1)
}
}
/* 求解子集和 I(包含重复子集) */
fun subsetSumINaive(nums: IntArray, target: Int): MutableList<MutableList<Int>?> {
val state = mutableListOf<Int>() // 状态(子集)
val total = 0 // 子集和
val res = mutableListOf<MutableList<Int>?>() // 结果列表(子集列表)
backtrack(state, target, total, nums, res)
return res
}
### 回溯算法:子集和 I ###
def backtrack(state, target, total, choices, res)
# 子集和等于 target 时,记录解
if total == target
res << state.dup
return
end
# 遍历所有选择
for i in 0...choices.length
# 剪枝:若子集和超过 target ,则跳过该选择
next if total + choices[i] > target
# 尝试:做出选择,更新元素和 total
state << choices[i]
# 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res)
# 回退:撤销选择,恢复到之前的状态
state.pop
end
end
### 求解子集和 I(包含重复子集)###
def subset_sum_i_naive(nums, target)
state = [] # 状态(子集)
total = 0 # 子集和
res = [] # 结果列表(子集列表)
backtrack(state, target, total, nums, res)
res
end
可视化运行
向以上代码输入数组 \([3, 4, 5]\) 和目标元素 \(9\) ,输出结果为 \([3, 3, 3], [4, 5], [5, 4]\) 。虽然成功找出了所有和为 \(9\) 的子集,但其中存在重复的子集 \([4, 5]\) 和 \([5, 4]\) 。
这是因为搜索过程是区分选择顺序的,然而子集不区分选择顺序。如图 13-10 所示,先选 \(4\) 后选 \(5\) 与先选 \(5\) 后选 \(4\) 是不同的分支,但对应同一个子集。
图 13-10 子集搜索与越界剪枝
图解 13-10:仅按和越界剪枝仍会生成重复组合
从累计和 0 出发累加 3、4、5,超过 9 的分支被剪除,但仍同时输出重复组合 [4, 5] 与 [5, 4]。
给定正整数候选数组 choices = [3, 4, 5] 与目标和 target = 9,允许同一元素重复选取,且结果子集(组合)不区分元素顺序。
圆节点表示当前前缀的累计和(根为 0),每轮从全部候选 3、4、5 中尝试累加:新和超过 9(图中 >9 虚线剪枝,不构成新圆节点)则跳过;恰好等于 9 则进入叶节点记录结果,再返回上一层继续尝试。
搜索树共有 13 个实心圆状态节点。下表按层列出各前缀的累计和与后续选择;到达和为 9 的叶节点时记录一次结果,父节点行中的“进入”只指向该子调用。表中的箭头表示进入相应子节点,箭头右侧的数字是累计和。
| 当前前缀 | 累计和 | 下一轮选择或终止原因 |
|---|---|---|
| [] | 0 | +3→3;+4→4;+5→5 |
| [3] | 3 | +3→6;+4→7;+5→8 |
| [4] | 4 | +3→7;+4→8;+5→9,进入 [4, 5](命中 9) |
| [5] | 5 | +3→8;+4→9,进入 [5, 4](命中 9);+5 越界 |
| [3, 3] | 6 | +3→9,进入 [3, 3, 3](命中 9);+4、+5 越界 |
| [3, 4] | 7 | +3、+4、+5 全部越界 |
| [3, 5] | 8 | +3、+4、+5 全部越界 |
| [4, 3] | 7 | +3、+4、+5 全部越界 |
| [4, 4] | 8 | +3、+4、+5 全部越界 |
| [4, 5] | 9 | 记录结果并返回 |
| [5, 3] | 8 | +3、+4、+5 全部越界 |
| [5, 4] | 9 | 记录结果并返回 |
| [3, 3, 3] | 9 | 记录结果并返回 |
越界剪枝虽能及时终止累计和超过 9 的分支,但搜索仍输出 [3, 3, 3]、[4, 5]、[5, 4] 三个结果,其中 [4, 5] 与 [5, 4] 是顺序不同但元素相同的重复组合。
为了去除重复子集,一种直接的思路是对结果列表进行去重。但这个方法效率很低,有两方面原因。
- 当数组元素较多,尤其是当
target较大时,搜索过程会产生大量的重复子集。 - 比较子集(数组)的异同非常耗时,需要先排序数组,再比较数组中每个元素的异同。
2. 重复子集剪枝¶
我们考虑在搜索过程中通过剪枝进行去重。观察图 13-11 ,重复子集是在以不同顺序选择数组元素时产生的,例如以下情况。
- 当第一轮和第二轮分别选择 \(3\) 和 \(4\) 时,会生成包含这两个元素的所有子集,记为 \([3, 4, \dots]\) 。
- 之后,当第一轮选择 \(4\) 时,则第二轮应该跳过 \(3\) ,因为该选择产生的子集 \([4, 3, \dots]\) 和第
1.步中生成的子集完全重复。
在搜索过程中,每一层的选择都是从左到右被逐个尝试的,因此越靠右的分支被剪掉的越多。
- 前两轮选择 \(3\) 和 \(5\) ,生成子集 \([3, 5, \dots]\) 。
- 前两轮选择 \(4\) 和 \(5\) ,生成子集 \([4, 5, \dots]\) 。
- 若第一轮选择 \(5\) ,则第二轮应该跳过 \(3\) 和 \(4\) ,因为子集 \([5, 3, \dots]\) 和 \([5, 4, \dots]\) 与第
1.步和第2.步中描述的子集完全重复。
图 13-11 不同选择顺序导致的重复子集
图解 13-11:用不递减的选择索引避免重复组合
限制下一轮只从当前索引 i 及之后选取(对应下文代码的起始索引 start = i),剪去回头选更早索引的反序重复分支。
候选数组为 choices = [3, 4, 5](索引 0、1、2),各元素允许重复选取,且子集不区分元素顺序。本图仅展开前两轮选择来对比选数顺序与重复子集的关系,未展开第三轮及目标和判断。
组合不区分元素先后:先选较大索引再回头选较小索引,必定与先选较小索引再选较大索引的路径重复。因此选了 4 后不再回头选 3,选了 5 后不再回头选 3 或 4。
由于本题允许同一元素重复选取(如 [3, 3, …]、[4, 4, …]、[5, 5, …]),当本轮选中索引 i 时,下一轮起始位置必须设为 start = i 而非 i + 1,以保留再次选择当前元素的分支。图中末尾的省略号表示后续未画出;本图只比较选数顺序,不判断是否达到或超过目标和。
被剪的三个分支以灰化方块、虚线和剪刀标出,底部灰色弧线将它们与保留的反序前缀配对。下表列全九个两元素前缀及三对重复关系。
| 两元素前缀 | 处理 | 反序配对前缀 | 原因 |
|---|---|---|---|
| [3,3,…] | 保留 | 无另一顺序的配对 | 索引不递减 |
| [3,4,…] | 保留 | [4,3,…] | 索引不递减 |
| [3,5,…] | 保留 | [5,3,…] | 索引不递减 |
| [4,3,…] | 跳过更早索引 | [3,4,…] | 与保留前缀产生重复组合 |
| [4,4,…] | 保留 | 无另一顺序的配对 | 索引不递减 |
| [4,5,…] | 保留 | [5,4,…] | 索引不递减 |
| [5,3,…] | 跳过更早索引 | [3,5,…] | 与保留前缀产生重复组合 |
| [5,4,…] | 跳过更早索引 | [4,5,…] | 与保留前缀产生重复组合 |
| [5,5,…] | 保留 | 无另一顺序的配对 | 索引不递减 |
前两轮九个前缀中保留六个索引不递减的前缀;三条回头选更早索引的分支被剪去。
总结来看,给定输入数组 \([x_1, x_2, \dots, x_n]\) ,设搜索过程中的选择序列为 \([x_{i_1}, x_{i_2}, \dots, x_{i_m}]\) ,则该选择序列需要满足 \(i_1 \leq i_2 \leq \dots \leq i_m\) ,不满足该条件的选择序列都会造成重复,应当剪枝。
3. 代码实现¶
为实现该剪枝,我们初始化变量 start ,用于指示遍历起始点。当做出选择 \(x_{i}\) 后,设定下一轮从索引 \(i\) 开始遍历。这样做就可以让选择序列满足 \(i_1 \leq i_2 \leq \dots \leq i_m\) ,从而保证子集唯一。
除此之外,我们还对代码进行了以下两项优化。
- 在开启搜索前,先将数组
nums排序。在遍历所有选择时,当子集和超过target时直接结束循环,因为后边的元素更大,其子集和一定超过target。 - 省去元素和变量
total,通过在target上执行减法来统计元素和,当target等于 \(0\) 时记录解。
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""回溯算法:子集和 I"""
# 子集和等于 target 时,记录解
if target == 0:
res.append(list(state))
return
# 遍历所有选择
# 剪枝二:从 start 开始遍历,避免生成重复子集
for i in range(start, len(choices)):
# 剪枝一:若子集和超过 target ,则直接结束循环
# 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0:
break
# 尝试:做出选择,更新 target, start
state.append(choices[i])
# 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res)
# 回退:撤销选择,恢复到之前的状态
state.pop()
def subset_sum_i(nums: list[int], target: int) -> list[list[int]]:
"""求解子集和 I"""
state = [] # 状态(子集)
nums.sort() # 对 nums 进行排序
start = 0 # 遍历起始点
res = [] # 结果列表(子集列表)
backtrack(state, target, nums, start, res)
return res
/* 回溯算法:子集和 I */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.push_back(state);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (int i = start; i < choices.size(); i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.push_back(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.pop_back();
}
}
/* 求解子集和 I */
vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
vector<int> state; // 状态(子集)
sort(nums.begin(), nums.end()); // 对 nums 进行排序
int start = 0; // 遍历起始点
vector<vector<int>> res; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (int i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.remove(state.size() - 1);
}
}
/* 求解子集和 I */
List<List<Integer>> subsetSumI(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状态(子集)
Arrays.sort(nums); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<Integer>> res = new ArrayList<>(); // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
void Backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.Add(new List<int>(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (int i = start; i < choices.Length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.Add(choices[i]);
// 进行下一轮选择
Backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.RemoveAt(state.Count - 1);
}
}
/* 求解子集和 I */
List<List<int>> SubsetSumI(int[] nums, int target) {
List<int> state = []; // 状态(子集)
Array.Sort(nums); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表(子集列表)
Backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
func backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时,记录解
if target == 0 {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for i := start; i < len(*choices); i++ {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target-(*choices)[i] < 0 {
break
}
// 尝试:做出选择,更新 target, start
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)
// 回退:撤销选择,恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 I */
func subsetSumI(nums []int, target int) [][]int {
state := make([]int, 0) // 状态(子集)
sort.Ints(nums) // 对 nums 进行排序
start := 0 // 遍历起始点
res := make([][]int, 0) // 结果列表(子集列表)
backtrackSubsetSumI(start, target, &state, &nums, &res)
return res
}
/* 回溯算法:子集和 I */
func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
// 子集和等于 target 时,记录解
if target == 0 {
res.append(state)
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for i in choices.indices.dropFirst(start) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0 {
break
}
// 尝试:做出选择,更新 target, start
state.append(choices[i])
// 进行下一轮选择
backtrack(state: &state, target: target - choices[i], choices: choices, start: i, res: &res)
// 回退:撤销选择,恢复到之前的状态
state.removeLast()
}
}
/* 求解子集和 I */
func subsetSumI(nums: [Int], target: Int) -> [[Int]] {
var state: [Int] = [] // 状态(子集)
let nums = nums.sorted() // 对 nums 进行排序
let start = 0 // 遍历起始点
var res: [[Int]] = [] // 结果列表(子集列表)
backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
return res
}
/* 回溯算法:子集和 I */
function backtrack(state, target, choices, start, res) {
// 子集和等于 target 时,记录解
if (target === 0) {
res.push([...state]);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (let i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I */
function subsetSumI(nums, target) {
const state = []; // 状态(子集)
nums.sort((a, b) => a - b); // 对 nums 进行排序
const start = 0; // 遍历起始点
const res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
function backtrack(
state: number[],
target: number,
choices: number[],
start: number,
res: number[][]
): void {
// 子集和等于 target 时,记录解
if (target === 0) {
res.push([...state]);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (let i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I */
function subsetSumI(nums: number[], target: number): number[][] {
const state = []; // 状态(子集)
nums.sort((a, b) => a - b); // 对 nums 进行排序
const start = 0; // 遍历起始点
const res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
void backtrack(
List<int> state,
int target,
List<int> choices,
int start,
List<List<int>> res,
) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(List.from(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (int i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 I */
List<List<int>> subsetSumI(List<int> nums, int target) {
List<int> state = []; // 状态(子集)
nums.sort(); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 I */
fn backtrack(
state: &mut Vec<i32>,
target: i32,
choices: &[i32],
start: usize,
res: &mut Vec<Vec<i32>>,
) {
// 子集和等于 target 时,记录解
if target == 0 {
res.push(state.clone());
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for i in start..choices.len() {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0 {
break;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 I */
fn subset_sum_i(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
let mut state = Vec::new(); // 状态(子集)
nums.sort(); // 对 nums 进行排序
let start = 0; // 遍历起始点
let mut res = Vec::new(); // 结果列表(子集列表)
backtrack(&mut state, target, nums, start, &mut res);
res
}
/* 回溯算法:子集和 I */
void backtrack(int target, int *choices, int choicesSize, int start) {
// 子集和等于 target 时,记录解
if (target == 0) {
for (int i = 0; i < stateSize; ++i) {
res[resSize][i] = state[i];
}
resColSizes[resSize++] = stateSize;
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (int i = start; i < choicesSize; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试:做出选择,更新 target, start
state[stateSize] = choices[i];
stateSize++;
// 进行下一轮选择
backtrack(target - choices[i], choices, choicesSize, i);
// 回退:撤销选择,恢复到之前的状态
stateSize--;
}
}
/* 求解子集和 I */
void subsetSumI(int *nums, int numsSize, int target) {
qsort(nums, numsSize, sizeof(int), cmp); // 对 nums 进行排序
int start = 0; // 遍历起始点
backtrack(target, nums, numsSize, start);
}
/* 回溯算法:子集和 I */
fun backtrack(
state: MutableList<Int>,
target: Int,
choices: IntArray,
start: Int,
res: MutableList<MutableList<Int>?>
) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(state.toMutableList())
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
for (i in start..<choices.size) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break
}
// 尝试:做出选择,更新 target, start
state.add(choices[i])
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res)
// 回退:撤销选择,恢复到之前的状态
state.removeAt(state.size - 1)
}
}
/* 求解子集和 I */
fun subsetSumI(nums: IntArray, target: Int): MutableList<MutableList<Int>?> {
val state = mutableListOf<Int>() // 状态(子集)
nums.sort() // 对 nums 进行排序
val start = 0 // 遍历起始点
val res = mutableListOf<MutableList<Int>?>() // 结果列表(子集列表)
backtrack(state, target, nums, start, res)
return res
}
### 回溯算法:子集和 I ###
def backtrack(state, target, choices, start, res)
# 子集和等于 target 时,记录解
if target.zero?
res << state.dup
return
end
# 遍历所有选择
# 剪枝二:从 start 开始遍历,避免生成重复子集
for i in start...choices.length
# 剪枝一:若子集和超过 target ,则直接结束循环
# 这是因为数组已排序,后边元素更大,子集和一定超过 target
break if target - choices[i] < 0
# 尝试:做出选择,更新 target, start
state << choices[i]
# 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res)
# 回退:撤销选择,恢复到之前的状态
state.pop
end
end
### 求解子集和 I ###
def subset_sum_i(nums, target)
state = [] # 状态(子集)
nums.sort! # 对 nums 进行排序
start = 0 # 遍历起始点
res = [] # 结果列表(子集列表)
backtrack(state, target, nums, start, res)
res
end
可视化运行
图 13-12 所示为将数组 \([3, 4, 5]\) 和目标元素 \(9\) 输入以上代码后的整体回溯过程。
图 13-12 子集和 I 回溯过程
图解 13-12:子集和 I:余额归零与顺序剪枝
从目标 9 起逐层扣减候选,结合 start=i 与越界 break,输出 [3, 3, 3] 和 [4, 5]。
输入为已升序排列的正整数数组 choices = [3, 4, 5](索引 0、1、2)与初始目标 target = 9,元素允许重复选取,组合不区分顺序。图中圆节点内的数字表示剩余目标余额(9 减去当前前缀和),减至 0 时即命中合法子集。
进入调用后若余额为 0,则记录当前组合并返回上一层,由上一层继续循环;否则从起始索引 start 起枚举候选 choices[i],扣减余额后进入下一层。向下递归传递 start = i,既允许重复选取当前元素,又跳过更早索引(图中黑剪刀所示的顺序剪枝)。
候选已升序排列,在 i ≥ start 的范围内,遇到第一个大于余额的候选,只比较即 break,直接结束本轮循环;第一个及其后更大的越界候选都不会递归进入。图中的红剪刀标出这些越界分支。
图中有 10 个非负余额圆节点。下表按前缀列出余额、图示限制与实际后续;其中 [4, 4] 的余额 1 在图中没有继续展开,其后续 break 是按代码规则补充的。
| 当前前缀 | 剩余目标 | 可继续选择 | 图中限制或终止情况 | 实际后续 |
|---|---|---|---|---|
| [] | 9 | 3、4、5 | 无 | 选择后余额分别为 6、5、4 |
| [3] | 6 | 3、4、5 | 无 | 选择后余额分别为 3、2、1 |
| [3,3] | 3 | 3 | 4、5 越界 | 选 3 到 0;遇 4 时 break |
| [3,3,3] | 0 | 无 | 不再选择 | 记录 [3,3,3] |
| [3,4] | 2 | 无 | 3 为更早索引;4、5 越界 | 从 4 开始即 break |
| [3,5] | 1 | 无 | 3、4 为更早索引;5 越界 | 从 5 开始即 break |
| [4] | 5 | 4、5 | 3 为更早索引 | 选 4 到 1;选 5 到 0 |
| [4,4] | 1 | 无 | 后续未在图中展开 | 按代码规则,从 4 开始即 break |
| [4,5] | 0 | 无 | 不再选择 | 记录 [4,5] |
| [5] | 4 | 无 | 3、4 为更早索引;5 越界 | 从 5 开始即 break |
两条归零路径是 9 → 6 → 3 → 0 与 9 → 5 → 0,分别得到 [3, 3, 3] 与 [4, 5]。
13.3.2 考虑重复元素的情况¶
Question
给定一个正整数数组 nums 和一个目标正整数 target ,请找出所有可能的组合,使得组合中的元素和等于 target 。给定数组可能包含重复元素,每个元素只可被选择一次。请以列表形式返回这些组合,列表中不应包含重复组合。
相比于上题,本题的输入数组可能包含重复元素,这引入了新的问题。例如,给定数组 \([4, \hat{4}, 5]\) 和目标元素 \(9\) ,则现有代码的输出结果为 \([4, 5], [\hat{4}, 5]\) ,出现了重复子集。
造成这种重复的原因是相等元素在某轮中被多次选择。在图 13-13 中,第一轮共有三个选择,其中两个都为 \(4\) ,会产生两个重复的搜索分支,从而输出重复子集;同理,第二轮的两个 \(4\) 也会产生重复子集。
图 13-13 相等元素导致的重复子集
图解 13-13:相等候选造成新的组合重复
候选数组中两个值为 4 的元素,会在同一轮选择中产生内容相同的重复子集分支。
输入数组为 choices = [4, 4, 5],索引依次为 0、1、2。下文以“第一个 4”和“第二个 4”区分索引 0 与 1;原图在第二个 4 上加帽,两者数值都为 4。子集和 II 要求每个索引最多用一次且解集不重复。本图先沿用子集和 I 的选择方式,即下一轮 start = i、允许再次选择当前索引,展示相等候选带来的问题。
顶部给出 choices。两层局部搜索树从空状态出发,第一轮分别选择第一个 4、第二个 4 或 5;第二轮仅在 [第一个 4, …] 下继续尝试这三个候选。两处的第三个分支都只标 +5,没有写出前缀。
第一条灰色弧线连接 [第一个 4, …] 与 [第二个 4, …];第二条连接 [第一个 4, 第一个 4, …] 与 [第一个 4, 第二个 4, …],都标注“重复子集”。前一对数值前缀同为 [4, …],后一对同为 [4, 4, …]。其中再次选第一个 4 还重用了索引 0,在子集和 II 的规则下本身就是非法选择。
要解决子集和 II 的重复问题,既要禁止同一索引在一条路径中被重复选取,又要限制同一轮中相等数值的候选只尝试一次;而不同索引的两个 4 仍允许在不同轮次先后入选。
1. 相等元素剪枝¶
为解决此问题,我们需要限制相等元素在每一轮中只能被选择一次。实现方式比较巧妙:由于数组是已排序的,因此相等元素都是相邻的。这意味着在某轮选择中,若当前元素与其左边元素相等,则说明它已经被选择过,因此直接跳过当前元素。
与此同时,本题规定每个数组元素只能被选择一次。幸运的是,我们也可以利用变量 start 来满足该约束:当做出选择 \(x_{i}\) 后,设定下一轮从索引 \(i + 1\) 开始向后遍历。这样既能去除重复子集,也能避免重复选择元素。
2. 代码实现¶
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""回溯算法:子集和 II"""
# 子集和等于 target 时,记录解
if target == 0:
res.append(list(state))
return
# 遍历所有选择
# 剪枝二:从 start 开始遍历,避免生成重复子集
# 剪枝三:从 start 开始遍历,避免重复选择同一元素
for i in range(start, len(choices)):
# 剪枝一:若子集和超过 target ,则直接结束循环
# 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0:
break
# 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if i > start and choices[i] == choices[i - 1]:
continue
# 尝试:做出选择,更新 target, start
state.append(choices[i])
# 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res)
# 回退:撤销选择,恢复到之前的状态
state.pop()
def subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:
"""求解子集和 II"""
state = [] # 状态(子集)
nums.sort() # 对 nums 进行排序
start = 0 # 遍历起始点
res = [] # 结果列表(子集列表)
backtrack(state, target, nums, start, res)
return res
/* 回溯算法:子集和 II */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.push_back(state);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (int i = start; i < choices.size(); i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.push_back(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.pop_back();
}
}
/* 求解子集和 II */
vector<vector<int>> subsetSumII(vector<int> &nums, int target) {
vector<int> state; // 状态(子集)
sort(nums.begin(), nums.end()); // 对 nums 进行排序
int start = 0; // 遍历起始点
vector<vector<int>> res; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (int i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.remove(state.size() - 1);
}
}
/* 求解子集和 II */
List<List<Integer>> subsetSumII(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状态(子集)
Arrays.sort(nums); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<Integer>> res = new ArrayList<>(); // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
void Backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.Add(new List<int>(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (int i = start; i < choices.Length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.Add(choices[i]);
// 进行下一轮选择
Backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.RemoveAt(state.Count - 1);
}
}
/* 求解子集和 II */
List<List<int>> SubsetSumII(int[] nums, int target) {
List<int> state = []; // 状态(子集)
Array.Sort(nums); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表(子集列表)
Backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
func backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {
// 子集和等于 target 时,记录解
if target == 0 {
newState := append([]int{}, *state...)
*res = append(*res, newState)
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for i := start; i < len(*choices); i++ {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target-(*choices)[i] < 0 {
break
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if i > start && (*choices)[i] == (*choices)[i-1] {
continue
}
// 尝试:做出选择,更新 target, start
*state = append(*state, (*choices)[i])
// 进行下一轮选择
backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)
// 回退:撤销选择,恢复到之前的状态
*state = (*state)[:len(*state)-1]
}
}
/* 求解子集和 II */
func subsetSumII(nums []int, target int) [][]int {
state := make([]int, 0) // 状态(子集)
sort.Ints(nums) // 对 nums 进行排序
start := 0 // 遍历起始点
res := make([][]int, 0) // 结果列表(子集列表)
backtrackSubsetSumII(start, target, &state, &nums, &res)
return res
}
/* 回溯算法:子集和 II */
func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
// 子集和等于 target 时,记录解
if target == 0 {
res.append(state)
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for i in choices.indices.dropFirst(start) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0 {
break
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if i > start, choices[i] == choices[i - 1] {
continue
}
// 尝试:做出选择,更新 target, start
state.append(choices[i])
// 进行下一轮选择
backtrack(state: &state, target: target - choices[i], choices: choices, start: i + 1, res: &res)
// 回退:撤销选择,恢复到之前的状态
state.removeLast()
}
}
/* 求解子集和 II */
func subsetSumII(nums: [Int], target: Int) -> [[Int]] {
var state: [Int] = [] // 状态(子集)
let nums = nums.sorted() // 对 nums 进行排序
let start = 0 // 遍历起始点
var res: [[Int]] = [] // 结果列表(子集列表)
backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
return res
}
/* 回溯算法:子集和 II */
function backtrack(state, target, choices, start, res) {
// 子集和等于 target 时,记录解
if (target === 0) {
res.push([...state]);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (let i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] === choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 II */
function subsetSumII(nums, target) {
const state = []; // 状态(子集)
nums.sort((a, b) => a - b); // 对 nums 进行排序
const start = 0; // 遍历起始点
const res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
function backtrack(
state: number[],
target: number,
choices: number[],
start: number,
res: number[][]
): void {
// 子集和等于 target 时,记录解
if (target === 0) {
res.push([...state]);
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (let i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] === choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 II */
function subsetSumII(nums: number[], target: number): number[][] {
const state = []; // 状态(子集)
nums.sort((a, b) => a - b); // 对 nums 进行排序
const start = 0; // 遍历起始点
const res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
void backtrack(
List<int> state,
int target,
List<int> choices,
int start,
List<List<int>> res,
) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(List.from(state));
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (int i = start; i < choices.length; i++) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 II */
List<List<int>> subsetSumII(List<int> nums, int target) {
List<int> state = []; // 状态(子集)
nums.sort(); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表(子集列表)
backtrack(state, target, nums, start, res);
return res;
}
/* 回溯算法:子集和 II */
fn backtrack(
state: &mut Vec<i32>,
target: i32,
choices: &[i32],
start: usize,
res: &mut Vec<Vec<i32>>,
) {
// 子集和等于 target 时,记录解
if target == 0 {
res.push(state.clone());
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for i in start..choices.len() {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if target - choices[i] < 0 {
break;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if i > start && choices[i] == choices[i - 1] {
continue;
}
// 尝试:做出选择,更新 target, start
state.push(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退:撤销选择,恢复到之前的状态
state.pop();
}
}
/* 求解子集和 II */
fn subset_sum_ii(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
let mut state = Vec::new(); // 状态(子集)
nums.sort(); // 对 nums 进行排序
let start = 0; // 遍历起始点
let mut res = Vec::new(); // 结果列表(子集列表)
backtrack(&mut state, target, nums, start, &mut res);
res
}
/* 回溯算法:子集和 II */
void backtrack(int target, int *choices, int choicesSize, int start) {
// 子集和等于 target 时,记录解
if (target == 0) {
for (int i = 0; i < stateSize; i++) {
res[resSize][i] = state[i];
}
resColSizes[resSize++] = stateSize;
return;
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (int i = start; i < choicesSize; i++) {
// 剪枝一:若子集和超过 target ,则直接跳过
if (target - choices[i] < 0) {
continue;
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试:做出选择,更新 target, start
state[stateSize] = choices[i];
stateSize++;
// 进行下一轮选择
backtrack(target - choices[i], choices, choicesSize, i + 1);
// 回退:撤销选择,恢复到之前的状态
stateSize--;
}
}
/* 求解子集和 II */
void subsetSumII(int *nums, int numsSize, int target) {
// 对 nums 进行排序
qsort(nums, numsSize, sizeof(int), cmp);
// 开始回溯
backtrack(target, nums, numsSize, 0);
}
/* 回溯算法:子集和 II */
fun backtrack(
state: MutableList<Int>,
target: Int,
choices: IntArray,
start: Int,
res: MutableList<MutableList<Int>?>
) {
// 子集和等于 target 时,记录解
if (target == 0) {
res.add(state.toMutableList())
return
}
// 遍历所有选择
// 剪枝二:从 start 开始遍历,避免生成重复子集
// 剪枝三:从 start 开始遍历,避免重复选择同一元素
for (i in start..<choices.size) {
// 剪枝一:若子集和超过 target ,则直接结束循环
// 这是因为数组已排序,后边元素更大,子集和一定超过 target
if (target - choices[i] < 0) {
break
}
// 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue
}
// 尝试:做出选择,更新 target, start
state.add(choices[i])
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res)
// 回退:撤销选择,恢复到之前的状态
state.removeAt(state.size - 1)
}
}
/* 求解子集和 II */
fun subsetSumII(nums: IntArray, target: Int): MutableList<MutableList<Int>?> {
val state = mutableListOf<Int>() // 状态(子集)
nums.sort() // 对 nums 进行排序
val start = 0 // 遍历起始点
val res = mutableListOf<MutableList<Int>?>() // 结果列表(子集列表)
backtrack(state, target, nums, start, res)
return res
}
### 回溯算法:子集和 II ###
def backtrack(state, target, choices, start, res)
# 子集和等于 target 时,记录解
if target.zero?
res << state.dup
return
end
# 遍历所有选择
# 剪枝二:从 start 开始遍历,避免生成重复子集
# 剪枝三:从 start 开始遍历,避免重复选择同一元素
for i in start...choices.length
# 剪枝一:若子集和超过 target ,则直接结束循环
# 这是因为数组已排序,后边元素更大,子集和一定超过 target
break if target - choices[i] < 0
# 剪枝四:如果该元素与左边元素相等,说明该搜索分支重复,直接跳过
next if i > start && choices[i] == choices[i - 1]
# 尝试:做出选择,更新 target, start
state << choices[i]
# 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res)
# 回退:撤销选择,恢复到之前的状态
state.pop
end
end
### 求解子集和 II ###
def subset_sum_ii(nums, target)
state = [] # 状态(子集)
nums.sort! # 对 nums 进行排序
start = 0 # 遍历起始点
res = [] # 结果列表(子集列表)
backtrack(state, target, nums, start, res)
res
end
可视化运行
图 13-14 展示了数组 \([4, 4, 5]\) 和目标元素 \(9\) 的回溯过程,共包含四种剪枝操作。请你将图示与代码注释相结合,理解整个搜索过程,以及每种剪枝操作是如何工作的。
图 13-14 子集和 II 回溯过程
图解 13-14:子集和 II 的四种剪枝
对有序数组 [4, 4, 5] 搜索和为 9 的子集,综合四种剪枝条件后只保留唯一解 [4, 5]。
输入数组为 choices = [4, 4, 5],索引依次为 0、1、2。下文以“第一个 4”和“第二个 4”区分索引 0 与 1;原图在第二个 4 上加帽,两者数值都为 4。数组已排序,目标 target = 9;圆圈内的数字表示剩余目标余额。
每个索引最多用一次,子集不区分顺序。选中索引 i 后,下一轮从 start = i + 1 开始,同时实现两项规则:既不回头选更早索引(剪枝二),也不重用当前索引(剪枝三)。
根处尝试第二个 4 时,i = 1 大于 start = 0,且它与前一个候选相等,触发同轮去重(剪枝四)。进入 [第一个 4] 后,新的调用 start = 1;此时第二个 4 的 i = 1 等于 start,不满足 i > start,所以仍可选。选入后余额为 1,向后只剩 5,超过余额,按剪枝一直接 break。
下表“四种剪枝的含义”对应图中的四类剪刀,下一表逐项列出前缀和候选。被剪分支都不会递归进入。其中剪枝二、三由 start = i + 1 直接跳过,代码不会逐项进入循环尝试这些候选,图中画出它们供对照;在 [第一个 4, 第二个 4] 下再选第一个 4,图中标为回到更早索引(剪枝二),而该 4 的索引 0 同时也已在路径中。
| 图例 | 排除情形 |
|---|---|
| 剪枝一(红) | 选入后元素和超过9,即剩余 target 为负 |
| 剪枝二(蓝) | 回到较早索引,产生不同顺序的重复组合 |
| 剪枝三(紫) | 再次使用刚选中的当前数组索引 |
| 剪枝四(青) | 同一轮再次尝试数值相同的候选 |
| 前缀与图示候选 | 考虑该候选前的余额 | 结果或剪枝原因 |
|---|---|---|
| []:候选 第一个 4 | 9 | 保留,余额 5 |
| []:候选 第二个 4 | 9 | 同轮重复值,剪枝四 |
| []:候选 5 | 9 | 保留,余额 4 |
| [第一个 4]:候选 第一个 4 | 5 | 重用当前索引,剪枝三 |
| [第一个 4]:候选 第二个 4 | 5 | 不同索引,可选,余额 1 |
| [第一个 4]:候选 5 | 5 | 余额 0,记录 [4, 5] |
| [第一个 4, 第二个 4]:候选 第一个 4 | 1 | 回到更早索引,图示剪枝二 |
| [第一个 4, 第二个 4]:候选 第二个 4 | 1 | 重用当前索引,剪枝三 |
| [第一个 4, 第二个 4]:候选 5 | 1 | 超过余额,剪枝一 |
| [5]:候选 第一个 4、第二个 4 | 4 | 回到更早索引,剪枝二 |
| [5]:候选 5 | 4 | 重用当前索引,剪枝三 |
唯一余额归零的路径先选第一个 4,再选 5,得到 [4, 5]。