Leetcode39 Combination Sum

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]

Solution1

• 这是一道典型的回溯题。每次都尝试加入一个数，若当前得到的和还不够，则继续加入该数，直到和大于target，如果和等于target则得到一个解，若大于则回溯一个数，然后尝试数组中的下一个数。

import java.util.Arrays;import java.util.ArrayList;import java.util.List;public class Solution {    public List<List<Integer>> combinationSum(int[] candidates, int target) {        Arrays.sort(candidates);        List<List<Integer>> result = new ArrayList<List<Integer>>();        help(candidates,0,target,result,new ArrayList<Integer>());        return result;    }    public void help(int[] candidates,int index,int target,List<List<Integer>> result,List<Integer> item){        if(target==0){            result.add(item);            return;        }        if(target<0||index>=candidates.length) return;        for(int i=index;i<candidates.length;i++){            if(target<candidates[i]) return;//因为数组已经排过序，所以后面的数都没必要再去遍历            List<Integer> temp = new ArrayList<Integer>(item);            temp.add(candidates[i]);            help(candidates,i,target-candidates[i],result,temp);        }            }}

Solution2

• 理论上，任何递归解法都可以用迭代解法来实现，而迭代一般要借用栈的实现，这里就是用一个栈来记录存入数组中的下标。

import java.util.Arrays;import java.util.ArrayList;import java.util.List;import java.util.Stack;public class Solution {    public List<List<Integer>> combinationSum(int[] candidates, int target) {        Arrays.sort(candidates);        List<List<Integer>> result = new ArrayList<List<Integer>>();        List<Integer> item = new ArrayList<Integer>();        Stack<Integer> indexes = new Stack<Integer>();        for(int i=0,sum=0;i<candidates.length||!indexes.empty();){             if(i<candidates.length){                while(sum+candidates[i]<target){                    sum += candidates[i];                    indexes.push(i);                    item.add(candidates[i]);                }                if(sum+candidates[i]==target){                    List<Integer> item1 = new ArrayList<Integer>(item);                    item1.add(candidates[i]);                    result.add(item1);                }            }            if(indexes.empty()) return result;            i = indexes.pop();            sum -= candidates[i++];            item.remove(item.size()-1);        }        return result;          }}

Solution3

• 这道题实际和找零钱问题本质上是一样的，而找零钱是一个典型的动态规划的解法，因此本题可以用动态规划来解

import java.util.Arrays;import java.util.ArrayList;import java.util.HashMap;public class Solution {    public List<List<Integer>> combinationSum(int[] candidates, int target) {        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();        if(candidates.length==0) return result;        result.add(new ArrayList<Integer>());        HashMap<Integer,List<List<Integer>>> dp = new HashMap<Integer,List<List<Integer>>>();        dp.put(0,result);        Arrays.sort(candidates);        for(int sum=candidates[0];sum<=target;sum++){            result = new ArrayList<List<Integer>>();            for(int i=candidates.length-1;i>=0;i--){                if(!dp.containsKey(sum-candidates[i])) continue;                for(List<Integer> item:dp.get(sum-candidates[i])){                    if(item.size()>0&&candidates[i]<item.get(item.size()-1)) continue;//只将升序的序列加入，解决序列重复问题                    ArrayList<Integer> temp = new ArrayList<Integer>(item);                    temp.add(candidates[i]);                    result.add(temp);                }                if(i == candidates.length-1) dp.remove(sum-candidates[i]);//将不再需要的去掉，更节省空间            }            if(!result.isEmpty()) dp.put(sum,result);        }        return dp.get(target)==null?new ArrayList<List<Integer>>():dp.get(target);    }}