Split Array Into Maximum Number of Subarrays

Split Array Into Maximum Number of Subarrays - Problem

You're given an array of non-negative integers and need to split it into subarrays in a very specific way!

Here's the challenge: Each subarray has a score calculated by performing a bitwise AND operation on all its elements. For example, if you have a subarray [5, 4, 1], its score would be 5 AND 4 AND 1 = 0.

Your goal is to:

Split the array into one or more contiguous subarrays
Make sure the sum of all subarray scores is minimized
Among all possible splits that achieve this minimum sum, find the one with the maximum number of subarrays

Think of it like this: you want to break the array into as many pieces as possible, but only if doing so doesn't increase the total score sum beyond the absolute minimum possible.

Example: For nums = [1, 0, 2, 0, 1, 2], you can split it as [1] [0] [2, 0, 1] [2] with scores 1 + 0 + 0 + 2 = 3, giving you 4 subarrays.

Input & Output

example_1.py — Basic Splitting

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

› Output: 4

💡 Note: We can split as [1],[0],[2,0,1],[2] with scores 1+0+0+2=3. Since the global AND is 0, this achieves the minimum sum with maximum subarrays.

example_2.py — No Beneficial Splits

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

› Output: 1

💡 Note: The global AND is 5&7&1&3=1. Since this is >0, splitting won't reduce the sum, so we keep the entire array as one subarray.

example_3.py — All Zeros

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

› Output: 3

💡 Note: Each element can form its own subarray with score 0, giving us 3 subarrays with total sum 0+0+0=0.

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁶
All elements are non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Compute Global Baseline

Calculate AND of entire array to find the minimum achievable sum

Evaluate Split Benefit

If global AND > 0, splitting can't improve the sum, so return 1

Greedy Splitting Decision

When global AND = 0, split greedily whenever running AND reaches 0

Maximize Subarray Count

Each optimal split point increases our subarray count while maintaining minimum sum

Key Takeaway

🎯 Key Insight: The greedy approach works because bitwise AND can only decrease or maintain values. When the global AND is 0, we achieve the minimum sum by splitting whenever the running AND becomes 0, maximizing our subarray count.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses a greedy approach based on bitwise AND properties. Key insight: the minimum possible sum equals the AND of the entire array. If this global AND is greater than 0, splitting provides no benefit. If it equals 0, we can greedily split whenever the running AND becomes 0, maximizing the number of subarrays while maintaining the minimum sum.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Use bitwise AND properties to greedily determine optimal splits
Brute Force (Try All Splits)	O(2^n × n)	O(n)	Generate all possible ways to split the array and find the optimal one

Greedy Approach (Optimal) — Algorithm Steps

Calculate the AND of the entire array - this is our target minimum sum
If the global AND is greater than 0, we can't improve by splitting, so return 1
If the global AND is 0, greedily traverse and split whenever running AND becomes 0
Count the number of splits made this way
Handle edge case where we need at least one subarray

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Global AND

Find AND of entire array to determine minimum possible sum

Check if Splitting Helps

If global AND > 0, splitting won't improve the sum

Greedy Splitting

When global AND = 0, split whenever running AND becomes 0

Count Maximum Splits

Each split gives us another subarray in the optimal solution

Code -

solution.c — C

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

int maxSubarrays(int* nums, int n) {
    // Calculate AND of entire array
    int totalAnd = nums[0];
    for (int i = 1; i < n; i++) {
        totalAnd &= nums[i];
    }
    
    // If total AND > 0, we can't improve by splitting
    if (totalAnd > 0) {
        return 1;
    }
    
    // Greedily split whenever running AND becomes 0
    int count = 0;
    int currentAnd = nums[0];
    
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            currentAnd = nums[i];
        } else {
            currentAnd &= nums[i];
        }
        
        // When running AND becomes 0, we can make a split
        if (currentAnd == 0) {
            count++;
            // Reset for next subarray (if not at end)
            if (i < n - 1) {
                currentAnd = INT_MAX;
            }
        }
    }
    
    // Ensure we have at least one subarray
    return count > 1 ? count : 1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

23.4K Views

Medium-High Frequency

~18 min Avg. Time

890 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler