leetcode-40. 组合总和 II

40. 组合总和 II

题目

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

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

注意：解集不能包含重复的组合。

示例1

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例2

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示

• 1 <= candidates.length <= 100
• 1 <= candidates[i] <= 50
• 1 <= target <= 30

分析

方法一：动态规划首先对数组进行排序。如果只需要记录个数而不需要记录组合的话，动态规划非常适合本题。记录组合的话，需要一些改动。首先dp格式为List<Set<List>>，其中第一个List为二维数组优化后的一维数组，Set<List>为每个矩阵内的元素dp[i][j]（本来没有[i]，但用[i]即二维数组表示比较方便），使用Set来避免List重复，每个dp[i][j]::Set<List>表示candidates[0:i]前i个元素和为j（j∈[0,target]）的组合。

对于dp[i][j]，如果dp[i-1][j-candidates[i]]，即上一行前candidates[i]的size大于0，将上一回合的组合末尾加上candidates[i]后添加到dp[i][j]中，表示了dp[i][j]所有的组合数。

最后返回最终结果即可。

**方法二：回溯法（超时）**首先对数组进行排序。使用Set<List>存储结果来避免组合重复。同时，为了避免有些值被重复运算，先在track中添加索引，回溯遍历时从索引末尾开始遍历，保证[1,2,5]和[1,5,2]这种情况的发生。但是由于没有解决当重复元素太多时，重复计算太多次的情况，导致部分极端用例没过去。如下，通过率为172/176。但是对于正常情况，该算法性能较好。

方法三：回溯法首先对数组进行排序。使用正常的回溯算法，但是使用两个条件进行剪枝。

1. 在for循环中，使用if(cur_count+candidates[i]>target) break。因为数组有序，所以当当前元素的和大于target时，接下来的元素都不满足，直接结束循环。
2. 在for循环中，使用if(i>position && candidates[i]==candidates[i-1]) continue防止出现重复数组（因为有序，所以相同的元素都在一块）。当i>position时，track加入candidates[i]和加入candidates[i-1]的效果是相同的。当在一个层级时，

代码

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<Set<List<Integer>>> list = new ArrayList<>();
        for(int i=0;i<target;i++) list.add(new HashSet<List<Integer>>());
        for(int i=0;i<candidates.length;i++){
            for(int j=target-1;j>=candidates[i];j--){
                if(list.get(j-candidates[i]).size()>0){
                    for(List<Integer> temp:list.get(j-candidates[i])){
                        List<Integer> out = new ArrayList<>(temp);
                        out.add(candidates[i]);
                        list.get(j).add(out);
                    }
                }
            }
            if(target>=candidates[i]) list.get(candidates[i]-1).add(new ArrayList<>(Arrays.asList(candidates[i])));
        }
        
        return new ArrayList<>(list.get(target-1));
    }
}

class Solution {
    public Set<List<Integer>> result = new HashSet<>();
    public List<Integer> track = new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backyard(candidates, target, 0, 0);
        return new ArrayList<>(result);
    }

    public void backyard(int[] candidates, int target, int index, int cur_count){
        if(cur_count>target) return;

        if(cur_count==target) {
            List<Integer> temp = new ArrayList<>(track);
            for(int i=0;i<temp.size();i++) temp.set(i, candidates[temp.get(i)]);
            result.add(temp);
        }
        if(track.size()>0) index = Math.max(index, track.get(track.size()-1));
        for(int i=index;i<candidates.length;i++){
            // if(track.size()>0 && i<=track.get(track.size()-1)) continue;
            track.add(i);
            backyard(candidates, target, i+1, cur_count+candidates[i]);
            track.remove(track.size()-1);
        }
    }
}

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

    public void backtrack(int[] candidates, int position, int target, int cur_count){
        if(cur_count==target) {
            result.add(new ArrayList<>(track));
            return;
        }
        if(candidates.length==position || cur_count>target) return;

        for(int i=position;i<candidates.length;i++){
            if(cur_count+candidates[i]>target) break;
            if(i>position && candidates[i]==candidates[i-1]) continue;
            track.add(candidates[i]);
            backtrack(candidates, i+1, target, cur_count+candidates[i]);
            track.remove(track.size()-1);
            
        }
    }
}

结果

时间超过%

内存超过%