Find the Number of Subarrays Where Boundary Elements Are Maximum

Find the Number of Subarrays Where Boundary Elements Are Maximum - Problem

Imagine you're analyzing data segments where you need to find special subarrays - those where the first and last elements are the rulers of their domain!

Given an array of positive integers nums, your task is to count how many subarrays have a unique property: the first and last elements of the subarray are equal to the largest element within that subarray.

What makes a subarray special?

The subarray's maximum value appears at both boundaries (first and last positions)
No element inside the subarray is larger than the boundary elements
Single-element subarrays automatically qualify (boundary = maximum)

Example: In [2, 4, 1, 4], the subarray [4, 1, 4] is special because both boundaries are 4 (the maximum), while [2, 4, 1] is not special because 2 ≠ 4 (the maximum).

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Valid subarrays: [1], [4], [3], [4], [1], [4,3,4]. Each single element forms a valid subarray, and [4,3,4] is valid because both boundaries are 4 (the maximum).

example_2.py — All Equal Elements

$ Input: nums = [3, 3, 3]

› Output: 6

💡 Note: Valid subarrays: [3], [3], [3], [3,3], [3,3], [3,3,3]. When all elements are equal, every subarray satisfies the condition since all elements are maximum.

example_3.py — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: Only one subarray [5] exists, and it satisfies the condition since the single element is both the first, last, and maximum element.

Visualization

Tap to expand

Understanding the Visualization

Identify Subarrays

Generate all possible contiguous subarrays from the input array

Find Maximum

For each subarray, determine the maximum element value

Check Boundaries

Verify if first and last elements equal the maximum

Count Valid

Increment counter for each subarray meeting the criteria

Key Takeaway

🎯 Key Insight: Every single element forms a valid subarray, and multi-element subarrays are valid only when the maximum value appears at both boundaries, ensuring no internal element exceeds the guards.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Space for the monotonic stack in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses a brute force method with O(n²) time complexity to check all possible subarrays. For each subarray, we verify if the first and last elements equal the maximum element within that range. While more advanced techniques like monotonic stacks can theoretically optimize this, the straightforward approach remains most reliable for this specific boundary condition problem.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stack to efficiently find valid subarrays where boundaries are maximum
Brute Force (Check All Subarrays)	O(n³)	O(1)	Generate all possible subarrays and check each one individually

Monotonic Stack (Optimal) — Algorithm Steps

Iterate through the array with a monotonic decreasing stack
For each element, pop elements from stack that are smaller
For each element, calculate how many valid subarrays end at this position
Use the stack to determine the range where current element is maximum
Sum up all valid subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Maintain Stack

Keep decreasing elements in stack

Process Element

For each element, determine its valid range

Count Subarrays

Calculate valid subarrays with current element

Update Result

Add count to final result

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int countSubarrays(int* nums, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int maxVal = nums[i];
            for (int k = i; k <= j; k++) {
                maxVal = max(maxVal, nums[k]);
            }
            
            if (nums[i] == maxVal && nums[j] == maxVal) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char ch;
    
    while (scanf("%d%c", &nums[n], &ch) && n < 1000) {
        n++;
        if (ch == '\n') break;
    }
    
    printf("%d\n", countSubarrays(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Space for the monotonic stack in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

27.3K Views

Medium Frequency

~25 min Avg. Time

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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler