Ways to Split Array Into Good Subarrays

Ways to Split Array Into Good Subarrays - Problem

You are given a binary array nums.

A subarray of an array is good if it contains exactly one element with the value 1.

Return an integer denoting the number of ways to split the array nums into good subarrays. As the number may be too large, return it modulo 10⁹ + 7.

A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: There are 6 ways to split: [0,1]|[0,0,1]|[0,1], [0,1]|[0,0,1,0]|[1], [0,1,0]|[0,1]|[0,1], [0,1,0]|[0,1,0]|[1], [0,1,0,0]|[1]|[0,1], [0,1,0,0]|[1,0]|[1]

Example 2 — Single 1

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

› Output: 1

💡 Note: Only one way to split: [0,1,0] as a single subarray containing exactly one 1

Example 3 — No Valid Split

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

› Output: 0

💡 Note: Cannot create subarrays with exactly one 1 each - any split will have some subarray with 0 or multiple 1s

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1

Visualization

Tap to expand

Asked in

M Meta 15 G Google 12 M Microsoft 8

The key insight is that each split between consecutive 1s can be placed at multiple positions. The mathematical approach finds all 1 positions and multiplies the gaps between them. Best approach is Math: Time O(n), Space O(1).

Common Approaches

✓ Brute Force - Try All Split Combinations

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

Try every possible combination of split positions and check if each resulting subarray contains exactly one '1'. Use backtracking to generate all possible splits.

Mathematical Solution - Count Gaps Between 1s

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

The key insight is that between any two consecutive 1s, we can place the split at any of the 0 positions. The number of ways is the product of all possible positions between consecutive 1s.

Brute Force - Try All Split Combinations — Algorithm Steps

Generate all possible split positions
For each split combination, check if all subarrays are good
Count valid splits

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Splits

Try all possible positions to end each subarray

Validate

Check if each subarray has exactly one '1'

Count

Count valid split combinations

Code -

solution.c — C

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

#define MOD 1000000007

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int* nums, int n) {
    // Find positions of all 1s
    int onesPositions[1000];
    int onesCount = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] == 1) {
            onesPositions[onesCount++] = i;
        }
    }
    
    // If no 1s, cannot form good subarrays
    if (onesCount == 0) {
        return 0;
    }
    
    // Check for consecutive 1s - if any exist, impossible to split
    for (int i = 0; i < onesCount - 1; i++) {
        if (onesPositions[i + 1] - onesPositions[i] == 1) {
            return 0;
        }
    }
    
    // If only one 1, there's exactly one way (the entire array)
    if (onesCount == 1) {
        return 1;
    }
    
    // For multiple 1s, count ways to place split boundaries
    long long result = 1;
    
    for (int i = 0; i < onesCount - 1; i++) {
        // Between onesPositions[i] and onesPositions[i+1],
        // we can place the boundary at any position from
        // onesPositions[i] to onesPositions[i+1] - 1
        // This gives us (onesPositions[i+1] - onesPositions[i]) choices
        int choices = onesPositions[i + 1] - onesPositions[i];
        result = (result * choices) % MOD;
    }
    
    return (int) result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    parseArray(line, nums, &n);
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

2^n possible ways to split array, each takes O(n) to validate

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays for validation

⚡ Linearithmic Space

23.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Split Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler