L78子集

78. 子集
    给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if(nums == null || nums.length == 0) return  res;
        int len = nums.length;
        for(int i = 0; i < (1<<len); i++){//对应2^len中可能
            //对对应的二进制位每一个进行分析，0表示存在，1表示不存在
            ArrayList<Integer> list = new ArrayList<>();
            for(int j = 0; j < len; j++){
                if(((i>>j) & 1) == 1) list.add(nums[j]);//注意加上括号保护优先级
            }
            res.add(list);
        }
        return res;
    }
}

2.可以与招行那题相对应，也就是每一个数都是两种状态，可选，可不选的状态，

public class Solution {

    private List<List<Integer>> res;

    private void find(int[] nums, int begin, List<Integer> pre) {
      
        if(begin == nums.length){
            res.add(new ArrayList<>(pre));
            return;
        }
        
        pre.add(nums[begin]);
        find(nums, begin + 1, pre);
        pre.remove(pre.size() - 1);// 组合问题，状态在递归完成后要重置
        find(nums, begin + 1, pre);

    }

    public List<List<Integer>> subsets(int[] nums) {
        int len = nums.length;
        res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        List<Integer> pre = new ArrayList<>();
        find(nums, 0, pre);
        return res;
    }
}

调整一下顺序

public class Solution {

    private List<List<Integer>> res;

    private void find(int[] nums, int begin, List<Integer> pre) {
        // 没有显式的递归终止
        if(begin == nums.length){
            res.add(new ArrayList<>(pre));
            return;
        }
        
        
        find(nums, begin + 1, pre);
        pre.add(nums[begin]);
        find(nums, begin + 1, pre);
        pre.remove(pre.size() - 1);//注意要remove

    }

    public List<List<Integer>> subsets(int[] nums) {
        int len = nums.length;
        res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        List<Integer> pre = new ArrayList<>();
        find(nums, 0, pre);
        return res;
    }
}

3.利用for循环，常规操作,就是有序添加，可以避免重复

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int len = nums.length;
        res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        List<Integer> pre = new ArrayList<>();
        dfs(nums, 0, pre, res);//从0开始
        return res;
    }
    void dfs(int[] nums, int index, List<Integer> list, List<List<Integer>> res){
        //无显式边界条件
        /*if(index == nums.length){//如果这样写，则必须等到index = n的时候才加入res
            res.add(list);
            return;
        }*/
        //res.add(list);//这样的话保证每次都会加入res,注意要new一个新的
        res.add(new ArrayList(list));
        for(int i = index; i < nums.length; i++){
            list.add(nums[i]);
            dfs(nums, i + 1, list, res);
            list.remove(list.size() - 1);
        }
    }
}

可以加上一个显式的边界条件

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int len = nums.length;
        res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        List<Integer> pre = new ArrayList<>();
        for(int size = 0; size <= len; size++){//根据pre集合的个数进行遍历
            dfs(nums, 0, pre, res, size);
        }

        return res;
    }
    void dfs(int[] nums, int index, List<Integer> list, List<List<Integer>> res, int size){
        if(size == list.size()){
            res.add(new ArrayList<>(list));
        }
        for(int i = index; i < nums.length; i++){
            list.add(nums[i]);
            dfs(nums, i + 1, list, res, size);
            list.remove(list.size() - 1);
        }
    }
}