Longest Non-decreasing Subarray From Two Arrays

Longest Non-decreasing Subarray From Two Arrays - Problem

You are given two 0-indexed integer arrays nums1 and nums2 of length n.

Let's define another 0-indexed integer array, nums3, of length n. For each index i in the range [0, n - 1], you can assign either nums1[i] or nums2[i] to nums3[i].

Your task is to maximize the length of the longest non-decreasing subarray in nums3 by choosing its values optimally.

Return an integer representing the length of the longest non-decreasing subarray in nums3.

Note: A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We can choose nums1[0]=2, nums1[1]=3, and either nums1[2]=1 or nums2[2]=2 to form [2,3,1] or [2,3,2]. In both cases, the longest non-decreasing subarray is [2,3] with length 2.

Example 2 — Minimum Size

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

› Output: 1

💡 Note: With only one position, we can choose either nums1[0]=1 or nums2[0]=2. Either choice gives us an array of length 1, so the longest non-decreasing subarray has length 1.

Example 3 — All Increasing

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

› Output: 3

💡 Note: Both arrays are already non-decreasing. We can choose either nums1 entirely to get [1,2,3] or nums2 entirely to get [4,5,6]. Both give us a non-decreasing subarray of length 3.

Constraints

1 ≤ nums1.length == nums2.length ≤ 10⁵
-10⁹ ≤ nums1[i], nums2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use dynamic programming to track the maximum length of non-decreasing subarray ending at each position, considering both possible choices from nums1 and nums2. The optimal approach uses space-optimized DP with Time: O(n), Space: O(1).

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(n × 2^n) Space: O(n)

For each position, we can choose either nums1[i] or nums2[i]. We generate all 2^n possible combinations of choices, then for each combination, find the longest non-decreasing subarray and keep track of the maximum length.

Dynamic Programming - Track Best Choices

⏱️ Time: O(n) Space: O(n)

At each position i, we track the maximum length of non-decreasing subarray ending at position i. For each position, we consider both nums1[i] and nums2[i], and extend the best possible sequence from previous position.

Space-Optimized DP

⏱️ Time: O(n) Space: O(1)

Since we only need information from the previous position to compute current state, we can optimize space by using variables instead of a full DP array. This reduces space complexity from O(n) to O(1) while maintaining the same time complexity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int increments = 0;

int dfs(int node, int cost[], int n) {
    int leftChild = 2 * node;
    int rightChild = 2 * node + 1;
    
    // If leaf node, return its cost
    if (leftChild > n) {
        return cost[node - 1];
    }
    
    // Get costs from left and right subtrees
    int leftCost = dfs(leftChild, cost, n);
    int rightCost = rightChild <= n ? dfs(rightChild, cost, n) : leftCost;
    
    // Balance the subtrees by incrementing the cheaper one
    int maxSubtreeCost = leftCost > rightCost ? leftCost : rightCost;
    increments += (maxSubtreeCost - leftCost) + (maxSubtreeCost - rightCost);
    
    // Return total cost for this subtree
    return cost[node - 1] + maxSubtreeCost;
}

int solution(int cost[], int n) {
    if (n == 1) return 0;
    
    increments = 0;
    dfs(1, cost, n);
    return increments;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int cost[1000];
    int n = 0;
    char *token = strtok(line + 1, ",]");
    while (token != NULL) {
        cost[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(cost, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 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