Sum of Subarray Ranges - Practice Coding Problems

Sum of Subarray Ranges - Problem

You are given an integer array nums. The range of a subarray is defined as the difference between the largest and smallest element in that subarray.

Your task is to return the sum of all subarray ranges of nums.

A subarray is a contiguous non-empty sequence of elements within an array. For example, if nums = [1, 2, 3], the subarrays are: [1], [2], [3], [1, 2], [2, 3], and [1, 2, 3].

Example: For nums = [1, 2, 3]:
- Subarray [1]: range = 1 - 1 = 0
- Subarray [2]: range = 2 - 2 = 0
- Subarray [3]: range = 3 - 3 = 0
- Subarray [1, 2]: range = 2 - 1 = 1
- Subarray [2, 3]: range = 3 - 2 = 1
- Subarray [1, 2, 3]: range = 3 - 1 = 2
Total sum: 0 + 0 + 0 + 1 + 1 + 2 = 4

Input & Output

example_1.py — Simple Array

$ Input: [1, 2, 3]

› Output: 4

💡 Note: Subarrays: [1] (range=0), [2] (range=0), [3] (range=0), [1,2] (range=1), [2,3] (range=1), [1,2,3] (range=2). Total: 0+0+0+1+1+2=4

example_2.py — Single Element

$ Input: [1]

› Output: 0

💡 Note: Only one subarray [1] with range = 1-1 = 0

example_3.py — Larger Array

$ Input: [1, 3, 3]

› Output: 4

💡 Note: Subarrays: [1] (range=0), [3] (range=0), [3] (range=0), [1,3] (range=2), [3,3] (range=0), [1,3,3] (range=2). Total: 0+0+0+2+0+2=4

Constraints

1 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i] ≤ 10⁹
Note: The array can contain duplicate elements

Visualization

Tap to expand

Understanding the Visualization

Identify the insight

Range = Max - Min, so sum of ranges = sum of all maximums - sum of all minimums

Use monotonic stacks

Track when each element is maximum/minimum using decreasing/increasing stacks

Count contributions

For each element, count how many subarrays it dominates as max/min

Calculate final result

Multiply each element by its contribution count and sum the differences

Key Takeaway

🎯 Key Insight: Instead of generating O(n²) subarrays, we use monotonic stacks to mathematically count each element's contribution as maximum/minimum, reducing time complexity from O(n³) to O(n).

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses monotonic stacks to solve this problem in O(n) time. The key insight is that the sum of subarray ranges equals the sum of subarray maximums minus the sum of subarray minimums. Using monotonic stacks, we can efficiently count how many subarrays each element contributes to as a maximum or minimum, avoiding the need to generate all O(n²) subarrays explicitly.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stacks to count contribution of each element as min/max
Brute Force (Nested Loops)	O(n³)	O(1)	Check every subarray, find min/max, calculate range and sum

Monotonic Stack (Optimal) — Algorithm Steps

Use monotonic decreasing stack to find how many subarrays each element is maximum in
Use monotonic increasing stack to find how many subarrays each element is minimum in
For each element, calculate its contribution as maximum and minimum
Return sum of maximum contributions minus sum of minimum contributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Key insight

Sum of ranges = Sum of maximums - Sum of minimums

Monotonic stack

Use stack to find contribution of each element as max/min

Count subarrays

Calculate how many subarrays each element dominates

Final calculation

Subtract minimum contributions from maximum contributions

Code -

solution.c — C

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

long long sumSubarrayMaximums(int* nums, int n) {
    int* stack = (int*)malloc((n + 1) * sizeof(int));
    int top = -1;
    long long result = 0;
    
    for (int i = 0; i <= n; i++) {
        while (top >= 0 && (i == n || nums[stack[top]] <= nums[i])) {
            int mid = stack[top--];
            int left = top >= 0 ? stack[top] : -1;
            int right = i;
            long long count = (long long)(mid - left) * (right - mid);
            result += (long long)nums[mid] * count;
        }
        stack[++top] = i;
    }
    
    free(stack);
    return result;
}

long long sumSubarrayMinimums(int* nums, int n) {
    int* stack = (int*)malloc((n + 1) * sizeof(int));
    int top = -1;
    long long result = 0;
    
    for (int i = 0; i <= n; i++) {
        while (top >= 0 && (i == n || nums[stack[top]] >= nums[i])) {
            int mid = stack[top--];
            int left = top >= 0 ? stack[top] : -1;
            int right = i;
            long long count = (long long)(mid - left) * (right - mid);
            result += (long long)nums[mid] * count;
        }
        stack[++top] = i;
    }
    
    free(stack);
    return result;
}

long long subArrayRanges(int* nums, int numsSize) {
    return sumSubarrayMaximums(nums, numsSize) - sumSubarrayMinimums(nums, numsSize);
}

int main() {
    int nums[1000];
    int n = 0;
    char ch;
    int num = 0;
    int sign = 1;
    int reading = 0;
    
    while ((ch = getchar()) != '\n') {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
            reading = 1;
        } else if (ch == '-') {
            sign = -1;
            reading = 1;
        } else if (ch == ',' || ch == ']') {
            if (reading) {
                nums[n++] = sign * num;
                num = 0;
                sign = 1;
                reading = 0;
            }
        }
    }
    
    printf("%lld\n", subArrayRanges(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 stacks

⚡ Linearithmic Space

68.2K Views

Medium Frequency

~25 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