leetcode1856.子数组最小乘积的最大值

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/maximum-subarray-min-product

题目描述

一个数组的最小乘积定义为这个数组中最小值乘以数组的和。
比方说，数组 [3,2,5] （最小值是 2）的最小乘积为 2 * (3+2+5) = 2 * 10 = 20 。
给你一个正整数数组 nums ，请你返回 nums 任意非空子数组的最小乘积的最大值。由于答案可能很大，请你返回答案对 109 + 7 取余的结果。
请注意，最小乘积的最大值考虑的是取余操作之前的结果。题目保证最小乘积的最大值在不取余的情况下可以用 64 位有符号整数保存。
子数组定义为一个数组的连续部分。

示例 1：
输入：nums = [1,2,3,2]
输出：14
解释：最小乘积的最大值由子数组 [2,3,2] （最小值是 2）得到。
2 * (2+3+2) = 2 * 7 = 14 。

示例 2：
输入：nums = [2,3,3,1,2]
输出：18
解释：最小乘积的最大值由子数组 [3,3] （最小值是 3）得到。
3 * (3+3) = 3 * 6 = 18 。

示例 3：

输入：nums = [3,1,5,6,4,2]
输出：60
解释：最小乘积的最大值由子数组 [5,6,4] （最小值是 4）得到。
4 * (5+6+4) = 4 * 15 = 60 。

提示：
1 <= nums.length <= 100000
1 <= nums[i] <= 10000000

解题思路

这题我们用单调栈的结构去解答，并单调栈还不熟悉的可以先看下单调栈的实现
计算的过程就是不断以每个元素为最小值的情况下，他所在数组的长度能有多长，因为正数集合的数组，数组越长值越大，最小值固定了，我们就找到最长的子数组就行了。
在单调栈中我们能找到左侧比他小的数字的下标，这样就能确定左右的边界，就能求出累加和乘以当前数字的大小，不断去比较，求出最大值就可以了：
以示例3，为例。nums = [3,1,5,6,4,2]
我们用图演示下流程：

因为要不断去计算区域累加和，所以就用辅助累加和数组来优化计算：

代码演示：

/**
     * 最大值
     * @param arr
     * @return
     */
    public static int maxSumMinProduct(int[] arr){
        int size = arr.length;
        long[]sums = new long[size];
        sums[0] = arr[0];
        //生成累加和数组
        for (int i = 1; i < size;i++){
            sums[i] = sums[i - 1] + arr[i];
        }
        //记录最大值
        long max = Long.MIN_VALUE;
        //用数组来优化栈结构,来节省常数时间的复杂度
        int[] stack = new int[size];
        //记录stack的实际大小
        int stackSize = 0;
        for (int i = 0; i < size;i++){
            //如果当前队列不为空,且队列中的值大于i位置的值了,说明到了右边界了,已经不是区域最小值了,我们先求出这个值
           while (stackSize != 0 && arr[stack[stackSize - 1]] >= arr[i]){
               //计算以J为最小值的情况,
               int j = stack[--stackSize];
               long ans = (stackSize == 0 ? sums[i - 1] : (sums[i - 1] - sums[stack[stackSize - 1]])) * arr[j];
               max = Math.max(max,ans);
           }
           //加入到队列中
            stack[stackSize++] = i;
        }

        //计算最后剩余在队列中的
        while (stackSize != 0){
            int j = stack[--stackSize];
            max = Math.max(max,
                    (stackSize == 0 ? sums[size - 1] : (sums[size - 1] - sums[stack[stackSize - 1]])) * arr[j]);
        }
        return (int) (max % 1000000007);
    }