[LintCode] Subsets

Given a set of distinct integers, return all possible subsets.

 Notice

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

Example

If S = [1,2,3], a solution is:

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

Challenge 

Can you do it in both recursively and iteratively?

 

Solution 1. Recursion

class Solution {
    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        if(nums == null){
            return results;
        }
        Arrays.sort(nums);
        getSubsets(results, new ArrayList<Integer>(), nums, 0);
        return results;
    }
    
    private void getSubsets(ArrayList<ArrayList<Integer>> results,
                            ArrayList<Integer> result,
                            int[] nums, int startIdx){
        results.add(new ArrayList<Integer>(result));
        for(int i = startIdx; i < nums.length; i++){
            result.add(nums[i]);
            getSubsets(results, result, nums, i + 1);
            result.remove(result.size() - 1);
        }
    }
}

 

Solution 2. Iterative 

Algorithm:

if there are n elements in nums[], then we'll have 2^n different subsets in total. 

Each outer loop genereates a different subset. For a given i, its bits of 1 represent

that which elements should be included in the ith subset. 

Each inner loop checks if nums[j] should be included in the ith subset.

For example, nums = {1, 2, 3}, i = 5 with binary representation of 101. This means 

nums[0] and nums[2] should be included in the 5th subset.

Then in the inner loop checks if each nums[j] should be included in the 5th subset.

class Solution {
    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        int n = nums.length;
        Arrays.sort(nums);
        
        for (int i = 0; i < (1 << n); i++) {
            ArrayList<Integer> subset = new ArrayList<Integer>();
            for (int j = 0; j < n; j++) {
                // check whether the jth digit in i's binary representation is 1
                if ((i & (1 << j)) != 0) {
                    subset.add(nums[j]);
                }
            }
            result.add(subset);
        }
        
        return result;
    }
}

 

Both solutions' runtime are O(2^n), and it is already optimal since there are 2^n different subsets to generate.

 

Related Problems

Subsets II

Restore IP Address