2170. Count Number Of Maximum Bitwise Or Subsets¶

LeetCode Problem View on GitHub

2170. Count Number of Maximum Bitwise-OR Subsets

Medium

Given an integer array nums, find the maximum possible bitwise OR of a subset of nums and return the number of different non-empty subsets with the maximum bitwise OR.

An array a is a subset of an array b if a can be obtained from b by deleting some (possibly zero) elements of b. Two subsets are considered different if the indices of the elements chosen are different.

The bitwise OR of an array a is equal to a[0] OR a[1] OR ... OR a[a.length - 1] (0-indexed).

Example 1:

Input: nums = [3,1]
Output: 2
Explanation: The maximum possible bitwise OR of a subset is 3. There are 2 subsets with a bitwise OR of 3:
- [3]
- [3,1]

Example 2:

Input: nums = [2,2,2]
Output: 7
Explanation: All non-empty subsets of [2,2,2] have a bitwise OR of 2. There are 23 - 1 = 7 total subsets.

Example 3:

Input: nums = [3,2,1,5]
Output: 6
Explanation: The maximum possible bitwise OR of a subset is 7. There are 6 subsets with a bitwise OR of 7:
- [3,5]
- [3,1,5]
- [3,2,5]
- [3,2,1,5]
- [2,5]
- [2,1,5]

Constraints:

• 1 <= nums.length <= 16
• 1 <= nums[i] <= 105

Solution¶

class Solution {
    private ArrayList<ArrayList<Integer>> res;
    public int countMaxOrSubsets(int[] nums) {
        res = new ArrayList<>();
        solve(0, nums, new ArrayList<>());
        int maxi = 0;
        for(ArrayList<Integer> current : res) {
            int res2 = 0;
            for(int ele : current) {
                res2 |= ele;
            }
            maxi = Math.max(maxi, res2);
        }
        int count = 0;
        for(ArrayList<Integer> current : res) {
            int res1 = 0;
            for(int ele : current) {
                res1 |= ele;
            }
            if(res1 == maxi) count++;
        }
        return count;
    }
    private void solve(int ind, int arr[], ArrayList<Integer> temp) {
        if(ind > arr.length - 1) {
            res.add(new ArrayList<>(temp));
            return;
        }
        temp.add(arr[ind]);
        solve(ind + 1, arr, temp);
        temp.remove(temp.size() - 1);
        solve(ind + 1, arr, temp);
    }  
}

Complexity Analysis¶

• Time Complexity: O(?)
• Space Complexity: O(?)

Approach¶

Detailed explanation of the approach will be added here