Maximum Length of Semi-Decreasing Subarrays

Maximum Length of Semi-Decreasing Subarrays - Problem

Maximum Length of Semi-Decreasing Subarrays

You're given an integer array nums and need to find the longest semi-decreasing subarray. A subarray is semi-decreasing if its first element is strictly greater than its last element.

What you need to do:
• Find the longest contiguous sequence where first > last
• Return the length of this longest sequence
• Return 0 if no such subarray exists

Example: In array [7,6,5,4], the entire array is semi-decreasing since 7 > 4, so the answer is 4. In array [1,2,3,4], no semi-decreasing subarray exists, so the answer is 0.

Input & Output

example_1.py — Basic Case

$ Input: [7,6,5,4]

› Output: 4

💡 Note: The entire array [7,6,5,4] is semi-decreasing since 7 > 4. This gives us the maximum length of 4.

example_2.py — No Semi-Decreasing

$ Input: [1,2,3,4]

› Output: 0

💡 Note: No subarray exists where the first element is greater than the last element, so we return 0.

example_3.py — Mixed Values

$ Input: [3,1,4,1,5]

› Output: 4

💡 Note: The subarray [3,1,4,1] has first element 3 > last element 1, giving length 4. Other valid subarrays like [3,1] have shorter lengths.

Visualization

Tap to expand

Understanding the Visualization

Scan the Mountain

Process each elevation point from left to right, tracking where each elevation first appears

Find Downhill Routes

For each point, check if you can create a longer downhill run by starting from any higher elevation seen earlier

Track Longest Run

Keep updating your record for the longest valid downhill run found so far

Key Takeaway

🎯 Key Insight: The longest semi-decreasing subarray will always start at the first occurrence of the highest value in the optimal pair and end at the current position of a smaller value, maximizing the distance between them.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, with each element processed once

✓ Linear Growth

Space Complexity

O(n)

HashMap to store the leftmost position of each unique value

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
A subarray must have at least 1 element

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a single-pass approach with a hash map to track the leftmost position of each unique value. As we process each element, we check all previously seen values that are larger than the current element to find the maximum subarray length. This achieves O(n) time complexity by avoiding redundant comparisons and processing each element only once.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Index Mapping	O(n²)	O(n)	First pass builds index mapping, second pass finds maximum length
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray to find the longest semi-decreasing one
Optimized Single Pass (Optimal)	O(n)	O(n)	Use monotonic approach to track minimum values seen so far

Two-Pass with Index Mapping — Algorithm Steps

First pass: Record first and last occurrence of each value
Create sorted list of unique values
For each value, find the farthest position of any smaller value
Track maximum length found
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Record positions

Map each value to its first and last occurrence

Find value pairs

Look for pairs where first value > second value

Calculate distances

Compute subarray length for valid pairs

Code -

solution.c — C

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

typedef struct {
    int value;
    int first;
    int last;
} ValuePos;

int maxSubarrayLength(int* nums, int numsSize) {
    if (nums == NULL || numsSize == 0) {
        return 0;
    }
    
    // Find unique values and their positions
    ValuePos positions[1000];  // Assuming reasonable input size
    int uniqueCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (positions[j].value == nums[i]) {
                positions[j].last = i;
                found = 1;
                break;
            }
        }
        if (!found) {
            positions[uniqueCount].value = nums[i];
            positions[uniqueCount].first = i;
            positions[uniqueCount].last = i;
            uniqueCount++;
        }
    }
    
    int maxLength = 0;
    
    // Check all pairs for semi-decreasing condition
    for (int i = 0; i < uniqueCount; i++) {
        for (int j = 0; j < uniqueCount; j++) {
            if (positions[i].value > positions[j].value) {
                int length = positions[j].last - positions[i].first + 1;
                if (positions[i].first <= positions[j].last && length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    int nums[] = {7, 6, 5, 4};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maxSubarrayLength(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

First pass is O(n), but second pass can be O(n²) in worst case when comparing all unique values

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store first and last positions of each unique value

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
A subarray must have at least 1 element

34.4K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass with Index Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler