Find the Count of Monotonic Pairs II - Practice Coding Problems

Find the Count of Monotonic Pairs II - Problem

Array Math Dynamic Programming Combinatorics Prefix Sum Hard

Imagine you have an array of positive integers and need to decompose each number into two parts that follow opposite trends across the array.

Given an array nums of length n, you need to find how many ways you can create two arrays:

arr1: A non-decreasing sequence (values stay same or increase)
arr2: A non-increasing sequence (values stay same or decrease)

The key constraint: arr1[i] + arr2[i] = nums[i] for every position i.

Example: If nums = [2, 3, 2], one valid pair could be:

arr1 = [0, 1, 1] (non-decreasing: 0 ≤ 1 ≤ 1)
arr2 = [2, 2, 1] (non-increasing: 2 ≥ 2 ≥ 1)
Check: [0+2, 1+2, 1+1] = [2, 3, 2] ✓

Return the total count of such monotonic pairs modulo 10^9 + 7.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, 2]

› Output: 4

💡 Note: Valid pairs: ([0,1,1],[2,2,1]), ([0,2,2],[2,1,0]), ([1,2,2],[1,1,0]), ([2,3,2],[0,0,0])

example_2.py — Single Element

$ Input: nums = [5]

› Output: 6

💡 Note: For single element, arr1 can be 0,1,2,3,4,5 and arr2 will be 5,4,3,2,1,0 respectively. All 6 combinations are valid.

example_3.py — Increasing Sequence

$ Input: nums = [5, 5, 5, 5]

› Output: 126

💡 Note: With identical values, we have maximum flexibility in distribution while maintaining monotonic constraints.

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 1000
Both arr1 and arr2 contain non-negative integers
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Start with constraints

arr1 must be non-decreasing, arr2 must be non-increasing

Try all combinations

For each position, split nums[i] between arr1[i] and arr2[i]

Check validity

Ensure monotonic properties are maintained

Count solutions

Sum all valid complete decompositions

Key Takeaway

🎯 Key Insight: Use DP to systematically explore all valid decompositions while respecting monotonic constraints, memoizing intermediate results to avoid redundant computation.

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming with memoization to count monotonic pairs efficiently. The key insight is to define states as (position, last_arr1_value, last_arr2_value) and use constraints to limit the search space, achieving O(n × max(nums)²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n * max(nums)^2)	O(n * max(nums)^2)	Use DP to avoid recomputing subproblems by memoizing based on position and last values

Dynamic Programming with Memoization — Algorithm Steps

Define DP state as (position, last_arr1_value, last_arr2_value)
For each state, try all valid values for current position
Ensure arr1 values are non-decreasing and arr2 values are non-increasing
Use memoization to cache results for each state
Sum up all valid paths from initial state to final state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize state

Start with (pos=0, last1=0, last2=∞)

Explore transitions

Try valid values maintaining constraints

Memoize results

Cache computed results to avoid recomputation

Aggregate solutions

Sum all valid paths to final state

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 1000000

typedef struct {
    int pos, last1, last2;
    int result;
} State;

State memo[MAX_STATES];
int memoSize = 0;

int findMemo(int pos, int last1, int last2) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].last1 == last1 && memo[i].last2 == last2) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, int last1, int last2, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].pos = pos;
        memo[memoSize].last1 = last1;
        memo[memoSize].last2 = last2;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int pos, int last1, int last2, int* nums, int n) {
    if (pos == n) return 1;
    
    int cached = findMemo(pos, last1, last2);
    if (cached != -1) return cached;
    
    int count = 0;
    int start = (last1 > 0) ? last1 : 0;
    
    for (int val1 = start; val1 <= nums[pos]; val1++) {
        int val2 = nums[pos] - val1;
        if (val2 <= last2 && val2 >= 0) {
            count = (count + dp(pos + 1, val1, val2, nums, n)) % MOD;
        }
    }
    
    addMemo(pos, last1, last2, count);
    return count;
}

int countOfPairs(int* nums, int numsSize) {
    memoSize = 0;
    return dp(0, 0, 1000, nums, numsSize);
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max(nums)^2)

We have n positions and up to max(nums)^2 unique states per position

✓ Linear Growth

Space Complexity

O(n * max(nums)^2)

Memoization table stores results for all possible states

⚡ Linearithmic Space

26.1K 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler