Longest Non-decreasing Subarray From Two Arrays

Longest Non-decreasing Subarray From Two Arrays - Problem

You're given two parallel arrays nums1 and nums2, each of length n. Your mission is to create the optimal third array by choosing either nums1[i] or nums2[i] at each position i.

The goal is to maximize the length of the longest non-decreasing subarray in your constructed array. A non-decreasing subarray means each element is greater than or equal to the previous one.

Example:
If nums1 = [2, 3, 1] and nums2 = [1, 2, 3]
You could create [2, 3, 3] by choosing indices [0, 0, 1] respectively
This gives you a non-decreasing subarray of length 3!

Return the maximum possible length of the longest non-decreasing subarray you can achieve.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [2,3,1], nums2 = [1,2,3]

› Output: 3

💡 Note: We can construct [2,3,3] by choosing nums1[0], nums1[1], nums2[2]. This gives us a non-decreasing subarray of length 3: [2,3,3].

example_2.py — Optimal Switching

$ Input: nums1 = [1,3,2,1], nums2 = [2,2,3,4]

› Output: 4

💡 Note: We can construct [2,2,3,4] by choosing nums2[0], nums2[1], nums2[2], nums2[3]. This entire array is non-decreasing with length 4.

example_3.py — Single Element

$ Input: nums1 = [1], nums2 = [2]

› Output: 1

💡 Note: With only one position, we can choose either 1 or 2, giving us a non-decreasing subarray of length 1.

Constraints

1 ≤ nums1.length == nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁹
Both arrays have the same length

Visualization

Tap to expand

Understanding the Visualization

State Tracking

At each position, track the best sequences ending with each choice

Smart Transitions

Extend previous states only when the non-decreasing property is maintained

Optimal Choice

Choose the path that gives the maximum overall length

Key Takeaway

🎯 Key Insight: By tracking the best sequence length ending with each choice at every position, we can build the optimal solution without exploring all combinations.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with O(n) time complexity. We track two states at each position: the longest non-decreasing sequence ending with nums1[i] and the longest ending with nums2[i]. At each step, we can extend either state if the new element maintains the non-decreasing property. This approach efficiently finds the maximum length without exploring all 2^n combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track the longest sequences ending at each position with each possible choice

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP arrays: dp1[i] = longest sequence ending at i using nums1[i], dp2[i] = using nums2[i]
For each position i, calculate dp1[i] by extending from previous positions if possible
Similarly calculate dp2[i] by extending from previous positions
Track the maximum length seen so far
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Start with dp1[0]=1, dp2[0]=1 representing sequences of length 1

State Transition

For each position, calculate new states based on previous optimal choices

Track Maximum

Keep track of the maximum length seen across all positions and choices

Code -

solution.c — C

int maxNonDecreasingLength(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int n = nums1Size;
    if (n == 0) return 0;
    
    // dp1 = max length ending here using nums1[i]
    // dp2 = max length ending here using nums2[i]
    int dp1 = 1, dp2 = 1;
    int maxLength = 1;
    
    for (int i = 1; i < n; i++) {
        int newDp1 = 1, newDp2 = 1;
        
        // Try extending with nums1[i]
        if (nums1[i] >= nums1[i-1]) {
            newDp1 = (dp1 + 1 > newDp1) ? dp1 + 1 : newDp1;
        }
        if (nums1[i] >= nums2[i-1]) {
            newDp1 = (dp2 + 1 > newDp1) ? dp2 + 1 : newDp1;
        }
        
        // Try extending with nums2[i]
        if (nums2[i] >= nums1[i-1]) {
            newDp2 = (dp1 + 1 > newDp2) ? dp1 + 1 : newDp2;
        }
        if (nums2[i] >= nums2[i-1]) {
            newDp2 = (dp2 + 1 > newDp2) ? dp2 + 1 : newDp2;
        }
        
        dp1 = newDp1;
        dp2 = newDp2;
        maxLength = (dp1 > maxLength) ? dp1 : maxLength;
        maxLength = (dp2 > maxLength) ? dp2 : maxLength;
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per position

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous position states, can optimize to constant space

✓ Linear Space

41.3K Views

Medium Frequency

~18 min Avg. Time

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