Split Array Into Maximum Number of Subarrays

Split Array Into Maximum Number of Subarrays - Problem

You are given an array nums consisting of non-negative integers.

We define the score of subarray nums[l..r] such that l <= r as nums[l] AND nums[l + 1] AND ... AND nums[r] where AND is the bitwise AND operation.

Consider splitting the array into one or more subarrays such that the following conditions are satisfied:

Each element of the array belongs to exactly one subarray.
The sum of scores of the subarrays is the minimum possible.

Return the maximum number of subarrays in a split that satisfies the conditions above.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Split

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

› Output: 3

💡 Note: We can split into [1,0], [2,0], [1]. Scores are 0, 0, 1 with sum = 1. But to get minimum sum = 0, we split as [1,0,2,0], [1] with scores 0, 1, sum = 1. Actually, the minimum sum is achieved by maximally splitting where each part has AND = 0: [1,0], [2,0], [1] giving 3 subarrays.

Example 2 — Single Subarray

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

› Output: 1

💡 Note: The entire array AND is 5&7&1&3 = 1 > 0. To minimize sum, we must keep as one subarray [5,7,1,3] with score 1.

Example 3 — All Zeros

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

› Output: 3

💡 Note: We can split into [0], [0], [0]. Each subarray has score 0, sum = 0 (minimum), with 3 subarrays maximum.

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that AND operations only decrease values, so we want to split greedily when the running AND becomes zero to minimize the sum while maximizing subarrays. Best approach is greedy splitting. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Partitions

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

Try every possible way to split the array into subarrays. For each partition, calculate the sum of AND scores and track partitions with minimum sum. Among those, return the maximum number of subarrays.

Greedy - Split When AND Becomes Zero

⏱️ Time: O(n) Space: O(1)

First find the minimum possible sum by taking AND of entire array. Then greedily build subarrays, splitting whenever the current AND equals zero or we can achieve the target sum.

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partitions using recursion
Calculate AND score for each subarray in partition
Find minimum possible sum of scores
Count maximum subarrays among minimum sum partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Try every way to split array into subarrays

Calculate Scores

Compute AND for each subarray in partition

Find Minimum

Track partitions with minimum sum of scores

Code -

solution.c — C

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

static int nums[10000];

int solution(int n) {
    if (n == 0) return 0;
    
    int subarrays = 0;
    int i = 0;
    
    while (i < n) {
        int current_and = nums[i];
        int j = i;
        
        // Extend the current subarray as long as AND doesn't become 0
        // or until we reach the end
        while (j < n) {
            if (j > i) {
                current_and &= nums[j];
            }
            
            // If AND becomes 0, we should cut here to minimize sum
            if (current_and == 0) {
                j++;
                break;
            }
            j++;
        }
        
        subarrays++;
        i = j;
    }
    
    return subarrays;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    int i = 1; // skip '['
    
    while (line[i] && line[i] != ']') {
        if (line[i] == ',' || line[i] == ' ') {
            i++;
            continue;
        }
        
        int num = 0;
        while (line[i] >= '0' && line[i] <= '9') {
            num = num * 10 + (line[i] - '0');
            i++;
        }
        nums[n++] = num;
    }
    
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n²)

2^n possible partitions, each taking O(n²) to calculate scores

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n levels

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

245 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler