1. 题目

读题

https://leetcode.cn/problems/combination-sum/

你好，这是Bing。根据搜索结果，leetcode 39是一个编程题目，要求你找出一个整数数组中所有可以使数字和为目标数的不同组合¹²。

例如，如果数组是[2,3,6,7]，目标数是7，

那么输出应该是[[2,2,3],[7]]。

考查点

根据搜索结果，这道题的考查点是**回溯算法**²。回溯算法是一种递归搜索的方法，可以用来找出所有可能的解。这道题要求你使用回溯算法来遍历整数数组，找出所有可以使数字和为目标数的组合。你需要注意以下几点：
- 你可以重复使用数组中的同一个数字，所以在递归时不需要改变起始位置²。
- 你需要剪枝优化，即在搜索过程中排除一些不可能的情况，比如当数字和已经超过目标数时，就不需要继续搜索了²。
- 你需要排序数组，以便在剪枝时提前判断数字和是否超过目标数²。

(1) 「leetcode」39. 组合总和【回溯算法】详解！ - 知乎. https://zhuanlan.zhihu.com/p/308364408.
(2) 39. 组合总和 - 力扣（Leetcode）. https://leetcode.cn/problems/combination-sum/.
(3) Combination Sum - LeetCode. https://leetcode.com/problems/combination-sum/.

2. 解法

思路

当然可以。思路是这样的：

我们要找出所有可能的组合，所以我们需要遍历数组中的每个元素，看看它是否可以加入到当前的组合中。如果可以，我们就把它加入到当前组合中，然后递归地寻找剩余的目标和。如果不可以，我们就跳过它，继续考虑下一个元素。

为了避免重复的组合，我们需要保证每次递归时，只考虑当前元素及其之后的元素，而不是从头开始。这样，我们就可以保证每个元素只出现在它之前的元素后面，而不会出现在它之前的元素前面。

为了方便回溯，我们使用一个链表来存储当前的组合，每次加入一个元素时，就把它放到链表的末尾，每次回溯时，就把它从链表的末尾移除。

当目标和为零时，说明我们找到了一个有效的组合，我们就把当前的链表转换成一个数组，并加入到结果列表中。当目标和小于零时，或者数组索引越界时，说明我们已经无法找到有效的组合了，我们就直接返回。

这样，通过不断地递归和回溯，我们就可以找出所有可能的组合。

代码的思路可以分为以下几个步骤：

定义两个全局变量，一个是 res，用来存储最终的结果列表，一个是 tmp，用来存储当前的组合链表。
定义一个公共方法 combinationSum，接收两个参数，一个是 candidates 数组，一个是 target 目标和。在这个方法中，我们初始化 res 和 tmp 为空列表，然后调用一个私有方法 dfs，传入 candidates 数组，target 目标和，和 0 作为初始的数组索引。最后返回 res 作为结果。
定义一个私有方法 dfs，接收三个参数，一个是 candidates 数组，一个是 target 目标和，一个是 idx 数组索引。在这个方法中，我们进行以下判断和操作：
- 如果 target 等于 0，说明我们找到了一个有效的组合，我们就把 tmp 链表转换成数组，并加入到 res 列表中，然后返回。
- 如果 idx 大于等于 candidates 数组的长度，或者 target 小于 0，说明我们已经无法找到有效的组合了，我们就直接返回。
- 否则，我们先调用 dfs 方法，传入 candidates 数组，target 目标和，和 idx + 1 作为下一个数组索引。这样相当于跳过当前的元素，不加入到当前的组合中。
- 然后，我们把当前的元素 candidates [idx] 加入到 tmp 链表的末尾，再调用 dfs 方法，传入 candidates 数组，target - candidates [idx] 作为新的目标和，和 idx 作为不变的数组索引。这样相当于选取当前的元素，并继续寻找剩余的目标和。
- 最后，我们把 tmp 链表的最后一个元素移除，相当于回溯到上一层状态。

这样，通过不断地递归和回溯，我们就可以找出所有可能的组合。

解释一下第三条。😊

第三条是定义一个私有方法 dfs，接收三个参数，一个是 candidates 数组，一个是 target 目标和，一个是 idx 数组索引。在这个方法中，我们进行以下判断和操作：

这个方法的作用是使用回溯算法，从数组的第 idx 个元素开始，寻找所有可能的组合，使得它们的和等于 target。

我们需要考虑两种情况，一种是选取当前的元素，一种是跳过当前的元素。

为了避免重复的组合，我们需要保证每次递归时，只考虑当前元素及其之后的元素，而不是从头开始。

具体的操作如下：

如果 target 等于 0，说明我们找到了一个有效的组合，我们就把 tmp 链表转换成数组，并加入到 res 列表中，然后返回。这是递归的终止条件。
如果 idx 大于等于 candidates 数组的长度，或者 target 小于 0，说明我们已经无法找到有效的组合了，我们就直接返回。这也是递归的终止条件。
否则，我们先调用 dfs 方法，传入 candidates 数组，target 目标和，和 idx + 1 作为下一个数组索引。这样相当于跳过当前的元素，不加入到当前的组合中。这是递归的一种分支。
然后，我们把当前的元素 candidates [idx] 加入到 tmp 链表的末尾，再调用 dfs 方法，传入 candidates 数组，target - candidates [idx] 作为新的目标和，和 idx 作为不变的数组索引。这样相当于选取当前的元素，并继续寻找剩余的目标和。这是递归的另一种分支。
最后，我们把 tmp 链表的最后一个元素移除，相当于回溯到上一层状态。这是为了恢复之前的选择，以便进行下一次选择。

这样，通过不断地递归和回溯，我们就可以找出所有可能的组合。

具体实现

class Solution {
    List<List<Integer>> res; // 存储结果
    LinkedList<Integer> tmp; // 存储当前组合
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        res = new ArrayList<>(); // 初始化结果列表
        tmp = new LinkedList<>(); // 初始化当前组合
        dfs(candidates, target, 0); // 从数组第一个元素开始回溯
        return res; // 返回结果
    }
    private void dfs(int[] candidates, int target, int idx) {
        if (target == 0) { // 如果目标和为零，说明找到了一个有效的组合
            res.add(new ArrayList<>(tmp)); // 将当前组合加入到结果列表中
            return; // 返回
        }
        if (idx >= candidates.length || target < 0) { // 如果数组索引越界，或者目标和小于零，说明当前组合无效
            return; // 返回
        }
        // 跳过当前元素
        dfs(candidates, target, idx + 1); 
        // 选取当前元素
        tmp.add(candidates[idx]); 
        dfs(candidates, target - candidates[idx], idx); // 继续寻找剩余的目标和
        tmp.removeLast(); // 回溯，移除当前元素
    }
}