Maximal Range That Each Element Is Maximum in It

Maximal Range That Each Element Is Maximum in It - Problem

You are given a 0-indexed array nums of distinct integers. Let us define a 0-indexed array ans of the same length as nums in the following way:

ans[i] is the maximum length of a subarray nums[l..r], such that the maximum element in that subarray is equal to nums[i].

Return the array ans.

Note that a subarray is a contiguous part of the array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,7,3,6,5]

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

💡 Note: For nums[0]=1: maximum subarray is [1] with length 1. For nums[1]=7: maximum subarray is [1,7,3,6,5] with length 5. For nums[2]=3: maximum subarray is [3] with length 1. For nums[3]=6: maximum subarray is [3,6,5] with length 3. For nums[4]=5: maximum subarray is [5] with length 1.

Example 2 — Increasing Array

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

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

💡 Note: In an increasing array, each element can be maximum for all subarrays starting from index 0 up to its position. So nums[i] has maximum range of i+1.

Example 3 — Single Element

$ Input: nums = [10]

› Output: [1]

💡 Note: With only one element, it can be maximum only in the subarray containing itself, which has length 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements in nums are distinct

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that each element can be maximum in a subarray only until we encounter a larger element on either side. The optimal approach uses monotonic stacks to find nearest larger elements efficiently. Time: O(n), Space: O(n)

Common Approaches

✓ Greedy

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

Brute Force - Check All Subarrays

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

For each element at index i, we iterate through all possible subarrays that include nums[i]. For each subarray, we check if nums[i] is the maximum element. We keep track of the longest such subarray.

Monotonic Stack - Optimal Solution

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

For each element, we need to find the leftmost and rightmost positions where it can be the maximum. This happens until we encounter a larger element. We use monotonic stacks to find the nearest larger element on both left and right sides.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums[100000];
static int ans[100000];
static int leftBound[100000];
static int rightBound[100000];
static int stack[100000];

void solution(int n) {
    // Find nearest larger element to the left
    for (int i = 0; i < n; i++) {
        leftBound[i] = -1;
    }
    int stackTop = -1;
    
    for (int i = 0; i < n; i++) {
        while (stackTop >= 0 && nums[stack[stackTop]] < nums[i]) {
            stackTop--;
        }
        if (stackTop >= 0) {
            leftBound[i] = stack[stackTop];
        }
        stack[++stackTop] = i;
    }
    
    // Find nearest larger element to the right
    for (int i = 0; i < n; i++) {
        rightBound[i] = n;
    }
    stackTop = -1;
    
    for (int i = n - 1; i >= 0; i--) {
        while (stackTop >= 0 && nums[stack[stackTop]] < nums[i]) {
            stackTop--;
        }
        if (stackTop >= 0) {
            rightBound[i] = stack[stackTop];
        }
        stack[++stackTop] = i;
    }
    
    // Calculate maximum range for each element
    for (int i = 0; i < n; i++) {
        ans[i] = rightBound[i] - leftBound[i] - 1;
    }
}

int main() {
    char line[500000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int n = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++; // Skip '['
        char* endPtr = strchr(ptr, ']');
        if (endPtr) {
            *endPtr = '\0';
            
            char* token = strtok(ptr, ",");
            while (token != NULL && n < 100000) {
                nums[n++] = (int)strtol(token, NULL, 10);
                token = strtok(NULL, ",");
            }
        }
    }
    
    solution(n);
    
    // Output as JSON array
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", ans[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

29.1K Views

Medium Frequency

~25 min Avg. Time

856 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