LeetCode 热题 HOT 100 Java题解——39. 组合总和

39. 组合总和

题目：
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。

示例：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

回溯+剪枝

典型的回溯题目，因为每次都可以重复选择，因此每个循环里的递归$start$值不需要$+1$，最简单的，不考虑剪枝的版本：

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    public void backtrack(int[] candidates, int start, int target){
        if(target < 0) return;
        if(target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start; i < candidates.length; i++) {
            path.add(candidates[i]);
            backtrack(candidates, i, target - candidates[i]);
            path.remove(path.size() - 1);
        }
    }
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtrack(candidates, 0, target);
        return res;
    }
}

因为回溯复杂度比较高，因此想剪枝的话可以先进行一个排序，如果当前$target$减掉一个小的值已经小于$0$了，就不需要继续进行下去了。以下是简单的剪枝修改后的代码：

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    public void backtrack(int[] candidates, int start, int target){
        if(target < 0) return;
        if(target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start; i < candidates.length; i++) {
            if(target - candidates[i] < 0) break;
            path.add(candidates[i]);
            backtrack(candidates, i, target - candidates[i]);
            path.remove(path.size() - 1);
        }
    }
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates, 0, target);
        return res;
    }
}

剪枝效果很明显。

复杂度分析

• 时间复杂度：$O(?)$

  比较难给出，官方答案$O(n\times 2^n)$。

• 空间复杂度：$O(target)$

  最差情况下都是$1$，需要递归栈深度为$O(target)$。