Count Number of Maximum Bitwise-OR Subsets

Count Number of Maximum Bitwise-OR Subsets - Problem

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).

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,1]

› Output: 2

💡 Note: Maximum OR is 3|1 = 3. Subsets [3] and [3,1] both achieve OR = 3, so return 2.

Example 2 — Single Element

$ Input: nums = [2,2,2]

› Output: 7

💡 Note: Maximum OR is 2. All non-empty subsets ([2], [2], [2], [2,2], [2,2], [2,2], [2,2,2]) achieve OR = 2.

Example 3 — Different Bits

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

› Output: 6

💡 Note: Maximum OR is 3|2|1|5 = 7. Count all subsets that achieve OR = 7.

Constraints

1 ≤ nums.length ≤ 16
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12

The key insight is to first calculate the maximum possible OR by ORing all elements, then count subsets that achieve this maximum. The backtracking approach explores all possibilities efficiently. Time: O(2ⁿ), Space: O(n) for recursion stack.

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Merge Sort

⏱️ Time: N/A Space: N/A

Backtracking with Pruning

⏱️ Time: O(2ⁿ) Space: O(n)

Use recursive backtracking to build subsets incrementively. First find the maximum possible OR, then count subsets that achieve it using DFS with pruning.

Brute Force - Generate All Subsets

⏱️ Time: O(n × 2ⁿ) Space: O(1)

Generate all 2^n possible subsets, calculate the bitwise OR for each subset, find the maximum OR value, then count how many subsets achieve this maximum.

Optimized with Bit Analysis

⏱️ Time: O(2ⁿ) Space: O(n)

First calculate the maximum possible OR by ORing all elements. Then use a more efficient approach to count subsets with this maximum OR value without generating all subsets explicitly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int maxOR = 0;
int count = 0;

void backtrack(int* nums, int numsSize, int index, int currentOR) {
    if (index == numsSize) {
        // Only consider non-empty subsets (currentOR > 0)
        if (currentOR > 0) {
            if (currentOR > maxOR) {
                maxOR = currentOR;
                count = 1;
            } else if (currentOR == maxOR) {
                count++;
            }
        }
        return;
    }
    
    // Include current element
    backtrack(nums, numsSize, index + 1, currentOR | nums[index]);
    
    // Exclude current element
    backtrack(nums, numsSize, index + 1, currentOR);
}

int solution(int* nums, int numsSize) {
    maxOR = 0;
    count = 0;
    
    // Start backtracking from index 0 with OR = 0
    backtrack(nums, numsSize, 0, 0);
    
    // Return count directly (no need to subtract 1)
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    // Parse array from string like "[3,1]" or "[2,2,2]"
    char *p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0' || *p == '\n') break;
        
        char *endptr;
        long val = strtol(p, &endptr, 10);
        if (endptr != p) {
            nums[numsSize++] = (int)val;
            p = endptr;
        } else {
            p++;
        }
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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