Leetcode: Subsets

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

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

Adopted approach: Notice that in line 11, you should create a copy of current path, and add it to res. Otherwise, it'll be edited later, and be wiped out to []. So the res will be [[], [], [], [], [], ...]

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        backtracking(path, res, nums, 0);
        return res;
    }
    
    public void backtracking(List<Integer> path, List<List<Integer>> res, int[] nums, int pos) {
        if (pos == nums.length) {
            res.add(new ArrayList<Integer>(path));
            return;
        }
        // not to add current element to the subset
        backtracking(path, res, nums, pos + 1);
        
        // add current element to the subset
        path.add(nums[pos]);
        backtracking(path, res, nums, pos + 1);
        path.remove(path.size() - 1);
    }
}

第二遍做法：

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, 0);
    return list;
}

private void backtrack(List<List<Integer>> list , List<Integer> tempList, int [] nums, int start){
    list.add(new ArrayList<>(tempList));
    for(int i = start; i < nums.length; i++){
        tempList.add(nums[i]);
        backtrack(list, tempList, nums, i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

网上看到Bit Manipulation做法：

Take = 1
Dont take = 0
 
0) 0 0 0  -> Dont take 3 , Dont take 2 , Dont take 1 = { } 
1) 0 0 1  -> Dont take 3 , Dont take 2 ,   take 1       =  {1 } 
2) 0 1 0  -> Dont take 3 ,    take 2       , Dont take 1 = { 2 } 
3) 0 1 1  -> Dont take 3 ,    take 2       ,      take 1    = { 1 , 2 } 
4) 1 0 0  ->    take 3      , Dont take 2  , Dont take 1 = { 3 } 
5) 1 0 1  ->    take 3      , Dont take 2  ,     take 1     = { 1 , 3 } 
6) 1 1 0  ->    take 3      ,    take 2       , Dont take 1 = { 2 , 3 } 
7) 1 1 1  ->    take 3     ,      take 2     ,      take 1     = { 1 , 2 , 3 } 

public class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums==null || nums.length==0) return res;
        Arrays.sort(nums);
        int totalNum = 1<<nums.length;
        for (int i=0; i<totalNum; i++) { //one i correspond to one subset pattern
            List<Integer> path = new ArrayList<>();
            for (int k=0; k<nums.length; k++) {
                if (((i>>k)&1) == 1) 
                    path.add(nums[k]);
            }
            res.add(new ArrayList<Integer>(path));
        }
        return res;
    }
}