leetcode--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] 

 

One simple solution:

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer> > result = new ArrayList<List<Integer> >();
		Arrays.sort(candidates);
		Deque<List<Integer> > combinations = new LinkedList<List<Integer> >();
		List<Integer> startList = new ArrayList<Integer>();
		combinations.add(startList);
		Deque<Integer> sums = new LinkedList<Integer>();
		Deque<Integer> lastIndices = new LinkedList<Integer>();
		sums.add(0);
		lastIndices.add(0);
		int length = candidates.length;
		while(combinations.peek() != null){
			List<Integer> aList = combinations.poll();
			int sum = sums.poll();
			int lastIndex = lastIndices.poll();
			for(int i = lastIndex; i < length; ++i){
				if(sum + candidates[i] < target){
					List<Integer> newList = new ArrayList<Integer>();
					newList.addAll(aList);
					newList.add(candidates[i]);
					combinations.add(newList);
					sums.add(sum + candidates[i]);
					lastIndices.add(i);
				}
				else if(sum + candidates[i] == target){
					aList.add(candidates[i]);
					result.add(aList);
				}
				else
					break;
			}
		}
		return result;    
    }
}

　　

 Another solution:

public class Solution {
    public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {
  　　   ArrayList<ArrayList<Integer> > result = new ArrayList<ArrayList<Integer> >();
        ArrayList<ArrayList<Integer> > temp = new ArrayList<ArrayList<Integer> >();
        ArrayList<IndexSum> sum = new ArrayList<IndexSum>();
        Arrays.sort(candidates);
        if(candidates.length > 0){
            for(int i = 0; i < candidates.length; ++i){
                if(candidates[i] <= target){
                    ArrayList<Integer> nodes = new ArrayList<Integer>();
                    nodes.add(candidates[i]);
                    temp.add(nodes);
                    sum.add(new IndexSum(i, candidates[i]));                
                }
                else
                    break;;                
            }
            while(!temp.isEmpty()){
                ArrayList<Integer> aNode = temp.remove(0);
                IndexSum aPair = sum.remove(0);
                if(aPair.sum == target)
                    result.add(aNode);
                if(aPair.sum < target){
                    for(int i = aPair.index; i < candidates.length; ++i){
                        if(aPair.sum + candidates[i] < target){
                            ArrayList<Integer> newNode = new ArrayList<Integer>();
                            newNode.addAll(aNode);
                            newNode.add(candidates[i]);
                            temp.add(newNode);
                            IndexSum newPair = new IndexSum(i, aPair.sum + candidates[i]);
                            sum.add(newPair);
                        }
                        else if(aPair.sum + candidates[i] == target){
                            aNode.add(candidates[i]);
                            result.add(aNode);
                        }
                        else
                            break;
                    }
                }
            }        
        }
        return result;        
    }
}

class IndexSum{
    int index;
    int sum;
    IndexSum(int i, int s){ index = i; sum = s;}
}