Check if it is Possible to Split Array - Practice Coding Problems

Check if it is Possible to Split Array - Problem

Array Splitting Challenge

You're given an array nums of length n and an integer m. Your task is to determine whether you can completely break down this array into individual elements (arrays of size 1) through a series of strategic splits.

The Rules:
• An array is considered "good" if it has length 1 OR its sum ≥ m
• You can only split an array if BOTH resulting parts are "good"
• Keep splitting until you have n individual arrays

Goal: Return true if complete decomposition is possible, false otherwise.

This problem tests your understanding of dynamic programming and greedy algorithms - you need to find the optimal splitting strategy!

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: We can split [2,2,1] into [2,2] and [1]. Both parts are good: [2,2] has sum 4 ≥ m, and [1] has length 1. Then [2,2] can be split into [2] and [2], both with length 1.

example_2.py — Impossible Case

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

› Output: false

💡 Note: No matter how we split [2,1,2], we cannot make both parts good. For example, splitting at position 1 gives [2] (good, length 1) and [1,2] (sum=3 < 5, length > 1, so not good).

example_3.py — Edge Case

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

› Output: true

💡 Note: Array has length 2, so it can always be split into individual elements regardless of their sum.

Constraints

1 ≤ n ≤ 100
1 ≤ nums[i] ≤ 100
1 ≤ m ≤ 200
Key insight: Arrays of length ≤ 2 can always be split completely

Visualization

Tap to expand

Understanding the Visualization

Check Base Cases

Length 1 arrays are done, length 2 can always split

Try Split Positions

For each position, check if both sides are 'good'

Recursive Splitting

If split is valid, recursively split both parts

Memoize Results

Store results to avoid recalculating same subarrays

Key Takeaway

🎯 Key Insight: Use dynamic programming with memoization to efficiently explore all splitting strategies. Arrays of length ≤ 2 are always splittable, making this a powerful base case for recursion.

Asked in

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

The optimal solution uses dynamic programming with memoization to solve this problem efficiently. The key insight is that arrays of length ≤ 2 can always be split completely. For larger arrays, we try all possible split positions and recursively check if both parts can be split, using memoization to avoid recalculating the same subarrays. Time complexity: O(n³), Space complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n³)	O(n²)	Use memoization to avoid recalculating same subarrays

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization table to store results for each (start, end) range
Check base cases: length 1 (always true) or length 2 (check sum ≥ m)
For each split position, verify both parts are 'good'
Recursively solve subproblems with memoization
Store and return result for current range

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize memoization table

Create a table to store results for each (start, end) range

Solve subproblems once

Calculate each subarray result only once and store it

Reuse stored results

When the same subarray is encountered, return cached result

Build up solution

Combine subproblem results to solve larger problems

Code -

solution.c — C

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

#define MAX_N 1000

static int memo[MAX_N][MAX_N];
static int prefix[MAX_N + 1];
static bool memo_set[MAX_N][MAX_N];

int rangeSum(int start, int end) {
    return prefix[end + 1] - prefix[start];
}

bool canSplit(int start, int end, int m) {
    if (memo_set[start][end]) {
        return memo[start][end];
    }
    
    int length = end - start + 1;
    if (length == 1) {
        memo_set[start][end] = true;
        return memo[start][end] = 1;
    }
    if (length == 2) {
        bool result = rangeSum(start, end) >= m;
        memo_set[start][end] = true;
        return memo[start][end] = result ? 1 : 0;
    }
    
    for (int i = start; i < end; i++) {
        int leftSum = rangeSum(start, i);
        int rightSum = rangeSum(i + 1, end);
        
        bool leftGood = (i - start + 1) == 1 || leftSum >= m;
        bool rightGood = (end - i) == 1 || rightSum >= m;
        
        if (leftGood && rightGood) {
            if (canSplit(start, i, m) && canSplit(i + 1, end, m)) {
                memo_set[start][end] = true;
                return memo[start][end] = 1;
            }
        }
    }
    
    memo_set[start][end] = true;
    return memo[start][end] = 0;
}

bool canSplitArray(int* nums, int numsSize, int m) {
    if (numsSize <= 2) return true;
    
    // Clear memoization
    memset(memo_set, false, sizeof(memo_set));
    
    // Precompute prefix sums
    prefix[0] = 0;
    for (int i = 0; i < numsSize; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    return canSplit(0, numsSize - 1, m);
}

int main() {
    int nums[] = {2, 2, 1};
    int m = 4;
    printf("%s\n", canSplitArray(nums, 3, m) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

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

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table for all possible (start, end) pairs plus recursion stack

⚠ Quadratic Space

42.8K Views

Medium-High 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

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler