Combination Sum | && || Leetcode

https://leetcode.com/problems/combination-sum/

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where
the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

All numbers (including target) will be positive integers.
Elements in a combination (a1, a2,
… , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤
… ≤ ak).
The solution set must not contain duplicate combinations.

For example, given candidate set 

2,3,6,7

 and target 

7

, 

A solution set is: 

[7]

 

[2, 2, 3]

 
这个题目其实就是经典回溯问题，但是就是有一个不太一样地方就是，这里每个数可以出现无限制次数，加入说每个数只出现一次就跟这道题一样啦：
http://blog.csdn.net/huruzun/article/details/21823343

递归调用时需要增加一个控制起始位置参数来使得每次还可以调用出现过的数

package combination_Sum;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

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

if(candidates == null || candidates.length == 0)
return result;

ArrayList<Integer> current = new ArrayList<Integer>();
Arrays.sort(candidates);

combinationSum(candidates, target, 0, current, result);

return result;
}

public static void combinationSum(int[] candidates, int target, int j, ArrayList<Integer> curr, List<List<Integer>> result){
if(target == 0){
// 这里一定要new起来一个新的拷贝
ArrayList<Integer> temp = new ArrayList<Integer>(curr);
result.add(temp);
return;
}
// 这里 参数 j 用来控制同一个数可以出现多次
for(int i=j; i<candidates.length; i++){
if(target < candidates[i])
return;

curr.add(candidates[i]);
combinationSum(candidates, target - candidates[i], i, curr, result);
curr.remove(curr.size()-1);
}
}
public static void main(String[] args){
int []candidates = {2,3,6,7};
System.out.println(combinationSum(candidates,7));
}
}

接着是这道题的变形

https://leetcode.com/problems/combination-sum-ii/

与前面区别就是每个数字只能使用一次，而且要避免重复的答案，最简单就是在最终答案处进行判重，但是这样效率不高，在对数组排序后，如果某个数字后面又重复的就需要跳过。

public class Solution {
public static List<List<Integer>> combinationSum2(int[] candidates,
int target) {
List<List<Integer>> result = new ArrayList<>();

if (candidates == null || candidates.length == 0)
return result;

ArrayList<Integer> current = new ArrayList<Integer>();
Arrays.sort(candidates);

combinationSum(candidates, target, 0, current, result);

return result;
}

public static void combinationSum(int[] candidates, int target, int i,
ArrayList<Integer> curr, List<List<Integer>> result) {
if (target == 0) {
// 这里一定要new起来一个新的拷贝

ArrayList<Integer> temp = new ArrayList<Integer>(curr);

result.add(temp);
return;
}
for (; i < candidates.length; i++) {
if (target < candidates[i])
return;

curr.add(candidates[i]);
combinationSum(candidates, target - candidates[i], i+1, curr, result);
curr.remove(curr.size() - 1);
// 这里重复的数字要跳过
while(i< candidates.length-1 && candidates[i] == candidates[i+1]){
i++;
}
}
}

}