<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 {
private:
    bool solve(int ind, int n, vector<int>&nums, vector<int>&dp){
        // base case
        if(ind==n){
            return true;
        }

        if(dp[ind]!=-1) return dp[ind];

        // nums[i] == nums[i+1]
        if(ind+1<n && nums[ind]==nums[ind+1]){
            bool res = solve(ind+2,n,nums,dp);
            if(res){
                return dp[ind] = res;
            }
        }

        // nums[i] == nums[i+1] == nums[i+2]
        if(ind+2<n && nums[ind]==nums[ind+1] && nums[ind+1]==nums[ind+2]){
            bool res = solve(ind+3,n,nums,dp);
            if(res){
                return dp[ind] = res;
            }
        }

        // nums[i+1] - nums[i] == nums[i+2] - nums[i+1] == 1
        if(ind+2<n && nums[ind+1]-nums[ind] == 1 && nums[ind+2] - nums[ind+1] == 1){
            bool res = solve(ind+3,n,nums,dp);
            if(res){
                return dp[ind] = res;
            }
        }

        return dp[ind] = false; 
    }
public:
    bool validPartition(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n+1,-1);
        // base case
        dp[n] = true;

        for(int ind = n-1; ind>=0; ind--){
            // nums[i] == nums[i+1]
            if(ind+1<n && nums[ind]==nums[ind+1]){
                bool res = dp[ind+2];
                if(res){
                    dp[ind] = res;
                    continue;
                }
            }

            // nums[i] == nums[i+1] == nums[i+2]
            if(ind+2<n && nums[ind]==nums[ind+1] && nums[ind+1]==nums[ind+2]){
                bool res = dp[ind+3];
                if(res){
                    dp[ind] = res;
                    continue;
                }
            }

            // nums[i+1] - nums[i] == nums[i+2] - nums[i+1] == 1
            if(ind+2<n && nums[ind+1]-nums[ind] == 1 && nums[ind+2] - nums[ind+1] == 1){
                bool res = dp[ind+3];
                if(res){
                    dp[ind] = res;
                    continue;
                }
            }

            dp[ind] = false;
        }

        return dp[0];
    }
};
90100