Minimum Subarrays in a Valid Split - Practice Coding Problems

Minimum Subarrays in a Valid Split - Problem

You're given an integer array nums and need to split it into the minimum number of subarrays following a special rule.

The Rule: Each subarray must have its first and last elements share a common divisor greater than 1. In other words, gcd(first_element, last_element) > 1 for every subarray.

Your Mission: Find the minimum number of subarrays needed to split the entire array. If it's impossible to create a valid split, return -1.

Note: The GCD (Greatest Common Divisor) of two numbers is the largest positive integer that divides both numbers evenly. A subarray is a contiguous part of the original array.

Example: For array [4, 6, 15, 35], one valid split is [4, 6] and [15, 35] because gcd(4,6) = 2 > 1 and gcd(15,35) = 5 > 1.

Input & Output

example_1.py — Basic Valid Split

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

› Output: 2

💡 Note: We can split into [4, 6] and [15, 35]. gcd(4,6) = 2 > 1 and gcd(15,35) = 5 > 1, so both subarrays are valid. This gives us 2 subarrays total.

example_2.py — No Valid Split

$ Input: [4, 3, 15, 35]

› Output: -1

💡 Note: Starting with 4, we cannot form a valid subarray because gcd(4,3) = 1, gcd(4,15) = 1, and gcd(4,35) = 1. Since we must include 4 in some subarray, no valid split exists.

example_3.py — Single Element Arrays

$ Input: [6, 10, 15]

› Output: -1

💡 Note: Each single element forms a subarray where first == last, but gcd(x,x) = x. Since 6, 10, and 15 are all > 1, we might expect this to work, but we need to check if we can form larger subarrays. gcd(6,10) = 2 > 1, so [6,10] is valid, but then [15] alone has gcd(15,15) = 15 > 1, giving us 2 subarrays total. Actually this should return 2, not -1.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
Each subarray must be contiguous and non-empty
gcd(first, last) > 1 for each subarray in the split

Visualization

Tap to expand

Understanding the Visualization

Check Compatibility

For each possible subarray, check if gcd(first, last) > 1

Dynamic Programming

Use DP to build optimal solution: dp[i] = min subarrays for nums[0:i]

Extend Greedily

For each start position, extend as far as possible while maintaining GCD constraint

Return Result

dp[n] contains the minimum subarrays needed, or -1 if impossible

Key Takeaway

🎯 Key Insight: Use dynamic programming to build the optimal solution by trying all possible subarray extensions while checking the GCD constraint. The DP state dp[i] represents the minimum subarrays needed to validly split nums[0:i].

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses Dynamic Programming with time complexity O(n² × log(max(nums))). The key insight is to use dp[i] to track the minimum subarrays needed to split nums[0:i], then for each starting position, extend the subarray as far as possible while maintaining gcd(first, last) > 1. This greedy extension with DP memoization ensures we find the minimum number of valid subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(2^n × n)	O(n)	Try all possible ways to split the array and find the minimum valid split
Dynamic Programming (Optimal)	O(n² × log(max(nums)))	O(n)	Use DP to find minimum splits by extending subarrays as far as possible

Brute Force (Try All Splits) — Algorithm Steps

Generate all possible ways to split the array
For each split, check if every subarray has gcd(first, last) > 1
Track the minimum number of subarrays among valid splits
Return the minimum or -1 if no valid split exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Splits

Create all possible ways to divide the array

Validate Each Split

Check GCD constraint for each subarray in the split

Find Minimum

Among valid splits, return the one with minimum subarrays

Code -

solution.c — C

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

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

int backtrack(int* nums, int n, int idx, int* splits, int splitCount) {
    if (idx == n) {
        // Check if current split is valid
        for (int i = 0; i < splitCount; i += 2) {
            if (gcd(nums[splits[i]], nums[splits[i+1]]) <= 1) {
                return INT_MAX;
            }
        }
        return splitCount / 2;
    }
    
    int minSplits = INT_MAX;
    
    for (int end = idx; end < n; end++) {
        splits[splitCount] = idx;
        splits[splitCount + 1] = end;
        int result = backtrack(nums, n, end + 1, splits, splitCount + 2);
        if (result < minSplits) {
            minSplits = result;
        }
    }
    
    return minSplits;
}

int minimumSubarrays(int* nums, int n) {
    int* splits = (int*)malloc(2 * n * sizeof(int));
    int result = backtrack(nums, n, 0, splits, 0);
    free(splits);
    return result == INT_MAX ? -1 : result;
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
    }
    printf("%d\n", minimumSubarrays(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n possible splits, each taking O(n) time to validate and compute GCDs

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current split

⚡ Linearithmic Space

23.2K Views

Medium Frequency

~25 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 Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler