Subsets 解答

Question

Given a set of distinct integers, 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,3], a solution is:

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

Solution 1 -- BFS

Because it's required that subset must be non-descending order, we can sort input array first. We can write out the solution space tree.

For example, input is [1,2,3]

　　　　　　[]

　　　　　/　|　

　　　[1]    [2]　[3]

　　/　　　  |

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

If element of last level is [i, j, .., k], then we could traverse elements from [k + 1, .., last] to add one element to construct complete answers.

BFS can be easily implemented to solve this problem. Time complexity is size of solution space tree, ie, C_n⁰ + C_n¹ + C_n² + .. + C_n^n/2 

public class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        Arrays.sort(nums);
        int length = nums.length;
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        List<List<Integer>> current = new ArrayList<List<Integer>>();
        results.add(new ArrayList<Integer>());
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < length; i++) {
            map.put(nums[i], i);
            List<Integer> tmp = new ArrayList<Integer>();
            tmp.add(nums[i]);
            current.add(tmp);
            results.add(tmp);
        }
        while (current.size() > 0) {
            List<List<Integer>> next = new ArrayList<List<Integer>>();
            int l = current.size();
            for (int i = 0; i < l; i++) {
                List<Integer> currentList = current.get(i);
                int ll = currentList.size();
                int last = currentList.get(ll - 1);
                int index = map.get(last);
                for (int j = index + 1; j < length; j++) {
                    // Note: create a new object
                    List<Integer> newList = new ArrayList<Integer>(currentList);
                    newList.add(nums[j]);
                    next.add(newList);
                    results.add(newList);
                }
            }
            current = next;
        }
        return results;
    }
}

Solution 2 -- DFS

We can transfer this problem to be list all combinations from number 0 to nums.length 

And we can get combinations of each size by DFS. Same time complexity as solution 1.

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