《子集》90. 子集 II（回溯+状态压缩+set）《leetcode》

90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10

代码：回溯思想

//回溯
class Solution {
    //时间复杂度（O（n*2^n）） 空间复杂度（O（n*2^n））
    public static void dfs(int nums[],int u,List<Integer>cur,Set<List<Integer>>ans)//u当前决策到原输入数组中的哪一位 cur 当前方案
    {
        if(u==nums.length)
        {
            ans.add(new ArrayList<>(cur));
            return;
        }

        //选择当前元素，往下走
        cur.add(nums[u]);
        dfs(nums,u+1,cur,ans);
        
        //不选当前位置的元素，往下走
        cur.remove(cur.size()-1);//回溯
        dfs(nums,u+1,cur,ans);
    }
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        
        Arrays.sort(nums);
        Set<List<Integer>>ans=new HashSet<>();
        List<Integer>cur=new ArrayList<>();
        dfs(nums,0,cur,ans);
        List<List<Integer>> re=new ArrayList<>(ans);
        return re;
    }
}

代码：状态压缩

//状态压缩
class Solution {
    //时间复杂度（O（n*2^n）） 空间复杂度（O（n*2^n））
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        Set<List<Integer>>ans=new HashSet<>();
        List<Integer>cur=new ArrayList<>();
        int n=nums.length;
        //1<<n 就是2的n次方 比如[1,2] 有[][1][2][1,2]四个子集，(0,0)(1,0)(0,1) (1,1)
        for(int i=0;i<(1<<n);i++)
        {
            cur.clear();
            for(int j=0;j<n;j++)//最多n位
            {
                int t=(i>>j)&1;//左移，按位进行判断 如果是1的话，对应j位的元素加进去  不过此时元素应该是按逆序排列的，因为题目没有要求，所以无所谓
                if(t==1) cur.add(nums[j]);
            }
            ans.add(new ArrayList<>(cur));
        }

        List<List<Integer>> re=new ArrayList<>(ans);
        return re;
    }
}

后记

这是一种类型题，可以多总结模板！今天总结了回溯和状态压缩。后序再记。