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 <= 1001 <= candidates[i] <= 501 <= target <= 30
分析
方法一：动态规划首先对数组进行排序。如果只需要记录个数而不需要记录组合的话，动态规划非常适合本题。记录组合的话，需要一些改动。首先dp格式为List为每个矩阵内的元素dp[i][j]（本来没有[i]，但用[i]即二维数组表示比较方便），使用Set来避免List重复，每个dp[i][j]::Set
表示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存储结果来避免组合重复。同时，为了避免有些值被重复运算，先在track中添加索引，回溯遍历时从索引末尾开始遍历，保证[1,2,5]和[1,5,2]这种情况的发生。但是由于没有解决当重复元素太多时，重复计算太多次的情况，导致部分极端用例没过去。如下，通过率为172/176。但是对于正常情况，该算法性能较好。
方法三：回溯法首先对数组进行排序。使用正常的回溯算法，但是使用两个条件进行剪枝。
- 在for循环中，使用
if(cur_count+candidates[i]>target) break。因为数组有序，所以当当前元素的和大于target时，接下来的元素都不满足，直接结束循环。 - 在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);
}
}
}
结果
时间超过%
内存超过%