Count Number of Maximum Bitwise-OR Subsets

Count Number of Maximum Bitwise-OR Subsets - Problem

Given an integer array nums, you need to find the maximum possible bitwise OR of any subset of the array, and then count how many different subsets achieve this maximum OR value.

A subset is any collection of elements from the original array (including empty collections, but we only consider non-empty subsets here). Two subsets are considered different if they contain elements at different indices.

The bitwise OR operation combines bits using the rule: if either bit is 1, the result is 1. For an array, we OR all elements together: a[0] OR a[1] OR ... OR a[n-1].

Example: For [3, 1], possible subsets are [3] (OR = 3), [1] (OR = 1), and [3,1] (OR = 3). Maximum OR is 3, achieved by 2 subsets.

Input & Output

example_1.py — Basic case

$ Input: [3, 1]

› Output: 2

💡 Note: Maximum OR is 3. Subsets with OR = 3: [3] and [3,1]. Count = 2.

example_2.py — Multiple elements

$ Input: [2, 2, 2]

› Output: 7

💡 Note: Maximum OR is 2. All non-empty subsets have OR = 2, so count = 7 (2^3 - 1).

example_3.py — Mixed values

$ Input: [3, 2, 1, 5]

› Output: 6

💡 Note: Maximum OR is 7 (3|2|1|5). Subsets achieving OR = 7 must include elements that contribute unique bits.

Visualization

Tap to expand

Understanding the Visualization

Analyze Devices

Each device has features: 3=[11], 1=[01], 2=[10]

Find Max Features

Maximum features = 11|01|10 = 11 (binary) = 3 (decimal)

Count Combinations

Find all device combinations that achieve maximum features

Result

Multiple combinations can achieve the same maximum feature set

Key Takeaway

🎯 Key Insight: The maximum possible bitwise OR is always achieved by combining all array elements. We only need to count how many subsets reach this theoretical maximum.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We still need to explore all possible subsets in worst case, but with some pruning potential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels deep

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 16
1 ≤ nums[i] ≤ 10⁵
The array length is small (≤16) making exponential solutions feasible

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses two-pass backtracking: first calculate the maximum possible OR by combining all elements, then use recursive backtracking to count subsets achieving this maximum. This leverages the key insight that the maximum OR is always achieved by ORing all elements together.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass: Find Max OR, then Backtrack Count	O(2^n)	O(n)	First pass finds maximum OR, second pass counts subsets achieving it
Brute Force (Generate All Subsets)	O(n × 2^n)	O(1)	Generate all possible subsets and check each one's OR value

Two-Pass: Find Max OR, then Backtrack Count — Algorithm Steps

First pass: Calculate the maximum possible OR by ORing all elements together
Second pass: Use backtracking to explore all subsets
For each subset during backtracking, check if its OR equals the target maximum
Count and return the number of subsets that achieve the maximum OR

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max OR

Calculate maximum possible OR by combining all elements

Backtrack Tree

Explore all subsets using recursive tree structure

Count Matches

Count subsets whose OR equals the target maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int maxOr;

int backtrack(int* nums, int n, int index, int currentOr) {
    if (index == n) {
        return currentOr == maxOr ? 1 : 0;
    }
    
    // Don't include current element
    int count = backtrack(nums, n, index + 1, currentOr);
    // Include current element
    count += backtrack(nums, n, index + 1, currentOr | nums[index]);
    
    return count;
}

int countMaxOrSubsets(int* nums, int n) {
    // First pass: find the maximum possible OR
    maxOr = 0;
    for (int i = 0; i < n; i++) {
        maxOr |= nums[i];
    }
    
    // Second pass: count subsets that achieve maxOr
    return backtrack(nums, n, 0, 0) - 1; // Subtract 1 for empty subset
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[20];
    int n = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL && n < 20) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", countMaxOrSubsets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We still need to explore all possible subsets in worst case, but with some pruning potential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels deep

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 16
1 ≤ nums[i] ≤ 10⁵
The array length is small (≤16) making exponential solutions feasible

32.0K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass: Find Max OR, then Backtrack Count — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler