【力扣算法】40-组合总和II

最新推荐文章于 2022-10-25 16:15:12 发布

原创最新推荐文章于 2022-10-25 16:15:12 发布 · 554 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #java #算法 #回溯法

java 专栏收录该内容

180 篇文章

订阅专栏

本文探讨了在给定数组和目标数的情况下，如何寻找所有可能的组合使数字和为目标数，同时确保每个数字在组合中仅使用一次且避免重复组合。通过使用回溯算法，并在遍历过程中加入条件判断实现有效去重，最终优化后的解决方案显著提升了执行效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

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

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

题解

无官方题解

感想

参考上一题，再使用HashSet去重，题目还是很容易做完的。

执行用时 : 19 ms, 在Combination Sum II的Java提交中击败了50.69% 的用户

内存消耗 : 39.9 MB, 在Combination Sum II的Java提交中击败了75.52% 的用户

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        HashSet<List<Integer>> res = new HashSet<>();//这里改用set来去重
        Arrays.sort(candidates);
        backtrack(candidates, target, res, 0, new ArrayList<>());
        return new ArrayList<>(res);
    }

    private void backtrack(int[] candidates, int target, HashSet<List<Integer>> res, int i, ArrayList<Integer> tmp_list) {
        if (target < 0) return;
        if (target == 0) {
            res.add(new ArrayList<>(tmp_list));
            return;
        }
        for (int start = i; start < candidates.length; start++) {
            if (target < candidates[start]) break;
            else{
                tmp_list.add(candidates[start]);
                backtrack(candidates, target - candidates[start], res, start+1, tmp_list);//这里start改为start+1，因为每个数字在每个组合中只能使用一次
                tmp_list.remove(tmp_list.size() - 1);
            }
        }
    }
}

用HashSet效率达不到最高，就试着想怎么去优化。后来发现原来的思路是可行的：在backtrack内部for循环直接去重——当时之所以写不出是因为理解错了i和start……（毕竟39题是参考的别人代码，有些变量的作用一旦想当然了就会搞错）

修改后速度显著提升。

执行用时 : 4 ms, 在Combination Sum II的Java提交中击败了98.93% 的用户

内存消耗 : 35.5 MB, 在Combination Sum II的Java提交中击败了99.74% 的用户

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, res, 0, new ArrayList<>());
        return res;
    }

    private void backtrack(int[] candidates, int target, List<List<Integer>> res, int i, ArrayList<Integer> tmp_list) {
        if (target < 0) return;
        if (target == 0) {
            res.add(new ArrayList<>(tmp_list));
            return;
        }
        for (int start = i; start < candidates.length; start++) {
            if(start>i && candidates[start-1]==candidates[start] ) continue;//这句话去重
            if (target < candidates[start]) break;
            else{
                tmp_list.add(candidates[start]);
                backtrack(candidates, target - candidates[start], res, start+1, tmp_list);//这里start+1一样保证candidates每个数只用一次
                tmp_list.remove(tmp_list.size() - 1);
            }
        }
    }
}