Check if it is Possible to Split Array

Check if it is Possible to Split Array - Problem

You are given an array nums of length n and an integer m. You need to determine if it is possible to split the array into n arrays of size 1 by performing a series of steps.

An array is called good if:

The length of the array is one, or
The sum of the elements of the array is greater than or equal to m.

In each step, you can select an existing array (which may be the result of previous steps) with a length of at least two and split it into two arrays, if both resulting arrays are good.

Return true if you can split the given array into n arrays, otherwise return false.

Input & Output

Example 1 — Basic Splittable Case

$ Input: nums = [2,1,2,6], m = 4

› Output: true

💡 Note: We can split [2,1,2,6] → [2,1,2] and [6]. Both are good: [2,1,2] has sum 5 ≥ 4, and [6] has length 1. Continue splitting [2,1,2] until all elements are separated.

Example 2 — Non-splittable Case

$ Input: nums = [2,1,1,1], m = 4

› Output: false

💡 Note: No two adjacent elements sum to 4 or more: 2+1=3, 1+1=2, 1+1=2. We cannot split any subarray of length > 2 while keeping both parts good.

Example 3 — Small Array

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

› Output: true

💡 Note: Arrays of length ≤ 2 can always be split into individual elements since single elements are always considered good.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 1000
1 ≤ m ≤ 200

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that we can split an array into individual elements if and only if we can find at least one pair of adjacent elements that sum to m or more, OR the array has length ≤ 2. The optimal greedy approach runs in O(n) time and O(1) space by simply checking adjacent pairs.

Common Approaches

✓ Dynamic Programming with Memoization

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

Use memoization to store whether each subarray range can be split. This avoids recalculating the same subproblems multiple times.

Greedy Observation

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

Key insight: if we can't split any subarray of length > 2, then no two adjacent elements sum to m or more. For arrays of length ≤ 2, splitting is always possible.

Recursive Backtracking

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

For each possible split point, recursively check if both halves can be completely split into single elements. Use backtracking to explore all possibilities.

Dynamic Programming with Memoization — Algorithm Steps

Use a memo table to cache results for each (left, right) range
Before computing, check if result already exists in memo
Store computed results in memo for future use

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Cache

Look up result for current range in memo table

Compute

If not cached, compute result recursively

Store

Cache the result for future lookups

Code -

solution.c — C

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

#define MAX_MEMO 10000

typedef struct {
    int left, right;
    bool result;
    bool used;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memoSize = 0;

bool getMemo(int left, int right) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].used && memo[i].left == left && memo[i].right == right) {
            return memo[i].result;
        }
    }
    return false;
}

bool hasMemo(int left, int right) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].used && memo[i].left == left && memo[i].right == right) {
            return true;
        }
    }
    return false;
}

void setMemo(int left, int right, bool result) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].left = left;
        memo[memoSize].right = right;
        memo[memoSize].result = result;
        memo[memoSize].used = true;
        memoSize++;
    }
}

bool canSplit(int* nums, int left, int right, int m) {
    if (left == right) {
        return true;
    }
    
    if (hasMemo(left, right)) {
        return getMemo(left, right);
    }
    
    long long currentSum = 0;
    for (int i = left; i <= right; i++) {
        currentSum += nums[i];
    }
    if (currentSum < m) {
        setMemo(left, right, false);
        return false;
    }
    
    for (int split = left; split < right; split++) {
        long long leftSum = 0, rightSum = 0;
        for (int i = left; i <= split; i++) {
            leftSum += nums[i];
        }
        for (int i = split + 1; i <= right; i++) {
            rightSum += nums[i];
        }
        
        bool leftGood = (split == left) || leftSum >= m;
        bool rightGood = (split + 1 == right) || rightSum >= m;
        
        if (leftGood && rightGood) {
            if (canSplit(nums, left, split, m) && canSplit(nums, split + 1, right, m)) {
                setMemo(left, right, true);
                return true;
            }
        }
    }
    
    setMemo(left, right, false);
    return false;
}

bool solution(int* nums, int numsSize, int m) {
    memoSize = 0;
    return canSplit(nums, 0, numsSize - 1, m);
}

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 main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int m;
    scanf("%d", &m);
    
    bool result = solution(nums, numsSize, m);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subproblems, each taking O(n) time to compute sums

✓ Linear Growth

Space Complexity

O(n²)

Memo table stores results for all possible (left, right) pairs

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

247 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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler