LeetCode #40 数组总和Ⅱ

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
[1,2,2],
[5]
]

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.List;

class Solution_40 {
     
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
     
        List<List<Integer>> res = new ArrayList<>();
        Deque<Integer> path = new ArrayDeque<>();
        if (candidates.length == 0) {
     
            return res;
        }
        // 数组正序排序, 想知道详情可以去百度 Arrays.sort用法
        Arrays.sort(candidates);
        dfs(candidates, 0, candidates.length, target, path, res);
        System.out.println(res);
        return res;
    }

    public void dfs(int[] candidates, int begin, int len, int target, Deque<Integer> path, List<List<Integer>> res) {
     
        if (target < 0) {
     
            return;
        }
        if (target == 0) {
     
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < len; i++) {
     
              // 大剪枝
              if (target - candidates[i] < 0) {
     
                break;
            }

            // 小剪枝  这里的去重思路是重点, 若想结果集中没有重复元素可以 i>0
            if ( i > begin && candidates[i] == candidates[i - 1]) {
     
                continue;
            }

            path.add(candidates[i]);
            dfs(candidates, i+1, len, target - candidates[i], path, res);
            path.removeLast();
        }
    }
	public static void main(String[] args) {
     
        int[] a = {
      2, 5, 2, 1,2 };
        Solution_40 s = new Solution_40();
        s.combinationSum2(a, 5);
    }
}

这个避免重复当思想是在是太重要了。 这个方法最重要的作用是，可以让同一层级，不出现相同的元素。即

              1
             / \
            2   2  这种情况不会发生 但是却允许了不同层级之间的重复即：
           /     \
         5       5
            例2
              1
             /
            2      这种情况确是允许的
           /
          2  
             为何会有这种神奇的效果呢？ 
       首先 cur-1 == cur 是用于判定当前元素是否和之前元素相同的语句。这个语句就能砍掉例1。

可是问题来了，如果把所有当前与之前一个元素相同的都砍掉，那么例二的情况也会消失。 因为当第二个2出现的时候，他就和前一个2相同了。
那么如何保留例2呢？ 那么就用cur > begin 来避免这种情况，你发现例1中的两个2是处在同一个层级上的， 例2的两个2是处在不同层级上的。
在一个for循环中，所有被遍历到的数都是属于一个层级的。我们要让一个层级中，
必须出现且只出现一个2，那么就放过第一个出现重复的2，但不放过后面出现的2。 第一个出现的2的特点就是 cur == begin.
第二个出现的2 特点是cur > begin.

上面代码思想主要参考 liweiwei1419
引用讲解来自于 Allen
本文仅用于记录LeetCode所见， 以及分享所见，
若侵权，速删

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。