LeetCode - Combination Sum

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]

这道题是典型的递归求解，对于这种要求所有解的题都可以用递归做。
题目中要求返回的解中的值是递增的，因此应该先对数组排序。另外，要求不能有重复解，由于每一层递归对应解中的一个位置，因此每层递归中(即对应的解的位置)不能有相同的值，因此用一个while循环来避免这种重复。还有一种重复是如[1,2]和[2,1]这种的，就是每个位置的值不一样，但其实只是顺序不同，本质是一样的。这种重复的情况是用确定一个位置后，它后面的位置上的数都必须只找比它大的数来解决的。因此helper有个start参数，来规定只再上一个数本身以及它后面的数中来寻找后面的位置的解。

代码如下：

public class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> rst = new LinkedList<List<Integer>>();
if(candidates==null || candidates.length==0) return rst;
Arrays.sort(candidates);  //保证解中的数是递增排列的
List<Integer> solution = new LinkedList<Integer>();

helper(candidates, rst, solution, target, 0);

return rst;
}

public void helper(int[] candidates, List<List<Integer>> rst, List<Integer> solution, int target, int start){
if(target==0){
rst.add(new LinkedList<Integer>(solution));
return;
}
if(target<0) return;
for(int i=start; i<candidates.length; i++){    //start参数规定后面位置上的解不能再用在当前位置之前的数，避免[1,2], [2,1]这种重复
solution.add(candidates[i]);
helper(candidates, rst, solution, target-candidates[i], i);
solution.remove(solution.size()-1);
while(i<candidates.length-1 && candidates[i+1]==candidates[i]) i++;   //一个位置上不能有相同的值
}
}
}

时间复杂度应该是NP的，第一层递归O(n)，第二层O(n*(n-1))...以此类推，因此是n+n^2+n^3+....,因此时间复杂度是exponential的。

空间复杂度是调用递归的次数，应该是n+n(n-1)+.....，空间复杂度也是exponential的