Number of Valid Subarrays

Number of Valid Subarrays - Problem

Given an integer array nums, return the number of non-empty subarrays with the leftmost element of the subarray not larger than other elements in the subarray.

A subarray is a contiguous part of an array.

Example: For array [1, 4, 2, 5, 3], the subarray [1, 4, 2] is valid because the leftmost element 1 is not larger than 4 and 2. However, [4, 2] is not valid because 4 > 2.

Input & Output

Example 1 — Basic Case

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

› Output: 11

💡 Note: Valid subarrays: Starting from index 0: [1], [1,4], [1,4,2], [1,4,2,5], [1,4,2,5,3] (5 total). Starting from index 1: [4] (1 total). Starting from index 2: [2], [2,5], [2,5,3] (3 total). Starting from index 3: [5] (1 total). Starting from index 4: [3] (1 total). Total: 5+1+3+1+1 = 11.

Example 2 — Single Element

$ Input: nums = [3]

› Output: 1

💡 Note: Only one subarray [3], which is valid since the leftmost (and only) element is not larger than itself.

Example 3 — Decreasing Array

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

› Output: 15

💡 Note: Every possible subarray is valid since each leftmost element is always >= subsequent elements. Total: 5+4+3+2+1 = 15 subarrays.

Constraints

1 ≤ nums.length ≤ 50,000
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is using a monotonic stack to efficiently find how far each element can extend as a leftmost element. The optimal approach uses a stack to maintain decreasing elements and calculates valid subarray counts in O(n) time with O(n) space.

Common Approaches

✓ Brute Force - Check All Subarrays

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

For each possible starting position, we extend the subarray to the right as long as the leftmost element is not larger than any element in the current subarray. Count all valid subarrays.

Monotonic Stack - Optimal Solution

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

For each element, we find how far it can extend as a leftmost element using a monotonic stack. The stack maintains elements in decreasing order, helping us quickly determine valid ranges.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: For each starting index i, initialize leftmost = nums[i]
Step 2: Extend subarray to the right, checking if leftmost <= current element
Step 3: Count valid subarrays and stop when leftmost > current element

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin with leftmost element as reference

Extend Right

Add elements while they're >= leftmost

Count Valid

Count each valid subarray found

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        int leftmost = nums[i];
        for (int j = i; j < n; j++) {
            if (nums[j] < leftmost) {
                break;
            }
            count++;
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop n times, inner loop up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

12.8K Views

Medium Frequency

~25 min Avg. Time

324 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

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler