leetcode 40. Combination Sum II

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:
All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.
For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
A solution set is:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]

图示：
可以看到和上一道题目的不同就是拿第i个候选数字进行尝试的时候，子问题就要把这个候选数字减少一个，
为了保证单个结果中的数字不递减，采用的方法是子问题从当前问题的序号开始搜索，那么这个问题中，2367拿6尝试 子问题中候选变成237 应该从7开始尝试 也是序号为3 所以仍然是从i开始尝试
还有就是子问题结束时应该把所尝试的数字（6）补回来 才能在父问题中尝试7

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);
        List<Integer> listOfCandidates =  new ArrayList<Integer>();
        for(int temp:candidates) listOfCandidates.add(temp);
        backTracking(listOfCandidates, target,0);
        return results;
    }

    public void  backTracking(List<Integer> candidates,int target,int from){
        if(target == 0) {
            List<Integer> copy = new LinkedList<Integer>();
            copy.addAll(result);
            results.add(copy);
        }
        else{
            if(candidates.get(0) > target)
                return ;
            else{
                for(int i = from;i < candidates.size() && candidates.get(0) <= target;i++){
                    result.push(candidates.get(i));
                    backTracking(candidates,target-candidates.remove(i),i);
                    candidates.add(i, result.pop());
                }
            }
        }
    }

改了改就有了第一版：
因为候选集合不在父问题与子问题中要变 所以再用数组就不合适 改成了用LinkedList 然后就是分治递归的这里：
result.push(candidates.get(i));
backTracking(candidates,target-candidates.remove(i),i);
candidates.add(i, result.pop());
非常完美
然后有问题：new int[]{10, 1, 2, 7, 6, 1, 5}, 8的结果是：
116
125
17
125
17
26
看到有重复的
上一道题目候选者没有重复的 所以只要路径注意递增就可以直接出结果
这个题目 1，1，2，5，6，7，10本身1，1是重复的 怎么避免呢？
好吧看了大神的 这个也没有在这里避免 是在出结果的时候去重复了 那我也这样做吧>_<

public class Solution {
    Stack<Integer> result = new Stack<Integer>();
    List<List<Integer>> results = new ArrayList<List<Integer>>();

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<Integer> listOfCandidates =  new LinkedList<Integer>();
        for(int temp:candidates) listOfCandidates.add(temp);
        backTracking(listOfCandidates, target,0);
        Set<List<Integer>> setOfResults = new HashSet<List<Integer>>();
        results.forEach(a->setOfResults.add(a));
        results.clear();
        setOfResults.forEach(a->results.add(a));
        return results;
    }

    public void  backTracking(List<Integer> candidates,int target,int from){
        if(target == 0) {
            List<Integer> copy = new ArrayList<Integer>();
            copy.addAll(result);
            results.add(copy);
        }
        else{
            if(candidates.size() == 0 || candidates.get(0) > target)
                return ;
            else{
                for(int i = from;i < candidates.size() && candidates.get(0) <= target;i++){
                    result.push(candidates.get(i));
                    backTracking(candidates,target-candidates.remove(i),i);
                    candidates.add(i, result.pop());
                }
            }
        }
    }
}

这个去重写的好别扭。。先把list里的元素都放到set里 list清空 再放回来。。
话说不知道有没有什么好方法啊。。。
list没有元素去重的方法吗。。是哪一个啊。。。>_<