D14 LeetCode 2044.统计按位或能得到最大值的子集数目（中等）

一、题目

二、思路（自己）

• 首先我们要知道按位或是什么意思，即取参与运算的两数各对应的二进制相或，题目给出条件元素大于0，所以不用考虑为负数的情况。
• nums子集按位或，其本身肯定是按位或最大的。所以先让其本身按位或再依次计算其子集按位或的结果。

class Solution {
  public int countMaxOrSubsets(int[] nums) {
        int count=1;
        Integer[] x=new Integer[nums.length];
        for (int i = 0; i < nums.length; i++) {
            x[i]=nums[i];
        }
        int max=byteOr(x);
        List list=getSonArray(nums);
        for(Integer[] i:list){
            if(byteOr(i)==max) {
                count++;
               // System.out.println(Arrays.toString(i));
            }
        }
        return count;
    }

    //获得nums数组的所有子集
    public static List getSonArray(int[] nums){
        int l=nums.length;
       int l1=l<<1;
       int nEnd=1< res=new ArrayList<>(l1);
       for (int i = 0; i < nEnd; i++) {
           List ele=new ArrayList<>();
           for (int j = 0; j < l; j++) {
               //该位置有元素输出
               if(((1<

•  我天，我这内存消耗和执行用时都太高了....我提交的时候以为都要超时了，不过能提交成功还是很棒哒！

三、收获

1. 如何获得一个数组的全部子集？ 答：

可以叫按位对应法。如集合A={a,b,c},对于任意一个元素，在每个子集中，要么存在，要么不存在。
映射为子集：
(a,b,c)
(1,1,1)->(a,b,c)
(1,1,0)->(a,b)
(1,0,1)->(a,c)
(1,0,0)->(a)
(0,1,1)->(b,c)
(0,1,0)->(b)
(0,0,1)->©
(0,0,0)->@(@表示空集)
观察以上规律，与计算机中数据存储方式相似，故可以通过一个整型数与集合映射00…00 ~ 11…11（1表示有，0表示无，反之亦可），通过该整型数逐次增可遍历获取所有的数，即获取集合的相应子集。

/*
	 *按位对应法。
	*/
	private static void getSonSet2(int[] arr, int length) {
		int mark=0;
		int nEnd=1<

2. int[ ]和Integer[ ]不能直接转换，可以通过流运算解决（目前还不太熟悉）

四、题解（官方）

1、位运算

        感觉官方的位运算跟我的思路差不多，我咋写了这么多...

class Solution {
    public int countMaxOrSubsets(int[] nums) {
        int maxOr = 0, cnt = 0;
        for (int i = 0; i < 1 << nums.length; i++) {
            int orVal = 0;
            for (int j = 0; j < nums.length; j++) {
                if (((i >> j) & 1) == 1) {
                    orVal |= nums[j];
                }
            }
            if (orVal > maxOr) {
                maxOr = orVal;
                cnt = 1;
            } else if (orVal == maxOr) {
                cnt++;
            }
        }
        return cnt;
    }
}

        官方直接在求子集的时候就把子集的元素进行了或运算，节省了时间和空间！

2、回溯

        

class Solution {
    int[] nums;
    int maxOr, cnt;

    public int countMaxOrSubsets(int[] nums) {
        this.nums = nums;
        this.maxOr = 0;
        this.cnt = 0;
        dfs(0, 0);
        return cnt;
    }

    public void dfs(int pos, int orVal) {
        if (pos == nums.length) {
            if (orVal > maxOr) {
                maxOr = orVal;
                cnt = 1;
            } else if (orVal == maxOr) {
                cnt++;
            }
            return;
        }
        dfs(pos + 1, orVal | nums[pos]);
        dfs(pos + 1, orVal);
    }
}

 每天加油！