#39 Combination Sum

Description

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

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

Note:
All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.

Examples

Example 1:

Input: candidates = [2,3,6,7], target = 7,
A solution set is: [[7],[2,2,3]]

Example 2:

Input: candidates = [2,3,5], target = 8,
A solution set is: [[2,2,2,2],[2,3,3],[3,5]]

解题思路

用了个暴力深搜

对输入的数组做了个排序，这样可以通过 target 和 cand[index] 的值的大小关系进行剪枝操作

class Solution {
    public void comb(Set<List<Integer>> answer, List<Integer> c, List<Integer> currList, int target, int index){
        if(target == 0){
            answer.add(new ArrayList<>(currList));
            return;
        }
        if(target < 0 || target < c.get(index))
            return;
        int i;
        for(i = index; i < c.size(); i++){
            int temp = c.get(i);
            currList.add(temp);
            comb(answer, c, currList, target - temp, i);
            currList.remove(currList.size() - 1);
        }
    }
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Set<List<Integer>> answer = new HashSet<>();
        int i;
        List<Integer> cand = new ArrayList<>();
        List<Integer> curr = new ArrayList<>();
        for(i = 0; i < candidates.length; i++)
            cand.add(candidates[i]);
        Collections.sort(cand);
        comb(answer, cand, curr, target, 0);
        return new ArrayList<>(answer);
    }
}

round 2

第二次再做的时候，思路相同，改动了一下传入的参数，但是时间短了很多
感觉是服务器连接问题，这次的代码更简洁，所以还是放上来了

class Solution {
    List<List<Integer>> finalAnswer = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<Integer> answer = new ArrayList<>();
        
        dfs(answer, candidates, 0, target);
        return finalAnswer;
    }
    
    public void dfs(List<Integer> answer, int[] candidates, int start, int target){
        if(target < 0)
            return;
        if(target == 0){
            finalAnswer.add(answer);
            return;
        }
        
        for(int i = start; i < candidates.length; i++){
            if (candidates[i] > target)
                break;
            List<Integer> temp = new ArrayList<>(answer);
            temp.add(candidates[i]);
            dfs(temp, candidates, i, target - candidates[i]);
        }
        return;
    }
}