39. Combination Sum

QUESTION

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

THOUGHTS

这道题完完全全是自己做出来的，略开心啊。不过还是调试了几次，利用的是回溯法加上dfs，这种做法应该很熟悉了，上课看书是理解不了的，只有多做题才能熟练掌握，不是提倡题海战术，只不过要多做题多思考多总结。给出一列数组，还有一个目标值，求所有和为目标值的集合。其实dfs就是一棵树啊，回溯只不过是借助这种结构进行剪枝。

CODE

public class Solution {    public List<List<Integer>> combinationSum(int[] candidates, int target) {        List<List<Integer>> res = new ArrayList<List<Integer>>();        if(candidates == null || candidates.length == 0)            return res;        List<Integer> temp = new ArrayList<Integer>();        Arrays.sort(candidates);        dfs(candidates,target,res,temp,0,0);        return res;    }    public void dfs(int[] nums,int target,List<List<Integer>> res,List<Integer> temp,int sum,int start){        if(sum == target){            sum = 0;            res.add(new ArrayList<Integer>(temp));            return;        }        else if(sum > target){            sum = 0;            return;        }        for(int i = start;i < nums.length;i++){            temp.add(nums[i]);            sum += nums[i];            dfs(nums,target,res,temp,sum,i);            sum -= nums[i];            temp.remove(temp.size() - 1);            while(i < nums.length - 1 && nums[i] == nums[i + 1])                i++;        }    }}

RESULT

runtime complexity is O(n^2),space complexity is O(1).

#

SPECIAL ATTENTION

• 在进行处理之前要先排序，因为可能会出现[3,2,2]的情况，答案给出的是[2,2,3]。
• 排序之后，也要考虑结果重复的情况，比如candidates[] = {2,2,3},target = 5;那么处出现[2,3],[2,3]俩个结果，最好是在处理的时候跳过这种情况。方法就是如果下一个处理数和本次处理数相同，则跳过。
• 还要考虑出现的一种情况是，结果中包含[2,2,3],[2,3,2],[3,2,2]为什么我们从小到大排序了还会出现这种情况呢？这是因为我们进行下次递归的时候不是从本节点以后开始的，而是又从0开始的，解决方法是，设置一个参数start，下次进行递归的时候从start开始，如果不允许结果重复，那么就从start + 1开始递归。很尴尬下道题就是这么出的，所以秒解。还需要注意的一点是当开始递归的时候，传递的参数不是start而是变成了i；

二刷

时间复杂度还是不会算，网上看到大神的答案也没看懂。
接下来就是复杂度分析。这道题的复杂度分析起来比较复杂….一刷的时候就没有好好思考。

首先我们假设这个数组candidate长为n， 在其中有m个元素小于target，假设T(n) = find(target)，那么我们可以根据程序得到以下分析结果:

DFS Level 0: 我们首次调用辅助函数， 这一层的count = 1
DFS Level 1: 这时候我们进入了辅助函数的for循环，在for循环里我们有一个pruning，当candidate[i] > target的时候，返回，所以这一层我们只对小于target的元素进行下一层DFS，如我们假设的，结果为m
DFS Level 2: 根据代码，我们上一层有一个target -= num，所以这一层的target其实都不一样。
假设我们对candidate中最小的元素min进行分析，这时候新的target1 = target - min，此时我们要继续计算在candidate数组中有多少元素小于新的target1，假设这个数目为m1，则在这一层我们要对小于target1的m1个数组进行下一层的DFS
假如我们考虑其他非min的元素来计算总的复杂度时， 这时候两层总共要进行1 + m(m1 + m2 + m3 + … + mn)次调用。
由于每一层的target和m都在改变，以我的水平比较难计算出一个漂亮的公式，那么我就想办法简化一下：
这里递归的最大深度是d= target / min， 就是最深我们可以到 target / min这么多层DFS
Branching factor b = m， m是candidate数组里小于等于target的distinct元素的个数。 其实这里多算了，每一层的m都在减少，而且是不规则减少
我们利用DFS公式可以算出这里的Time Complexty = O(md)， Space Complexity = O(m)
这只是一个worst case scenario， 更精确的计算还需要再花时间。

这是大神的csdn

二刷CODE

public class Solution {    public List<List<Integer>> combinationSum(int[] candidates, int target) {        List<List<Integer>> result = new ArrayList<List<Integer>>();        Arrays.sort(candidates);        List<Integer> temp = new ArrayList<Integer>();        if(candidates == null || candidates.length == 0)            return result;        sumHelper(result,temp,candidates,target,0);        return result;    }    public void sumHelper(List<List<Integer>> res,List<Integer> temp,int[] nums,int target,int index){        if(target == 0){            res.add(new ArrayList(temp));            return;        }        if(target < 0)        //这里之所以是return不是continue是因为数组是经过排序的        //如果当前的元素大于目标数，就没有必要再继续了，后面的肯定也大于            return;        for(int i = index;i < nums.length;i++){            if(nums[i] > target)                return;            //注意这里是i大于index            if(i > index && nums[i] == nums[i - 1])                continue;            temp.add(nums[i]);            target -= nums[i];            sumHelper(res,temp,nums,target,i);            temp.remove(temp.size() - 1);            target += nums[i];        }    }}