Maximum Subarray Min-Product

Maximum Subarray Min-Product - Problem

The min-product of an array is equal to the minimum value in the array multiplied by the array's sum.

For example, the array [3,2,5] (minimum value is 2) has a min-product of 2 * (3+2+5) = 2 * 10 = 20.

Given an array of integers nums, return the maximum min-product of any non-empty subarray of nums. Since the answer may be large, return it modulo 10⁹ + 7.

Note that the min-product should be maximized before performing the modulo operation. Testcases are generated such that the maximum min-product without modulo will fit in a 64-bit signed integer.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 14

💡 Note: The subarray [2,3,2] has minimum 2 and sum 7, giving min-product = 2 × 7 = 14, which is maximum among all subarrays.

Example 2 — Single Element

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

› Output: 18

💡 Note: The subarray [2,3,3] has minimum 2 and sum 8, giving min-product = 2 × 8 = 16. But [3,3] has min-product = 3 × 6 = 18.

Example 3 — Large Numbers

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

› Output: 60

💡 Note: The subarray [5,6,4] has minimum 4 and sum 15, giving min-product = 4 × 15 = 60, which is the maximum.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 A Apple 12

The key insight is to find the largest subarray where each element serves as the minimum. The optimal approach uses a monotonic stack to efficiently find left and right boundaries for each element in O(n) time, combined with prefix sums for fast range queries. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Subarrays

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

For each starting position, expand the subarray one element at a time, tracking the minimum value and sum to calculate min-product.

Monotonic Stack (Optimal)

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

For each element, find the largest subarray where it is the minimum using a monotonic stack to track boundaries efficiently.

Prefix Sum Optimization

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

Precompute prefix sums to get any subarray sum in O(1) time. Still check all subarrays but avoid recalculating sums.

Brute Force - Check All Subarrays — Algorithm Steps

Generate all possible subarrays
For each subarray, find minimum and sum
Calculate min-product and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Calculate Min-Product

For each subarray, find min × sum

Track Maximum

Keep the largest min-product found

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long maxProduct = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Calculate min and sum for subarray nums[i:j+1]
            int currentMin = INT_MAX;
            long long currentSum = 0;
            for (int k = i; k <= j; k++) {
                if (nums[k] < currentMin) {
                    currentMin = nums[k];
                }
                currentSum += nums[k];
            }
            
            // Calculate min-product
            long long minProduct = (long long) currentMin * currentSum;
            if (minProduct > maxProduct) {
                maxProduct = minProduct;
            }
        }
    }
    
    return maxProduct % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: O(n²) subarrays × O(n) to find min and sum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current min, sum, and max result

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

982 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