Leetcode: Combination Sum

已知数组C和目标值T，要求在C中找出所有独特的组合使其和为T，C中所有的数和T都为正整数

39. Combination Sum

Note：

1. C中无重复

2. 同一个数在组合中可以出现任意次

比如C=[2, 3, 6, 7] ，T=7, 解为

[
[7],
[2, 2, 3]
]

解法

简单回溯

public class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> result = new ArrayList<>();
findCombination(result, new ArrayList<Integer>(), candidates,  target, 0);
return result;
}

public void findCombination(List<List<Integer>> result, List<Integer> combinations, int[] candidates, int remain, int start){
if(remain < 0) return;
if (remain == 0){
result.add(new ArrayList<Integer>(combinations));
}
//每递归一层for循环确定一个位置的数，如第k层for循环就确定第k个数
for(int i = start; i < candidates.length; i++) {
combinations.add(candidates[i]);
findCombination(result, combinations, candidates, remain - candidates[i], i);//start置为i表明允许多次使用同一个数
combinations.remove(combinations.size()-1);
}
}
}

简单回溯 + 排序优化

public class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> result = new ArrayList<>();
//排序优化
Arrays.sort(candidates);
findCombination(result, new ArrayList<Integer>(), candidates,  target, 0);
return result;
}

public void findCombination(List<List<Integer>> result, List<Integer> combinations, int[] candidates, int remain, int start){
if(remain < 0) return;
if (remain == 0){
result.add(new ArrayList<Integer>(combinations));
}
//每递归一层for循环确定一个位置的数，如第k层for循环就确定第k个数
for(int i = start; i < candidates.length && candidates[i] <= remain; i++) { //当c[i]大于remain，则i以及i以后的都不会符合
combinations.add(candidates[i]);
findCombination(result, combinations, candidates, remain - candidates[i], i);
combinations.remove(combinations.size()-1);
}
}
}

40. Combination Sum II

Note：

1. C中可能有重复值

2. C中的每一个数在组合中只能出现一次

如C = [10, 1, 2, 7, 6, 1, 5], T = 8, 解为

[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]

解法

利用排序去重

public class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(candidates);//先排序以便去重
findCombination(result, new ArrayList<Integer>(), candidates,  target, 0);
return result;
}

public void findCombination(List<List<Integer>> result, List<Integer> combinations, int[] candidates, int remain, int start){
if(remain < 0) return;
if (remain == 0){
result.add(new ArrayList<Integer>(combinations));
}
//每层for循环确定一个位置的数，如第k层确定第k个数
for(int i = start; i < candidates.length && candidates[i] <= remain; i++) {
//保证当前位置不会重复使用相等的数，如1，1，2，5，6，7，10，位置0只可能使用第一个1，位置1只可能使用第二个1
if(i > start && candidates[i] == candidates[i-1]) continue;
combinations.add(candidates[i]);
findCombination(result, combinations, candidates, remain - candidates[i], i + 1);
combinations.remove(combinations.size()-1);
}
}
}

377. Combination Sum IV

只需求出所有可能组合的数量

Note：

1. C中无重复

2. C中的每一个数在组合中可出现任意次

如C = [1, 2, 3], T = 4, 则

可能的所有组合为
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

故结果为7.

解法

递推公式：comb[target] = sum(comb[target - nums[i]]) （0 <= i < nums.length && target >= nums[i]），comb[0] = 1。

递归，会超时，因为存在的大量重复计算（调用）

public class Solution {
public int combinationSum4(int[] nums, int target) {
if (target == 0) return 1;
int res = 0;
for (int i = 0; i < nums.length; i++) {
if (target >= nums[i]) {
res += combinationSum4(nums, target - nums[i]);
}
}
return res;
}
}

动态规划（从dp[0]到dp[target]都要计算，其中大部分可能都是不必要的）

public class Solution {
public int combinationSum4(int[] nums, int target) {
int [] dp = new int[target + 1];
dp[0] = 1;
for(int i = 1; i <= target; i++){
for(int j = 0; j < nums.length; j++){
dp[i] += (i - nums[j]) < 0 ? 0 : dp[i-nums[j]];
}
}
return dp[target];
}
}

动态规划+递归(可以将dp[]看作缓存），避免了重复计算和不必要的计算

public class Solution {
public int combinationSum4(int[] nums, int target) {
int[] dp = new int[target + 1];
Arrays.fill(dp, -1);
dp[0] = 1;
return helper(nums, target, dp);
}

private int helper(int[] nums, int target, int[] dp) {
//已计算过直接返回
if (dp[target] != -1)   return dp[target];

int res = 0;
for (int i = 0; i < nums.length; i++) {
if (target >= nums[i]) {
res += helper(nums, target - nums[i], dp);
}
}
dp[target] = res;
return res;
}
}