Minimum Subarrays in a Valid Split

Minimum Subarrays in a Valid Split - Problem

You are given an integer array nums. Splitting of an integer array nums into subarrays is valid if:

The greatest common divisor of the first and last elements of each subarray is greater than 1, and
Each element of nums belongs to exactly one subarray.

Return the minimum number of subarrays in a valid subarray splitting of nums. If a valid subarray splitting is not possible, return -1.

Note that:

The greatest common divisor of two numbers is the largest positive integer that evenly divides both numbers.
A subarray is a contiguous non-empty part of an array.

Input & Output

Example 1 — Basic Valid Split

$ Input: nums = [4,6,15,35]

› Output: 2

💡 Note: Split into [4,6] and [15,35]. GCD(4,6)=2>1 and GCD(15,35)=5>1, both valid.

Example 2 — Single Element Subarrays

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

› Output: 4

💡 Note: Each element forms its own subarray: [6], [2], [3], [4]. GCD of single element with itself is the element itself, all > 1.

Example 3 — Impossible Split

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

› Output: -1

💡 Note: First element is 1. Since GCD(1,x)=1 for any x, no valid subarray starting with 1 can have GCD>1.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

The key insight is that if the first element is 1, no valid split exists since GCD(1,x)=1. Otherwise, use dynamic programming to find minimum subarrays where each has GCD(first,last)>1. Best approach is memoized DP with Time: O(n³), Space: O(n).

Common Approaches

✓ Dynamic Programming with Memoization

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

Same recursive approach but store results of each starting position to avoid recalculating the same subproblems multiple times.

Greedy Approach

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

Start from the first element and try to extend the current subarray as far as possible while maintaining a valid GCD condition. Only start a new subarray when necessary.

Recursive Backtracking

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

For each position, try forming a subarray ending at every subsequent position. If the subarray is valid (GCD of first and last > 1), recursively solve for the remaining array.

Dynamic Programming with Memoization — Algorithm Steps

Use memoization table for each starting position
Check if result already computed
Calculate and store result if not cached
Return cached or computed result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Cache

Look up if result for current position already computed

Compute

If not cached, calculate minimum splits recursively

Store

Cache the result for future use

Code -

solution.c — C

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

int memo[1000];
int memoInitialized = 0;

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int dp(int* nums, int size, int start) {
    if (start == size) {
        return 0;
    }
    
    if (memo[start] != -1) {
        return memo[start];
    }
    
    int minSplits = INT_MAX;
    for (int end = start; end < size; end++) {
        if (gcd(nums[start], nums[end]) > 1) {
            int remaining = dp(nums, size, end + 1);
            if (remaining != INT_MAX) {
                int current = 1 + remaining;
                if (current < minSplits) {
                    minSplits = current;
                }
            }
        }
    }
    
    memo[start] = minSplits;
    return minSplits;
}

int solution(int* nums, int size) {
    if (!memoInitialized) {
        for (int i = 0; i < 1000; i++) {
            memo[i] = -1;
        }
        memoInitialized = 1;
    }
    
    for (int i = 0; i < size; i++) {
        memo[i] = -1;
    }
    
    int result = dp(nums, size, 0);
    return result == INT_MAX ? -1 : result;
}

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[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

n states, each trying n positions, GCD calculation is O(log min(a,b))

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization table stores results for n positions plus recursion stack

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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