Check if There is a Valid Partition For The Array

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

Imagine you're a puzzle master trying to break down a sequence of numbers into perfect groups! 🧩

You're given a 0-indexed integer array nums, and your mission is to partition it into one or more contiguous subarrays where each subarray follows one of these magical rules:

Twin Rule: Exactly 2 identical elements (like [5,5])
Triplet Rule: Exactly 3 identical elements (like [7,7,7])
Staircase Rule: Exactly 3 consecutive increasing elements with difference of 1 (like [3,4,5])

Your goal is to determine if you can create at least one valid partition using these rules. Return true if such a partition exists, otherwise return false.

Example: For [4,4,4,5,6], you can partition it as [4,4,4] (triplet rule) + [5,6] - wait, [5,6] doesn't follow any rule! So this would be false.

Input & Output

example_1.py — Basic Valid Partition

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

› Output: false

💡 Note: We can form [4,4,4] (triplet rule) but [5,6] doesn't satisfy any rule (needs exactly 2 or 3 elements, and they're not equal or consecutive with size 3).

example_2.py — Multiple Valid Partitions

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

› Output: false

💡 Note: We can partition as [1,1,1] + [2], but [2] is a single element which doesn't satisfy any rule. We could try [1,1] + [1,2] but [1,2] also doesn't work.

example_3.py — Consecutive Sequence

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

› Output: true

💡 Note: We can partition as [1,1,1] (triplet rule) + [1,2,2] - wait, that doesn't work. Actually [1,1] + [1,1] + [2,2] works! Three pairs following the twin rule.

Visualization

Tap to expand

Understanding the Visualization

Examine cookie line

Look at cookies from left to right: 🍪🍪🍪🥨🧁

Try jar rules

Can we fit first 3 cookies in one jar? Yes! (triplet rule)

Check remaining

Now we have 🥨🧁 left - can these follow any jar rule?

Determine validity

🥨🧁 are only 2 items and different - doesn't work!

Key Takeaway

🎯 Key Insight: At each position, we only need to know if the remaining elements can be validly partitioned - this creates a perfect dynamic programming opportunity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per position

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store results for each position

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Array must be partitioned completely (no elements left out)
All subarrays must be contiguous

Asked in

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

This problem is optimally solved using bottom-up dynamic programming in O(n) time. The key insight is that at each position, we only need to know if the remaining array can be validly partitioned. We build a DP array from right to left, trying each of the three partition rules (twin, triplet, staircase) at every position.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n)	O(n)	Cache results of subproblems to avoid recomputation
Recursive Backtracking	O(3^n)	O(n)	Try all possible ways to partition the array recursively
Bottom-Up Dynamic Programming (Optimal)	O(n)	O(n)	Iterative DP solution that builds up results from smaller subproblems

Dynamic Programming with Memoization — Algorithm Steps

Create a memoization table to store results for each index
Start recursion from index 0
Before computing, check if result for current index exists in memo
If not in memo, try all three partitioning rules
Store the result in memo before returning
Return cached result for subsequent calls with same index

Visualization

Tap to expand

Step-by-Step Walkthrough

First computation

Calculate result for index and store in cache

Cache lookup

For subsequent calls, return cached result immediately

Memory efficiency

Each index computed only once, dramatically reducing time complexity

Code -

solution.c — C

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

typedef struct {
    int index;
    bool result;
} MemoEntry;

MemoEntry memo[1001];
int memoSize = 0;

bool getMemo(int index) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].index == index) {
            return memo[i].result;
        }
    }
    return false;
}

bool hasMemo(int index) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].index == index) {
            return true;
        }
    }
    return false;
}

void setMemo(int index, bool result) {
    memo[memoSize].index = index;
    memo[memoSize].result = result;
    memoSize++;
}

bool canPartition(int* nums, int numsSize, int index) {
    if (index == numsSize) {
        return true;
    }
    
    if (hasMemo(index)) {
        return getMemo(index);
    }
    
    bool result = false;
    
    // Try 2 equal elements
    if (index + 1 < numsSize && nums[index] == nums[index + 1]) {
        result = result || canPartition(nums, numsSize, index + 2);
    }
    
    // Try 3 equal elements
    if (!result && index + 2 < numsSize && 
        nums[index] == nums[index + 1] && 
        nums[index + 1] == nums[index + 2]) {
        result = result || canPartition(nums, numsSize, index + 3);
    }
    
    // Try 3 consecutive elements
    if (!result && index + 2 < numsSize && 
        nums[index + 1] == nums[index] + 1 && 
        nums[index + 2] == nums[index] + 2) {
        result = result || canPartition(nums, numsSize, index + 3);
    }
    
    setMemo(index, result);
    return result;
}

bool validPartition(int* nums, int numsSize) {
    memoSize = 0;
    return canPartition(nums, numsSize, 0);
}

int main() {
    int nums[] = {4,4,4,5,6};
    int size = 5;
    printf("%s\n", validPartition(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each index is processed exactly once, and for each index we do constant work

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores one result per index, plus recursion stack

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Array must be partitioned completely (no elements left out)
All subarrays must be contiguous

23.5K Views

Medium-High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler