Check if There is a Valid Partition For The Array

Check if There is a Valid Partition For The Array - Problem

You are given a 0-indexed integer array nums. You have to partition the array into one or more contiguous subarrays.

We call a partition of the array valid if each of the obtained subarrays satisfies one of the following conditions:

The subarray consists of exactly 2, equal elements. For example, the subarray [2,2] is good.
The subarray consists of exactly 3, equal elements. For example, the subarray [4,4,4] is good.
The subarray consists of exactly 3 consecutive increasing elements, that is, the difference between adjacent elements is 1. For example, the subarray [3,4,5] is good, but the subarray [1,3,5] is not.

Return true if the array has at least one valid partition. Otherwise, return false.

Input & Output

Example 1 — Valid Partition Exists

$ Input: nums = [4,4,4,5,6]

› Output: false

💡 Note: We can form [4,4,4] (three equal elements) but [5,6] is invalid since 5≠6 (not equal elements). Therefore, no valid partition exists.

Example 2 — Three Equal Elements

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

› Output: true

💡 Note: The entire array [4,4,4] consists of exactly 3 equal elements, which is a valid subarray.

Example 3 — Consecutive Sequence

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

› Output: true

💡 Note: The entire array [1,2,3] consists of exactly 3 consecutive increasing elements (difference of 1 between adjacent elements).

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Meta 8

The key insight is to use dynamic programming to check if we can partition the array from each position. We work backwards, checking if we can form valid subarrays of length 2 (equal elements), 3 (equal elements), or 3 (consecutive). Best approach is bottom-up DP. Time: O(n), Space: O(n).

Common Approaches

✓ Dynamic Programming (Bottom-Up)

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

Use a DP array where dp[i] represents whether we can validly partition the subarray starting from index i. Fill the array from right to left, using previously computed results.

Memoized Recursion

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

Same recursive approach but cache results for each starting position. When we encounter the same subproblem again, return the cached result instead of recalculating.

Recursive Backtracking

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

Use recursion to try every possible way to split the array into subarrays. For each starting position, try forming a valid subarray of length 2 or 3, then recursively check if the remaining array can be validly partitioned.

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create DP array
Fill from right to left
For each position, check if valid subarrays can be formed
Use previous DP values to determine current result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array, set dp[n] = true (base case)

Fill Backwards

For each position, check if valid partitions possible

Result

dp[0] contains answer for entire array

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    bool* dp = (bool*)calloc(numsSize + 1, sizeof(bool));
    dp[numsSize] = true; // Empty array can always be partitioned
    
    for (int i = numsSize - 1; i >= 0; i--) {
        // Try length 2: two equal elements
        if (i + 1 < numsSize && nums[i] == nums[i + 1] && dp[i + 2]) {
            dp[i] = true;
        }
        // Try length 3: three equal elements
        else if (i + 2 < numsSize && 
                 nums[i] == nums[i + 1] && nums[i + 1] == nums[i + 2] && 
                 dp[i + 3]) {
            dp[i] = true;
        }
        // Try length 3: consecutive increasing
        else if (i + 2 < numsSize && 
                 nums[i + 1] == nums[i] + 1 && 
                 nums[i + 2] == nums[i] + 2 && 
                 dp[i + 3]) {
            dp[i] = true;
        }
    }
    
    bool result = dp[0];
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, constant work at each position

✓ Linear Growth

Space Complexity

O(n)

DP array of size n to store results for each position

⚡ Linearithmic Space

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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler