zoukankan      html  css  js  c++  java
  • [LeetCode#90]Subsets II

    Problem:

    Given a collection of integers that might contain duplicates, nums, return all possible subsets.

    Note:

    • Elements in a subset must be in non-descending order.
    • The solution set must not contain duplicate subsets.

    For example,
    If nums = [1,2,2], a solution is:

    [
      [2],
      [1],
      [1,2,2],
      [2,2],
      [1,2],
      []
    ]

    Analysis:

    At first glance, you would follow the same complex routine to solve permutation problem. 
    1. we need a indicator for position to check base case.
    2. we need a used array to indicate which words have already been used.
    3. we need a checking mechanism, so as to avoid palcing same value at the same position twice.
    
    Thus, we reach the following ugly solution.
    
        static public List<List<Integer>> subsetsWithDup(int[] nums) {
            List<List<Integer>> ret = new ArrayList<List<Integer>> ();
            if (nums == null || nums.length == 0)
                return ret;
            Arrays.sort(nums);
            ArrayList<Integer> path = new ArrayList<Integer> ();
            boolean[] used = new boolean[nums.length];
            helper(0, 0, nums, used, path, ret);
            return ret;
        }
        
        static public void helper(int pos, int index, int[] nums, boolean[] used, ArrayList<Integer> path, List<List<Integer>> ret)     {
            if (pos == nums.length) {
                ret.add(new ArrayList<Integer> (path));
                return;
            }
            for (int i = index; i < nums.length; i++) {
                if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
                if (!used[i]) {
                    used[i] = true;
                    helper(pos+1, i+1, nums, used, path, ret);
                    path.add(nums[i]);
                    helper(pos+1, i+1, nums, used, path, ret);
                    path.remove(path.size()-1);
                    used[i] = false;
                }
            }
        }
        
    To make things worse, it is not right for the following case.
    nums = [1, 1]
    output: [], [1], [1], [1, 1]
    expected: [], [1], [1, 1]
    The problem was caused by a ridiculous logic error:
            [1, 1]
        [1]
            [1]
    []
            [1]
        []
            []
    And this error is hard not solve, cause we have already solved the problem of placing two different elements with the same value at the same position.
    
    Actually, this problem could be sovled in a very very elegant way, without any need to record position, used array!!! The only thing we should keep in mind is that: we have no exact position concept now, a helper process is to place a element at a positon, but we do not know the eact position.
    
    Since the result must in no-descending order, we must sort the nums first. What's more, it is the tool of avoding duplicates!!!
    Arrays.sort(nums);
    
    1. Start from empty path: []
    2. For each search enter into the helper, we add it into result set. (That's the definition of subset. Right???)
    ret.add(new ArrayList<Integer> (path));
    3. Then we try to select a element from [start, nums.length - 1] to append it into the current subset.
    for (int i = start; i < nums.length; i++) {
        if (i > start && nums[i] == nums[i-1]) continue;
        path.add(nums[i]);
        helper(nums, i+1, path, ret);
        path.remove(path.size()-1);
    }
    Note 1: we are trying to place a element for the same position. we should avoid duplicates at here.
    The skill to avoid the duplicate is common. <only the first element share the value was placed>
    if (i > start && nums[i] == nums[i-1]) continue;
    
    Note 2: we do not need used array at here, cause for next placement, we always start from the element after the current placed element.
    path.add(nums[i]);
    helper(nums, i+1, path, ret);
    path.remove(path.size()-1);

    Solution:

    public class Solution {
        public List<List<Integer>> subsetsWithDup(int[] nums) {
            List<List<Integer>> ret = new ArrayList<List<Integer>> ();
            if (nums == null || nums.length == 0)
                return ret;
            ArrayList<Integer> path = new ArrayList<Integer> ();
            Arrays.sort(nums);
            helper(nums, 0, path, ret);
            return ret;
        }
        
        private void helper(int[] nums, int start, ArrayList<Integer> path, List<List<Integer>> ret) {
            ret.add(new ArrayList<Integer> (path));
            for (int i = start; i < nums.length; i++) {
                if (i > start && nums[i] == nums[i-1]) continue;
                path.add(nums[i]);
                helper(nums, i+1, path, ret);
                path.remove(path.size()-1);
            }
        }
    }
  • 相关阅读:
    [GXYCTF2019]BabyUpload
    [GYCTF2020]Blacklist
    [极客大挑战 2019]HardSQL
    PHP实现MVC框架路由功能模式
    色环电阻的阻值识别
    python的内存回收机制
    配置Openfiler做ISCS实验
    windows server 2008r2 在vmware里自动关机
    VMware Workstation网络修改vlan id值
    linux的服务自动启动的配置
  • 原文地址:https://www.cnblogs.com/airwindow/p/4750014.html
Copyright © 2011-2022 走看看