Codestin Search App

Maximal Range That Each Element Is Maximum in It - Problem

You're given an array of distinct integers, and your task is to find the maximum range where each element can be the dominant leader!

For each element nums[i] in the array, you need to determine the longest possible subarray where nums[i] is the maximum element. Think of it as finding the "sphere of influence" for each number - how far can its dominance extend?

Goal: Return an array ans where ans[i] represents the maximum length of any subarray that contains nums[i] as its maximum element.

Example: In array [2, 1, 4, 9, 3], the element 9 can dominate the entire array (length 5), while 1 can only dominate a subarray of length 1 (just itself).

Input & Output

example_1.py — Basic Case

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

› Output: [2, 1, 3, 5, 1]

💡 Note: Element 2 can dominate subarray [2,1] (length 2). Element 1 can only dominate itself (length 1). Element 4 can dominate [2,1,4] (length 3). Element 9 can dominate the entire array (length 5). Element 3 can only dominate itself (length 1).

example_2.py — Ascending Order

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

› Output: [1, 1, 1, 1, 5]

💡 Note: In ascending order, each element (except the last) can only dominate itself, as there's always a greater element immediately to the right. The last element (5) can dominate the entire array since it's the global maximum.

example_3.py — Single Element

$ Input: [42]

› Output: [1]

💡 Note: With only one element, it can dominate a subarray of length 1 (itself).

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements in nums are distinct
The array is 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Identify Peaks

Each number represents a mountain peak of that height

Look Left

Find the nearest taller peak to the left (or mountain base if none)

Look Right

Find the nearest taller peak to the right (or mountain base if none)

Calculate Visibility

The visible range is everything between the blocking peaks

Key Takeaway

🎯 Key Insight: Use monotonic stack to efficiently find the nearest greater elements, which define the boundaries of each element's maximum range.

Asked in

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

The optimal solution uses a monotonic stack to efficiently find the nearest greater elements on both sides of each element. The key insight is that an element's maximum range is bounded by these nearest greater elements. This approach achieves O(n) time complexity with two linear passes through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stack to find nearest greater elements on both sides efficiently

Monotonic Stack (Optimal) — Algorithm Steps

Find the nearest greater element on the left for each position using a decreasing monotonic stack
Find the nearest greater element on the right for each position using a decreasing monotonic stack
For each element, calculate the range as (right_bound - left_bound - 1)
The maximum subarray length is this range where the element is the maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Left Boundaries

Find nearest greater element on the left using decreasing stack

Right Boundaries

Find nearest greater element on the right using decreasing stack

Calculate Range

For each element, range = right_bound - left_bound - 1

Code -

solution.c — C

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

int* maximalRanges(int* nums, int n) {
    // Find nearest greater element on the left
    int* leftBound = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        leftBound[i] = -1;
    }
    
    int* stack = (int*)malloc(n * sizeof(int));
    int top = -1;
    
    for (int i = 0; i < n; i++) {
        while (top >= 0 && nums[stack[top]] < nums[i]) {
            top--;
        }
        
        if (top >= 0) {
            leftBound[i] = stack[top];
        }
        
        stack[++top] = i;
    }
    
    // Find nearest greater element on the right
    int* rightBound = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        rightBound[i] = n;
    }
    
    top = -1;  // Clear stack
    
    for (int i = n - 1; i >= 0; i--) {
        while (top >= 0 && nums[stack[top]] < nums[i]) {
            top--;
        }
        
        if (top >= 0) {
            rightBound[i] = stack[top];
        }
        
        stack[++top] = i;
    }
    
    // Calculate maximum range for each element
    int* ans = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        ans[i] = rightBound[i] - leftBound[i] - 1;
    }
    
    free(leftBound);
    free(rightBound);
    free(stack);
    
    return ans;
}

int main() {
    int nums[] = {2, 1, 4, 9, 3};
    int n = 5;
    
    int* result = maximalRanges(nums, n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array, each element pushed and popped at most once

✓ Linear Growth

Space Complexity

O(n)

Space for the monotonic stack and result arrays

⚡ Linearithmic Space

68.4K Views

Medium-High 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler