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

class Solution:
    def countOfPairs(self, nums: List[int]) -> int:
        M = 10 ** 9 + 7
        n = len(nums)
        m = max(nums)
        dp = [[0 for _ in range(m+1)] for _ in range(n)]
        dp[0] = [1] * (nums[0]+1)
        prefix = [[0 for _ in range(m+1)] for _ in range(n)]
        for i in range(nums[0]+1):
            prefix[0][i] = dp[0][i] + (prefix[0][i-1] if i-1 >= 0 else 0)
            
        
        for i in range(1, n):
            for curr_val in range(nums[i]+1): # curr_val is the value we will append to the arr1.
                # if we append curr_val, than we have 0 to curr_val as previous value in arr1.
                # but wait, the previous value must be valid for arr2 also.
                # so if we append curr_val to arr1, than nums[i]-curr_val will be appended to arr2.
                # and if prev_val is previous value for arr1 ranging in 0 to curr_val, than previous value
                # for arr2 is nums[i-1]-prev_val.

                # notice the condition nums[i]-curr_val <= nums[i-1]-prev_val must hold true for it to be valid
                # for arr2.
                # rearrange the equation nums[i]-curr_val <= nums[i-1]-prev_val to 
                # prev_val <= nums[i-1]-(nums[i]-curr_val)
                # thus all prev_val in range min(curr_val, nums[i-1]-(nums[i]-curr_val)) is valid
                # we take min(curr_val, nums[i-1]-(nums[i]-curr_val)) because if nums[i-1]-(nums[i]-curr_val) is greater than curr_val, than it would be invalid for arr1.
                # so we can use prefix sum to calculate the sum of dp[i-1][prev_val] for all valid previous
                # values.
                j = min(nums[i-1]-(nums[i]-curr_val), curr_val)
                dp[i][curr_val] = prefix[i-1][j] % M
                prefix[i][curr_val] = dp[i][curr_val] + (prefix[i][curr_val-1] if curr_val-1 >= 0 else 0)
                prefix[i][curr_val]%=M
                
        return sum(dp[-1]) % M
167832