Sum of Subarray Minimums - Practice Coding Problems

Sum of Subarray Minimums - Problem

Sum of Subarray Minimums

Imagine you have an array of integers, and you need to find every possible contiguous subarray within it. For each subarray, you find its minimum element, then sum all these minimums together.

For example, with array [3, 1, 2, 4]:
• Subarrays of length 1: [3], [1], [2], [4] → minimums: 3, 1, 2, 4
• Subarrays of length 2: [3,1], [1,2], [2,4] → minimums: 1, 1, 2
• Subarrays of length 3: [3,1,2], [1,2,4] → minimums: 1, 1
• Subarrays of length 4: [3,1,2,4] → minimum: 1

Total sum: (3+1+2+4) + (1+1+2) + (1+1) + (1) = 17

Since the answer can be very large, return the result modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Array

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

› Output: 17

💡 Note: All subarrays: [3]→3, [1]→1, [2]→2, [4]→4, [3,1]→1, [1,2]→1, [2,4]→2, [3,1,2]→1, [1,2,4]→1, [3,1,2,4]→1. Sum = 3+1+2+4+1+1+2+1+1+1 = 17

example_2.py — Single Element

$ Input: [11,81,94,43,3]

› Output: 444

💡 Note: For each element, calculate how many subarrays it's the minimum for. Element 3 is minimum in many subarrays, contributing significantly to the total sum.

example_3.py — Edge Case

$ Input: [5]

› Output: 5

💡 Note: Single element array has only one subarray [5] with minimum 5, so the answer is 5.

Constraints

1 ≤ arr.length ≤ 3 × 10⁴
1 ≤ arr[i] ≤ 3 × 10⁴
Return answer modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Impact Zones

For each restaurant, find how far its influence extends left and right

Calculate Coverage

Each restaurant affects left_distance × right_distance segments as the minimum

Sum Total Impact

Multiply each restaurant's value by its coverage area

Key Takeaway

🎯 Key Insight: Calculate each element's contribution by finding how many subarrays it dominates, rather than generating all subarrays explicitly. Use monotonic stack to efficiently find the nearest smaller elements on both sides.

Asked in

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

The optimal solution uses a monotonic stack to calculate each element's contribution efficiently. Instead of generating all O(n²) subarrays, we determine how many subarrays each element serves as the minimum for by finding the previous and next smaller elements. This reduces time complexity from O(n³) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Monotonic Stack)	O(n)	O(n)	Use monotonic stack to calculate each element's contribution efficiently

Optimized Brute Force (Monotonic Stack) — Algorithm Steps

For each element, find the previous smaller element using monotonic stack
For each element, find the next smaller element using monotonic stack
Calculate how many subarrays each element is minimum for
Multiply element value by its subarray count contribution
Sum all contributions modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Build monotonic stack

Find previous smaller element for each position

Calculate distances

Determine how many elements each can dominate

Compute contribution

Multiply element × left_count × right_count

Sum all contributions

Add up all individual contributions

Code -

solution.c — C

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

int sumSubarrayMins(int* arr, int n) {
    const int MOD = 1000000007;
    
    // Arrays to store distances to previous and next smaller elements
    int* left = (int*)malloc(n * sizeof(int));
    int* right = (int*)malloc(n * sizeof(int));
    int* stack = (int*)malloc(n * sizeof(int));
    int top = -1;
    
    // Find previous smaller elements using monotonic stack
    for (int i = 0; i < n; i++) {
        while (top >= 0 && arr[stack[top]] > arr[i]) {
            top--;
        }
        left[i] = i - (top >= 0 ? stack[top] : -1);
        stack[++top] = i;
    }
    
    // Find next smaller elements using monotonic stack
    top = -1;
    for (int i = n - 1; i >= 0; i--) {
        while (top >= 0 && arr[stack[top]] >= arr[i]) {
            top--;
        }
        right[i] = (top >= 0 ? stack[top] : n) - i;
        stack[++top] = i;
    }
    
    // Calculate contribution of each element
    long long result = 0;
    for (int i = 0; i < n; i++) {
        long long contribution = ((long long) arr[i] * left[i] * right[i]) % MOD;
        result = (result + contribution) % MOD;
    }
    
    free(left);
    free(right);
    free(stack);
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int arr[1000];
    int n = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", sumSubarrayMins(arr, 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)

Monotonic stack can store up to n elements in worst case

⚡ Linearithmic Space

28.6K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Optimized Brute Force (Monotonic Stack) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler