NC46 加起来和为目标值的组合(二)

刷题的时候经常可以遇到这一类型的题目。这道题总有测试用例超时，总结一下，看能不能更清晰。

//这里并不是题解，而是求出数组数字所有的组合  例如 [1，2，3] -> [[1],[1,2],[1,2,3],[2],[2,3],[3]]
//求 数组中任意组合的和==target   就需要先列出所有的组合。先看懂这段代码。
public class NC46 {
    //存储结果集
    static ArrayList<ArrayList<Integer>> result = new ArrayList<>();
    //存储选中的序列，符合条件 则将改序列加入 到result
    static ArrayList<Integer> list = new ArrayList<>();
    public static void dfs(int[] nums, int start) {
            result.add(new ArrayList<>(list));
        for (int i = start; i < nums.length; i++) {
            list.add(nums[i]);
            dfs(nums,  i + 1);
            list.remove(list.size() - 1);
        }
    }
    public static ArrayList<ArrayList<Integer>> combinationSum2(int[] nums, int t) {
        Arrays.sort(nums);
        dfs(nums,  0);
        return result;
    }
    public static void main(String[] args) {
        int[] a = {1, 2,3};
        combinationSum2(a, 2);
    }

}

//题解
public class NC46 {
    //存储结果集
    static ArrayList<ArrayList<Integer>> result = new ArrayList<>();
    //存储选中的序列，符合条件 则将改序列加入 到result
    static ArrayList<Integer> list = new ArrayList<>();

    public static void dfs(int[] nums, int target, int start) {
        if (target == 0) { 
            // 列表元素之和 == target  ，将列表加入 result
            result.add(new ArrayList<>(list));
            return;
        }

        if (start >= nums.length)
            return;

        for (int i = start; i < nums.length; i++) {
            //nums是有序数组，当nums[i]
            //如果把这个条件注释掉  对于 [1,1,1,2],3    输出的结果是 [[1,1,1],[1,2],[1,2],[1,2]]
            if (i > start && nums[i] == nums[i - 1])
                continue;
            //剪枝。 跳过该元素。
            if (nums[i] > target)
                continue;
            list.add(nums[i]);
            //递归，接下来利用剩余的数组 求 目标值  =   target - nums[i]
            dfs(nums, target - nums[i], i + 1);
            list.remove(list.size() - 1);
        }


    }

    public static ArrayList<ArrayList<Integer>> combinationSum2(int[] nums, int t) {
        //数组是升序的 后续结论都是基于有序数组。 
        Arrays.sort(nums);
        dfs(nums,t,0);
        return result;
    }


    public static void main(String[] args) {
        int[] a = {1,1,1,2};
        combinationSum2(a, 2);
    }

}

   if (i > start && nums[i] == nums[i - 1])    【后续这段判断用‘条件1’代指】
          continue;

	这段代码需要仔细斟酌一下。 到底是怎么做到去重的。（用这个判断条件，需要数组是有序的，数组一开始已经排过序了。）
    以测试用例 [1,1,1,2],2 为例 输出应该是[[1,1],[2]]  如果没有这段代码则输出 [[1,1],[1,1],[1,1],[2]] 
    也就是将每个1都当作了不同的元素处理
        
    if (nums[i] > target)    【剪枝， 用‘条件2’指代】
            continue;  
    
     首先调用  combinationSum2(a, 2); 
首次进入dfs， 
-> target=2 start=0 i=0      list=[1]  
  -> 继续调用dfs   target=1   start=1  i=1   条件1=false     list=[1,1]  
    ->dfs target=0 start=2 i=2  target == 0 条件满足  将[1,1]加入result.  调用结束 return;
  -> list.remove(list.size() - 1); 移除list中刚在本次dfs加入的元素    此时 list=[1]
  -> target =1 start=1 i=2 条件1=true continue
  -> target =1 start=1 i=3  此时num[3]=2 大于 target=1 ，条件2=true（即后续继续dfs()也凑不出target）  ，直接跳过这层循环。 该层递归结束 return
-> list.remove(list.size() - 1); 此时list=[]
-> target=2 start=0 i=1 条件1=true continue;
-> target=2 start=0 i=2 条件1=true continue;
-> target=2 start=0 i=3 条件1=false 条件2=false
  -> target=0 start=4      此时target==0 list=[2] 加入result 然后 return;
-> list.remove(list.size() - 1); 循环至此结束 首次调用的dfs return;


用语言描述一下dfs。 
    在首次进入dfs时， i=0 就是将nums[0] 取出，    然后求后续任意  target-nums[i] 的组合 
    i=1  取出nums[1] ，再求后续 target-nums[1]的组合 
    这样一层层循环 ，每层循环递归 就能排列出所有组合。
    
    
    那为什么会重复呢？
    当nums[0] 和 nums[1]相等的时候 ，   nums[0]+剩余组合   和  nums[1]+ 剩余组合 是有重复的。
    比如 [1,1,1,2]    会产生三个数组 [1,2] [1,2] [1,2]  这三个中我们只需要第一个nums[0]=1存在的组合就够了 [1,2]  
    那包含nums[1]=1 的组合会不会被去掉呢？即[1,1,1]这个组合怎么没有被去掉。
   	不会。  在i==0时  加入了nums[0] 之后 ，再次进入dfs 此时nums[1]即便与前面的数字相等也会被算进去。
  	总结：   nums[0]+剩余数组的组合  和  nums[1]+剩余数组的组合  在num[0]==nums[1]时  两个组合是有重复的。
    其中前者是真包含后者的。 所以要加    if (i > start && nums[i] == nums[i - 1]) 这层判断。