Ways to Split Array Into Three Subarrays

Ways to Split Array Into Three Subarrays - Problem

Array Partitioning Challenge: You need to find all the valid ways to split an array into exactly three contiguous subarrays such that their sums follow a specific order.

Given an array of non-negative integers, a "good" split must satisfy:
• Split into exactly 3 non-empty contiguous parts: left, mid, right
• sum(left) ≤ sum(mid) ≤ sum(right)

Goal: Count all possible good splits. Since the answer can be large, return it modulo 10^9 + 7.

Example: For [1,1,1], there's only one way to split: [1] | [1] | [1] where 1 ≤ 1 ≤ 1 ✅

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Only one way to split: [1] | [1] | [1]. Sum check: 1 ≤ 1 ≤ 1 ✅

example_2.py — Multiple Valid Splits

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

› Output: 3

💡 Note: Valid splits: [1] | [2] | [2,2,5,0] (1≤2≤9), [1] | [2,2] | [2,5,0] (1≤4≤7), [1,2] | [2,2] | [5,0] (3≤4≤5)

example_3.py — No Valid Splits

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

› Output: 0

💡 Note: Only possible split: [3] | [2] | [1]. Sum check: 3 ≤ 2 ≤ 1 ❌ (first condition fails)

Constraints

3 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁴
All elements are non-negative integers
Array must be split into exactly 3 non-empty contiguous subarrays

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses prefix sums with binary search to achieve O(n log n) time complexity. Key insight: for each fixed left subarray, there's a range of valid middle subarray positions - use binary search to find this range efficiently rather than checking each position individually.

Common Approaches

✓ Brute Force (Triple Nested Approach)

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

For each possible position of the first split (between left and mid), and each possible position of the second split (between mid and right), calculate the sum of each subarray and check if the condition sum(left) ≤ sum(mid) ≤ sum(right) holds.

Prefix Sum + Binary Search (Optimal)

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

Build prefix sums for O(1) subarray sum calculation. For each possible left subarray, use binary search to find the minimum and maximum valid positions for the mid subarray. This approach optimizes the range-finding step from O(n) to O(log n).

Prefix Sum + Two Pointers

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

Build prefix sums first to calculate subarray sums in O(1). For each possible left subarray, use two pointers to find the range of valid middle subarrays that satisfy both conditions: sum(left) ≤ sum(mid) and sum(mid) ≤ sum(right).

Brute Force (Triple Nested Approach) — Algorithm Steps

Use two nested loops to try all possible split positions
For each combination, calculate sum of left, mid, and right subarrays
Check if sum(left) ≤ sum(mid) ≤ sum(right)
Count valid splits and return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Split

Try each position for the first split (between left and mid)

Choose Second Split

For each first split, try each position for second split

Calculate Sums

Calculate sum of left, mid, and right subarrays

Check Condition

Verify if sum(left) ≤ sum(mid) ≤ sum(right)

Code -

solution.c — C

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

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

int waysToSplit(int* nums, int n) {
    const int MOD = 1000000007;
    int count = 0;
    
    // Calculate prefix sums for efficient range sum queries
    static long long prefix[100001];
    prefix[0] = 0;
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    // Try all possible first split positions (after index i)
    for (int i = 0; i < n - 2; i++) {
        // Try all possible second split positions (after index j)
        for (int j = i + 1; j < n - 1; j++) {
            long long left_sum = prefix[i + 1];  // sum of nums[0:i+1]
            long long mid_sum = prefix[j + 1] - prefix[i + 1];  // sum of nums[i+1:j+1]
            long long right_sum = prefix[n] - prefix[j + 1];  // sum of nums[j+1:n]
            
            if (left_sum <= mid_sum && mid_sum <= right_sum) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops O(n²) and sum calculation for each split O(n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Triple Nested Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler