回溯算法解决组合总和问题及Java实现

1. 组合总和问题概述

LeetCode上的组合总和问题（Combination Sum）是算法练习中的经典题目，要求找出所有能使数字和等于目标值的候选数字组合。这类问题在技术面试中出现频率极高，尤其考察候选人对回溯算法的理解和优化能力。

我最初接触这个问题时，曾陷入暴力枚举的误区，后来通过系统学习和反复实践，才真正掌握了回溯与剪枝的精髓。这道题的Java实现看似简单，但要做到高效和优雅，需要深入理解几个关键点：

• 候选数字可以无限制重复选取
• 解集不能包含重复组合
• 需要找到所有可能的解而非最优解

2. 回溯算法基础实现

2.1 基本回溯框架

回溯算法的核心是尝试所有可能的路径，并在不满足条件时回退。对于组合总和问题，最基本的Java实现如下：

java复制public List<List<Integer>> combinationSum(int[] candidates, int target) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack(result, new ArrayList<>(), candidates, target, 0);
    return result;
}

private void backtrack(List<List<Integer>> result, List<Integer> tempList, 
                      int[] candidates, int remain, int start) {
    if (remain < 0) return;
    if (remain == 0) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        tempList.add(candidates[i]);
        backtrack(result, tempList, candidates, remain - candidates[i], i);
        tempList.remove(tempList.size() - 1);
    }
}

这个实现有几个关键点需要注意：

1. 使用start参数避免重复组合
2. 每次递归更新剩余值remain
3. 必须创建新ArrayList存储结果，防止引用问题

2.2 时间复杂度分析

未经优化的回溯算法时间复杂度为O(N^T)，其中N是候选数字个数，T是目标值。这是因为在最坏情况下，每个数字都可能被重复选择多次，直到达到目标值。

3. 剪枝优化策略

3.1 排序预处理

在回溯前对数组进行排序可以带来两个好处：

1. 提前终止不可能的分支
2. 方便后续剪枝操作

java复制Arrays.sort(candidates); // 预处理排序

3.2 剪枝条件优化

在排序基础上，可以添加剪枝条件：

java复制for (int i = start; i < candidates.length; i++) {
    if (candidates[i] > remain) break; // 关键剪枝
    tempList.add(candidates[i]);
    backtrack(result, tempList, candidates, remain - candidates[i], i);
    tempList.remove(tempList.size() - 1);
}

这个剪枝可以将时间复杂度优化到O(2^N)，因为每个数字只有选或不选两种可能（虽然可以重复选择，但排序后可以提前终止）。

4. 完整优化实现

结合上述优化，完整的Java实现如下：

java复制public List<List<Integer>> combinationSum(int[] candidates, int target) {
    List<List<Integer>> result = new ArrayList<>();
    Arrays.sort(candidates);
    backtrack(result, new ArrayList<>(), candidates, target, 0);
    return result;
}

private void backtrack(List<List<Integer>> result, List<Integer> tempList, 
                      int[] candidates, int remain, int start) {
    if (remain == 0) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        if (candidates[i] > remain) break;
        tempList.add(candidates[i]);
        backtrack(result, tempList, candidates, remain - candidates[i], i);
        tempList.remove(tempList.size() - 1);
    }
}

5. 算法正确性验证

为了验证算法的正确性，我通常会构造以下几种测试用例：

1. 常规测试用例：

   java复制int[] candidates = {2,3,6,7};
   int target = 7;
   // 预期输出：[[2,2,3],[7]]
   

2. 边界测试用例：

   java复制int[] candidates = {2};
   int target = 1;
   // 预期输出：[]
   

3. 重复元素测试：

   java复制int[] candidates = {2,3,3,6,7};
   int target = 7;
   // 仍应输出：[[2,2,3],[7]]，不会出现重复组合
   

6. 性能对比测试

我做了以下性能对比实验（单位：毫秒）：

可以看到剪枝带来的性能提升非常显著，特别是当候选数字较多时。

7. 常见错误与调试技巧

7.1 结果去重问题

新手常犯的错误是结果中包含重复组合，比如输入[2,3,6,7]，得到[[2,2,3],[2,3,2],[3,2,2],...]。这是因为没有控制遍历的起始位置。正确的做法是：

java复制// 错误写法：每次都从0开始遍历
for (int i = 0; i < candidates.length; i++)

// 正确写法：从start开始遍历
for (int i = start; i < candidates.length; i++)

7.2 引用传递问题

另一个常见错误是直接添加tempList到结果中：

java复制// 错误写法：会导致所有结果都指向同一个list
result.add(tempList);

// 正确写法：创建新列表
result.add(new ArrayList<>(tempList));

7.3 剪枝条件位置

剪枝条件应该放在循环内部，而不是递归开始处：

java复制// 次优写法：每次递归都检查
if (remain < 0) return;

// 更优写法：在循环内提前判断
if (candidates[i] > remain) break;

8. 算法扩展与变种

8.1 组合总和II（不可重复使用元素）

如果每个数字只能使用一次，需要做两处修改：

1. 递归时传递i+1而不是i
2. 需要额外处理数组中重复元素的情况

java复制public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    List<List<Integer>> result = new ArrayList<>();
    Arrays.sort(candidates);
    backtrack2(result, new ArrayList<>(), candidates, target, 0);
    return result;
}

private void backtrack2(List<List<Integer>> result, List<Integer> tempList, 
                       int[] candidates, int remain, int start) {
    if (remain == 0) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        if (i > start && candidates[i] == candidates[i-1]) continue; // 去重
        if (candidates[i] > remain) break;
        tempList.add(candidates[i]);
        backtrack2(result, tempList, candidates, remain - candidates[i], i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

8.2 组合总和III（固定数量）

如果要求组合中数字的数量固定为k个，可以增加一个计数参数：

java复制public List<List<Integer>> combinationSum3(int k, int n) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack3(result, new ArrayList<>(), k, n, 1);
    return result;
}

private void backtrack3(List<List<Integer>> result, List<Integer> tempList,
                      int k, int remain, int start) {
    if (tempList.size() == k && remain == 0) {
        result.add(new ArrayList<>(tempList));
        return;
    }
    for (int i = start; i <= 9; i++) {
        if (i > remain) break;
        tempList.add(i);
        backtrack3(result, tempList, k, remain - i, i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

9. 实际应用场景

组合总和算法在实际中有多种应用场景：

1. 电商促销组合：给定不同面值的优惠券，找出所有能达到满减条件的组合
2. 金融投资组合：选择不同收益率的投资产品，达到目标收益
3. 资源分配问题：将有限资源分配给不同项目，达到最优效果

10. 面试技巧与注意事项

在面试中遇到这类问题时，建议按照以下步骤进行：

1. 先明确问题要求（是否可以重复使用数字、解集是否需要去重等）
2. 提出暴力解法并分析复杂度
3. 逐步引入优化（排序、剪枝）
4. 讨论边界条件和特殊情况
5. 编写代码并测试

特别要注意的是：

• 先和面试官确认输入是否包含负数或零
• 讨论解集的大小限制（是否需要限制组合长度）
• 考虑内存使用情况（对于大target值）