<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>. You have to partition the array into one or more <strong>contiguous</strong> subarrays.</p>

<p>We call a partition of the array <strong>valid</strong> if each of the obtained subarrays satisfies <strong>one</strong> of the following conditions:</p>

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

<p>Return <code>true</code><em> if the array has <strong>at least</strong> one valid partition</em>. Otherwise, return <code>false</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [4,4,4,5,6]
<strong>Output:</strong> true
<strong>Explanation:</strong> The array can be partitioned into the subarrays [4,4] and [4,5,6].
This partition is valid, so we return true.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,1,1,2]
<strong>Output:</strong> false
<strong>Explanation:</strong> There is no valid partition for this array.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>2 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
</ul>

class Solution:
    def validPartition(self, nums: List[int]) -> bool:
        # Good sub-array
        # - has 2 the same numbers
        # - has 3 the same numbers
        # - has 3 increasing numbers with diff of 1

        # We can try to partition array starting from every index between start_idx and end
        # We need to ensure that sub-array between start_idx and i is valid by some 4 conditions
        # i will be between start_idx + 1 and start_idx + 3

        # If partition is valid, we proceed to the next recursive call by moving the start_idx

        def is_valid_partition(arr):
            if len(arr) != 2 and len(arr) != 3:
                return False
            
            if len(arr) == 2:
                return arr[0] == arr[1]
            else:
                if arr[0] == arr[1] and arr[1] == arr[2]:
                    return True
                
                if arr[2] == arr[1] + 1 and arr[1] == arr[0] + 1:
                    return True
            
            return False

        cache = {}
        
        def process_partition(start_idx):
            if start_idx >= len(nums):
                return True

            if start_idx in cache:
                return cache[start_idx]
            
            for end_idx in range(start_idx + 1, start_idx + 3):
                partition = nums[start_idx:end_idx + 1]
                if is_valid_partition(partition) and process_partition(end_idx + 1):
                    return True
            cache[start_idx] = False
            return False
        
        return process_partition(0)
811