Find the Count of Monotonic Pairs I - Practice Coding Problems

Find the Count of Monotonic Pairs I - Problem

Array Math Dynamic Programming Combinatorics Prefix Sum Hard

You are given an array of positive integers nums of length n. Your task is to find the number of ways to split each element of nums into two non-negative integers such that:

The first part forms a monotonically non-decreasing array
The second part forms a monotonically non-increasing array

More formally, we need to count pairs of arrays (arr1, arr2) where:

Both arrays have length n
arr1[0] ≤ arr1[1] ≤ ... ≤ arr1[n-1] (non-decreasing)
arr2[0] ≥ arr2[1] ≥ ... ≥ arr2[n-1] (non-increasing)
arr1[i] + arr2[i] == nums[i] for all positions

Example: If nums = [2, 3, 2], one valid pair is arr1 = [0, 1, 1] and arr2 = [2, 2, 1] because 0+2=2, 1+2=3, 1+1=2, and the monotonicity conditions are satisfied.

Return the count modulo 10^9 + 7.

Input & Output

example_1.py — Basic Case

$ Input: [2, 3, 2]

› Output: 4

💡 Note: The 4 valid pairs are: ([0,0,0],[2,3,2]), ([0,1,1],[2,2,1]), ([1,1,1],[1,2,1]), ([2,3,2],[0,0,0]). Each satisfies arr1 non-decreasing and arr2 non-increasing.

example_2.py — Single Element

$ Input: [5]

› Output: 6

💡 Note: With one element, arr1 can be [0],[1],[2],[3],[4], or [5], and arr2 will be [5],[4],[3],[2],[1], or [0] respectively. All are valid since single-element arrays are trivially monotonic.

example_3.py — Increasing Sequence

$ Input: [2, 3, 4]

› Output: 6

💡 Note: Valid pairs include ([0,0,0],[2,3,4]), ([0,0,1],[2,3,3]), ([0,1,1],[2,2,3]), ([0,1,2],[2,2,2]), ([1,1,1],[1,2,3]), ([2,3,4],[0,0,0]). The constraints limit the valid combinations.

Constraints

1 ≤ n ≤ 2000
1 ≤ nums[i] ≤ 50
All elements of nums are positive integers
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Setup

Each building needs exactly nums[i] units of water from two sources

Constraints

Ground pressure can only increase, elevated pressure can only decrease

Count

Find all valid pressure distribution patterns

Key Takeaway

🎯 Key Insight: Use dynamic programming to track valid ground pressure levels at each position, automatically determining elevated pressure to satisfy building demands while maintaining system constraints.

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 5

The optimal solution uses dynamic programming to count valid monotonic pairs efficiently. The key insight is tracking possible values for arr1 at each position while ensuring both monotonicity constraints are satisfied. This avoids the exponential complexity of brute force approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n * sum²)	O(n * sum)	Use DP to count valid combinations by tracking possible arr1 values at each position

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table where dp[i][j] = ways to reach position i with arr1[i-1] = j
For each position i and each possible value j for arr1[i], check constraints
Ensure arr1[i] >= arr1[i-1] (non-decreasing constraint)
Ensure arr2[i] <= arr2[i-1] where arr2[i] = nums[i] - arr1[i] (non-increasing constraint)
Sum all valid ways in the final position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set up DP table with base case dp[0][0] = 1

Fill States

For each position, try all valid arr1 values

Check Constraints

Ensure arr1 non-decreasing and arr2 non-increasing

Sum Results

Add up all ways to reach the final position

Code -

solution.c — C

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

const int MOD = 1000000007;

int countOfPairs(int* nums, int n) {
    int maxSum = 0;
    for (int i = 0; i < n; i++) {
        maxSum += nums[i];
    }
    
    // Allocate DP table
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)calloc(maxSum + 1, sizeof(long long));
    }
    dp[0][0] = 1;
    
    for (int i = 1; i <= n; i++) {
        for (int prevVal = 0; prevVal <= maxSum; prevVal++) {
            if (dp[i-1][prevVal] == 0) continue;
            
            for (int currVal = 0; currVal <= nums[i-1]; currVal++) {
                int arr2Curr = nums[i-1] - currVal;
                
                if (i == 1) {
                    dp[i][currVal] = (dp[i][currVal] + dp[i-1][prevVal]) % MOD;
                } else {
                    int arr2Prev = nums[i-2] - prevVal;
                    if (currVal >= prevVal && arr2Curr <= arr2Prev) {
                        dp[i][currVal] = (dp[i][currVal] + dp[i-1][prevVal]) % MOD;
                    }
                }
            }
        }
    }
    
    long long result = 0;
    for (int j = 0; j <= maxSum; j++) {
        result = (result + dp[n][j]) % MOD;
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
    }
    printf("%d\n", countOfPairs(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * sum²)

For each position (n), we iterate through all possible values (up to sum of nums), leading to quadratic behavior in the sum

✓ Linear Growth

Space Complexity

O(n * sum)

DP table stores states for each position and possible value

⚡ Linearithmic Space

28.9K Views

Medium Frequency

~35 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler