[LeetCode] 907. Sum of Subarray Minimums

Given an array of integers arr, find the sum of min(b), where b ranges over every (contiguous) subarray of arr. Since the answer may be large, return the answer modulo 109 + 7.

Example 1:

Input: arr = [3,1,2,4]
Output: 17
Explanation: 
Subarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. 
Minimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1.
Sum is 17.

Example 2:

Input: arr = [11,81,94,43,3]
Output: 444

Constraints:

• 1 <= arr.length <= 3 * 104
• 1 <= arr[i] <= 3 * 104

子数组的最小值之和。

给定一个整数数组 arr，找到 min(b) 的总和，其中 b 的范围为 arr 的每个（连续）子数组。

由于答案可能很大，因此 返回答案模 10^9 + 7 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/sum-of-subarray-minimums
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目给的是数组，要我们求的东西也很简单，就是找出 input 数组里所有的子数组，并且把每个子数组里的最小值拿出来，计算所有最小值的和。

暴力解不难想，可以手动找出所有的子数组，然后找每个子数组的最小值。但是介于题目的数据范围会到 10 的 4 次方，暴力解会超时。我直接介绍最优解单调栈。我参考了这个帖子。

单调栈的特点就是可以在 O(n) 的时间内找到数组里的一个拐点。如下代码，是一个单调递增栈的代码。当我们遍历到 A[i] 的时候，如果 A[i] 小于栈顶元素，那么我们就一直把栈顶元素弹出。弹出操作完毕之后，再放入 A[i]。这个操作我们很熟悉，但是对于这道题，单调栈巧妙的地方在于当我们从 while 循环跳出来之后，也就正好找到了包含 A[i] 的子数组的左边界，且 A[i] 是这个子数组的最小值。

for (int i = 0; i < A.size(); i++) {
    while(!in_stk.empty() && in_stk.top() > A[i]) {
        in_stk.pop();
    }
    in_stk.push(A[i]);
}

• 为什么找到了左边界？因为栈弹出元素的规则就是如果栈顶元素更大就弹出，且从栈里弹出的元素一定在 A[i] 的左侧，是先于 A[i] 被放入栈内的。所以如果 A[i] 是某一段子数组的最小值，那么他的左边界可以一直包含所有从栈中被弹出的元素
• 为什么 A[i] 是这一段子数组的最小值？因为他一直比栈顶元素小，直到遇到了一个比 A[i] 更小的元素。停下的位置就是左边界的位置。

我们通过这个方式可以找到所有包含 A[i] 且 A[i] 是最小值的子数组的左边界，我们同时也要找到右边界，才能确定整个子数组的长度。所以我们需要创建两个和 input 数组等长的数组，一个记录每个数字 A[i] 可以辐射到的左边界 left[i]，一个记录可以辐射到的右边界 right[i]。这个辐射范围的定义是以 A[i] 为最小值的子数组的左边界和右边界。最后结算的时候，对于每个数字 A[i]，以 A[i] 为最小值可以形成的子数组的数量 = i 到左边界的距离 * i 到右边界的距离。

最后需要提醒的是，每个数字 A[i] 都有可能是某个非空子数组的最小值，比如长度为 1 的子数组，只包含 A[i] 自身的子数组，A[i] 自然就是这个子数组的最小值。单调栈的做法真的很巧妙。

时间O(n)

空间O(n)

Java实现

class Solution {
    private int MOD = (int) Math.pow(10, 9) + 7;

    public int sumSubarrayMins(int[] arr) {
        // corner case
        if (arr == null || arr.length == 0) {
            return 0;
        }

        // normal case
        int len = arr.length;
        int[] left = new int[len];
        int[] right = new int[len];
        Deque<Integer> stack = new ArrayDeque<>();
        for (int i = 0; i < len; i++) {
            while (!stack.isEmpty() && arr[i] < arr[stack.peek()]) {
                stack.pop();
            }
            if (stack.isEmpty()) {
                left[i] = -1;
            } else {
                left[i] = stack.peek();
            }
            stack.push(i);
        }

        stack.clear();
        for (int i = len - 1; i >= 0; i--) {
            // 需要有一边是带等号的，才不会漏解
            while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) {
                stack.pop();
            }
            if (stack.isEmpty()) {
                right[i] = len;
            } else {
                right[i] = stack.peek();
            }
            stack.push(i);
        }

        long res = 0;
        for (int i = 0; i < len; i++) {
            res = (res + (long) (i - left[i]) * (right[i] - i) * arr[i]) % MOD;
        }
        return (int) res;
    }
}

这里我再提供一个只需要扫描一遍的做法，思路也是单调栈。刚才第一种做法，单调栈为什么扫描两次是因为对于每一个 A[i] ，我们第一次找到 A[i] 能cover到的左边界，第二次找到 A[i] 能cover到的右边界。现在我们只需要扫描一遍就可以做到。

注意一下扫描一遍的时候我们会得到什么信息。我们会将每个大于当前元素 A[i] 的元素出栈以向左求解得到第一个小于 A[i] 的元素，那么反过来对于每个出栈的元素，当前元素 A[i] 不就是向右比它更小的第一个元素吗？这就得到了被弹出元素的右边界。

每个大于 A[i] 的元素都会出栈，那么每个能入栈的元素在栈内相邻的那个元素，不就是刚刚出栈的那个元素的左边界吗？

时间O(n)

空间O(n)

Java实现

class Solution {
    public int sumSubarrayMins(int[] arr) {
        int MOD = (int) Math.pow(10, 9) + 7;
        int len = arr.length;
        long sum = 0;
        Deque<Integer> stack = new ArrayDeque<>();
        int j;
        int k;
        for (int i = 0; i <= len; i++) {
            int cur = i == len ? Integer.MIN_VALUE : arr[i];
            while (!stack.isEmpty() && cur < arr[stack.peek()]) {
                j = stack.pop();
                k = stack.isEmpty() ? -1 : stack.peek();
                sum += (long) arr[j] * (i - j) * (j - k);
            }
            stack.push(i);
        }
        return (int) (sum % (long) MOD);
    }
}

相关题目

907. Sum of Subarray Minimums

2104. Sum of Subarray Ranges

LeetCode 题目总结