<p>You are given an array of <strong>positive</strong> integers <code>nums</code> of length <code>n</code>.</p>

<p>We call a pair of <strong>non-negative</strong> integer arrays <code>(arr1, arr2)</code> <strong>monotonic</strong> if:</p>

<ul>
	<li>The lengths of both arrays are <code>n</code>.</li>
	<li><code>arr1</code> is monotonically <strong>non-decreasing</strong>, in other words, <code>arr1[0] &lt;= arr1[1] &lt;= ... &lt;= arr1[n - 1]</code>.</li>
	<li><code>arr2</code> is monotonically <strong>non-increasing</strong>, in other words, <code>arr2[0] &gt;= arr2[1] &gt;= ... &gt;= arr2[n - 1]</code>.</li>
	<li><code>arr1[i] + arr2[i] == nums[i]</code> for all <code>0 &lt;= i &lt;= n - 1</code>.</li>
</ul>

<p>Return the count of <strong>monotonic</strong> pairs.</p>

<p>Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>

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

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">nums = [2,3,2]</span></p>

<p><strong>Output:</strong> <span class="example-io">4</span></p>

<p><strong>Explanation:</strong></p>

<p>The good pairs are:</p>

<ol>
	<li><code>([0, 1, 1], [2, 2, 1])</code></li>
	<li><code>([0, 1, 2], [2, 2, 0])</code></li>
	<li><code>([0, 2, 2], [2, 1, 0])</code></li>
	<li><code>([1, 2, 2], [1, 1, 0])</code></li>
</ol>
</div>

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

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">nums = [5,5,5,5]</span></p>

<p><strong>Output:</strong> <span class="example-io">126</span></p>
</div>

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

<ul>
	<li><code>1 &lt;= n == nums.length &lt;= 2000</code></li>
	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
</ul>

MOD = 10**9 + 7
class Solution:
    def countOfPairs(self, nums: List[int]) -> int:
        n=len(nums)
        # cacheddp = [[] for _ in range(n)]
        cachedsumr = [[] for _ in range(n+1)]
        # @lru_cache(None)
        def dp(i, va):
            if i==n: return 1
            vb= nums[i]-va
            if i==n-1: return int(va>=0 and vb>=0)

            # if i>=n-1: return 1
            vb=nums[i]-va
            # va<=x<=nums[i+1]
            # vb>=nums[i+1]-x>=0
            return (sumr(i+1, nums[i+1]) - sumr(i+1, max(va, nums[i+1]-vb)-1))%MOD
            # res=0
            # for x in range(max(va, nums[i+1]-vb), nums[i+1]+1): res += dp(i+1, x)
            # return res%MOD
        
        # @lru_cache(None)
        def sumr(i, va):
            if not cachedsumr[i]:
                cachedsumr[i] = [0]*(nums[i]+1)
                cachedsumr[i][0] = dp(i, 0)
                for j in range(1, nums[i]+1):
                    cachedsumr[i][j] = (cachedsumr[i][j-1] + dp(i, j))%MOD
            if va<0: return 0
            va=min(va, nums[i])
            # print(i, va, nums[i], cachedsumr[i])
            return cachedsumr[i][va]
            # return e
            # return 0
            # return cachedsumr[i][va]
            # return (sumr(i, va-1) + dp(i, va))%MOD
        # for i in range(0, nums[0]+1):
        #     print(i, dp(0, i), dp(1, i))
        return sum(dp(0, va) for va in range(0, nums[0]+1))%MOD
227412