Combination Sum Java

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] 

 Idea: same idea as Combination that

    use Loop Recursion to handle sub problem to obtain a list of
    Combinations Sum equal to target. beside, since there are duplicated allow,
    we need to skip recursion step if there is duplicated elements exist
  Remember to sort candidates Array first before the recursion
    Combinations Sum:
    Candidates: set of numbers
    target: target minus elements from set of "candidates" , and when target==0,
            we find combination satisfied requirement
    last: last selection, start from 0 & increment as i each time
    curr: a list containing current combination
    res: result of list contain all combinations
    Do forget to check the case of target less than 0, otherwise will throw exception

public class Solution {
    public  ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
         if(candidates.length==0 || target==0) return res;
        Arrays.sort(candidates);
        helper(candidates,target,0,res,new ArrayList<Integer>());
        return res;
    }
    private  void helper(int[] candidates,int target,int last,
                               ArrayList<ArrayList<Integer>> res, ArrayList<Integer> curr){
        if (target<0) return;
        if(target==0){
            res.add(new ArrayList<Integer>(curr));
                  return;
        }
        for(int i=last;i<candidates.length;i++){
            if(i>0 && candidates[i]==candidates[i-1]){
                continue;
            }
            curr.add(candidates[i]);
            helper(candidates,target-candidates[i],i,res,curr);
            curr.remove(curr.size()-1);
        }
    }
}