leetcode 39. Combination Sum

“C++程序员觉得内存管理太重要了，所以一定要自己进行管理；Java/C#程序员觉得内存管理太重要了，所以一定不能自己去管理。”
简直人生态度。
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]
]
candidate numbers (C)：候选者数字集合
target：目标和
每个候选数字可使用多次 既然这样原集合重不重复就不重要了 用个set就可以了
刷leetcode之后 我发现学会的很重要的一件事：第一念头不是怎么解决问题，而是怎么把大问题转化成小问题，所有，我是说几乎所有，都可以用分治法，比如这道：

非常好 画了十分钟的图
画的过程中思路就会很清晰：

对set排序：递归方法：        如果target == 0 有解 结束 当前解存入solution set里面        否则：            如果 最小候选数字 < target 无解 结束            否则：                遍历小于target的候选者 去做子问题的递归 

贴一个超时的代码：

Stack<Integer> result = new Stack<Integer>();    Set<Stack<Integer>> results = new HashSet<Stack<Integer>>();    public List<List<Integer>> combinationSum(int[] candidates, int target) {        List<List<Integer>> listResults = new ArrayList<List<Integer>>();        Set<List<Integer>> setResults = new HashSet<List<Integer>>();        Arrays.sort(candidates);        backTracking(candidates, target);        for(Stack<Integer> stackResult: results){            List<Integer> listResult = stackResult.subList(0, stackResult.size());            listResult.sort((a,b)->a-b);            setResults.add(listResult);        }        setResults.forEach(a->listResults.add(a));        return listResults;    }    public void  backTracking(int[] candidates,int target){        if(target == 0) {            Stack<Integer> copy = new Stack<Integer>();            copy.addAll(result);            results.add(copy);        }        else{            if(candidates[0] > target)                return ;            else{                for(int i = 0;i < candidates.length && candidates[0] <= target;i++){                    result.push(candidates[i]);                    backTracking(candidates, target-candidates[i]);                    result.pop();                }            }        }    }

分析一下原因：嗯 图里面232 和 223确实是一种拿法却算了两次
我觉得我应该回去找找皇后那道题做一下 好菜。。
为了避免这种重复 本来我的代码是不避免的 所以232 223都返回 然后再stack 转 list list再sort 再判重复。。。果然前期不想好后期好麻烦。。。
前期如果避免232 223的这种重复：
记录开始位置 23后面只尝试3及3以上的 也就是：回溯的时候记录当前结果路径最大值对应原排序数组的位置 只从该位置开始尝试

    Stack<Integer> result = new Stack<Integer>();    List<List<Integer>> results = new ArrayList<List<Integer>>();    public List<List<Integer>> combinationSum(int[] candidates, int target) {        Arrays.sort(candidates);        backTracking(candidates, target,0);        return results;    }    public void  backTracking(int[] candidates,int target,int from){        if(target == 0) {            List<Integer> copy = new ArrayList<Integer>();            copy.addAll(result);            results.add(copy);        }        else{            if(candidates[0] > target)                return ;            else{                for(int i = from;i < candidates.length && candidates[0] <= target;i++){                    result.push(candidates[i]);                    backTracking(candidates,target-candidates[i],i);                    result.pop();                }            }        }    }

终于写出了清楚的代码。。真的好菜。。。