Maximum Subarray Min-Product - Practice Coding Problems

Maximum Subarray Min-Product - Problem

Maximum Subarray Min-Product

You're given an array of integers and need to find the maximum min-product among all possible non-empty subarrays.

The min-product of a subarray is calculated as:
minimum_value × sum_of_all_elements

For example, in subarray [3, 2, 5]:
• Minimum value: 2
• Sum: 3 + 2 + 5 = 10
• Min-product: 2 × 10 = 20

Your goal is to find the subarray that gives the highest min-product value. Since the result can be very large, return it modulo 10⁹ + 7.

Key insight: You want to find the optimal balance between having a large minimum value and a large sum in your subarray.

Input & Output

example_1.py — Basic case

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

› Output: 14

💡 Note: The maximum min-product is achieved by subarray [2,3,2] with minimum=2 and sum=7, giving min-product=2×7=14

example_2.py — Single element optimal

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

› Output: 18

💡 Note: The maximum min-product is achieved by subarray [3,3] with minimum=3 and sum=6, giving min-product=3×6=18

example_3.py — Entire array optimal

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

› Output: 60

💡 Note: The maximum min-product is achieved by subarray [5,6] with minimum=5 and sum=11, giving min-product=5×11=55. Actually, it's [5,6,4] with min=4, sum=15, product=60

Visualization

Tap to expand

Understanding the Visualization

Identify Materials

Each array element represents a building material with a certain strength value

Find Optimal Sections

For each material, find the longest section where it's the weakest (determines project strength)

Calculate Profits

Profit = material_strength × sum_of_all_materials_in_section

Choose Maximum

Select the section that gives the highest profit

Key Takeaway

🎯 Key Insight: Each element can be the minimum in exactly one optimal subarray. Use monotonic stack to efficiently find the boundaries where each element is the bottleneck, maximizing the balance between minimum value and subarray sum.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, prefix sum is O(n)

✓ Linear Growth

Space Complexity

O(n)

Space for prefix sum array and monotonic stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Return answer modulo 10⁹ + 7
All array elements are positive integers

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a monotonic stack to find, for each element, the largest subarray where it serves as the minimum. Combined with prefix sums for O(1) range queries, this achieves O(n) time complexity. The key insight is that each element can be the "bottleneck" (minimum) in exactly one optimal subarray.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack + Prefix Sum (Optimal)	O(n)	O(n)	Use monotonic stack to find boundaries where each element is minimum, then calculate max contribution
Brute Force (Check All Subarrays)	O(n³)	O(1)	Generate all possible subarrays, calculate min-product for each, and return the maximum

Monotonic Stack + Prefix Sum (Optimal) — Algorithm Steps

Build prefix sum array for O(1) range sum queries
Use monotonic increasing stack to find left boundaries (previous smaller element)
Use monotonic increasing stack to find right boundaries (next smaller element)
For each element as minimum, calculate the sum of the largest possible subarray
Track the maximum min-product across all elements
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Build prefix sums

Create prefix sum array for O(1) range sum queries

Find left boundaries

Use stack to find previous smaller elements

Find right boundaries

Use stack to find next smaller elements

Calculate max products

For each element as minimum, calculate contribution

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 100000

long long max_ll(long long a, long long b) {
    return a > b ? a : b;
}

int maxSumMinProduct(int* nums, int n) {
    // Build prefix sum array
    long long* prefix = (long long*)calloc(n + 1, sizeof(long long));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    // Find left boundaries (previous smaller element)
    int* left = (int*)malloc(n * sizeof(int));
    int* stack = (int*)malloc(n * sizeof(int));
    int top = -1;
    
    for (int i = 0; i < n; i++) {
        while (top >= 0 && nums[stack[top]] >= nums[i]) {
            top--;
        }
        left[i] = (top >= 0) ? stack[top] : -1;
        stack[++top] = i;
    }
    
    // Find right boundaries (next smaller element)
    int* right = (int*)malloc(n * sizeof(int));
    top = -1;
    
    for (int i = n - 1; i >= 0; i--) {
        while (top >= 0 && nums[stack[top]] >= nums[i]) {
            top--;
        }
        right[i] = (top >= 0) ? stack[top] : n;
        stack[++top] = i;
    }
    
    long long maxProduct = 0;
    for (int i = 0; i < n; i++) {
        // Sum of subarray from (left[i], right[i])
        int leftBound = left[i] + 1;
        int rightBound = right[i] - 1;
        long long subarraySum = prefix[rightBound + 1] - prefix[leftBound];
        long long product = (long long) nums[i] * subarraySum;
        maxProduct = max_ll(maxProduct, product);
    }
    
    free(prefix);
    free(left);
    free(right);
    free(stack);
    
    return maxProduct % MOD;
}

int main() {
    int nums[] = {1, 2, 3, 2};
    int n = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maxSumMinProduct(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, prefix sum is O(n)

✓ Linear Growth

Space Complexity

O(n)

Space for prefix sum array and monotonic stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Return answer modulo 10⁹ + 7
All array elements are positive integers

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 + Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler