【LeetCode】子数组最小乘积的最大值

1856. 子数组最小乘积的最大值 - 力扣（LeetCode）

一、题目

一个数组的 最小乘积 定义为这个数组中 最小值 乘以 数组的 和 。

比方说，数组 [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 <= 105
• 1 <= nums[i] <= 107

二、代码

class Solution {
    public int maxSumMinProduct(int[] nums) {
        int n = nums.length;
        // 创建前缀和数组
        long[] preSum = new long[n];
        // 计算每一个位置的前缀和
        preSum[0] = nums[0];
        for (int i = 1; i < n; i++) {
            preSum[i] = preSum[i - 1] + nums[i];
        }

        // 这里用long类型，避免数据类型溢出
        long max = Long.MIN_VALUE;
        // 创建单调栈，里面存储的是数组下标，注意数组下标只能是int型，所以这里stack数组为int类型
        int[] stack = new int[n];
        // 栈顶指针
        int top = -1;
        // 遍历数组，执行单调栈的流程，找到单调栈弹出的这个数左边和右边距离它最近并且小于它的数
        // 找到的这两个数中间部分就是我们要的，这一部分子数组的最小值就是弹出单调栈的这个数
        for (int i = 0; i < n; i++) {
            // 完全是按照单调栈流程来执行   新加入的数小于栈顶，就需要将栈顶数弹出
            while (top != -1 && nums[stack[top]] >= nums[i]) {
                // 弹出栈顶数，注意ans是数组下标
                int ans = stack[top--];
                // 如果 top == -1，说明弹出数的下面没有压着任何数，说明在数组中这个数的左边全都比它大
                //      这种情况下要求的子数组就是下标0~i-1范围的数组，这个范围内是以nums[ans]为最小值的，并且累加和最大（包含的数最多）的子数组
                // 如果 top != -1，说明弹出数的下面还压着别的数，说明在数组中这个数左边到它下面压着的这个数之间的数都是比这个数大的，右边到使这个数弹出，即将压入栈中的这个数之前的数都是比这个数大的，所以这个子数组下标范围就是i-1~stack[top]+1，然后用下标利用前缀和规则去求指定区间的累加和
                // 前缀和公式：sum(arr, i, j) = arr[i] + arr[i + 1] + …. arr[j - 1] + arr[j] = sum(arr, 0, j) - sum(arr, 0, i - 1)
                max = Math.max(max, top == -1 ? preSum[i - 1] * nums[ans] : (preSum[i - 1] - preSum[stack[top]]) * nums[ans]);
            }

            // 将数据压入栈
            stack[++top] = i;
        }

        // 如果将数组遍历完，单调栈还没空，就继续依次弹出
        while (top != -1) {
            int ans = stack[top--];
            // 此时弹出的所有数，数组中在这这个数右边的所有数一定都比它大
            // 所以就只需要考虑它左边有没有比它小的数即可
            // 如果 top == -1，说明弹出数的下面没有压着任何数，说明在数组中这个数的左边全都比它大
            //      这种情况这个子数组就是从0~n-1，因为这个数左边和右边所有的数都比它大，那么整个数组的最小值就是这个数
            // 如果 top != -1，说明弹出数的下面还压着别的数，说明在数组中这个数左边到它下面压着的这个数之间的数都是比这个数大的，所以这个子数组下标范围就是当前这个数的下标压着的这个树的下标stack[top]+1~n-1
            max = Math.max(max, top == -1 ? preSum[n - 1] * nums[ans] : (preSum[n - 1] - preSum[stack[top]]) * nums[ans]);
        }
        
        return (int) (max % 1000000007);
    }
}

三、解题思路 

这个题就可以用单调栈求。

已知数组都是正数，i位置的值假设是x，要求的子数组必须以x作为最小值，如何能够得到一个子数组，并且保证它是符合上述条件的，并且累加和最大的子数组?

左边离x最近的比x小的，右边离x最近的比x小的中间这一部分连续的子数组就是我们需要的子数组（不包括左边和右边离x最近并且比x小的这两个数），中间这个子数组必然是以x作为最小值的子数组，并且累加和一定是最大的。因为整个数组是正数数组，子数组包括的数越多，那么累加和一定越大，当前这个子数组数量一定是满足要求的包含数量最大的子数组了。

其次就是要在代码中捋清楚下标和值，知道那些结构中存储的是下标，哪些是值。