单调栈题目：子数组的最小值之和

题目

标题和出处

标题：子数组的最小值之和

出处：907. 子数组的最小值之和

难度

7 级

题目描述

要求

给定一个整数数组 $\text{arr}$，找到 $\text{min(b)}$ 的总和，其中 $\text{b}$ 的范围为 $\text{arr}$ 的每个（连续）子数组。由于答案可能很大，因此返回答案模 ${\text{10}}^{\text{9}}+\text{7}$。

示例

示例 1：

输入：$\text{arr = [3,1,2,4]}$
输出：$\text{17}$
解释：
子数组为 $\text{[3]}$，$\text{[1]}$，$\text{[2]}$，$\text{[4]}$，$\text{[3,1]}$，$\text{[1,2]}$，$\text{[2,4]}$，$\text{[3,1,2]}$，$\text{[1,2,4]}$，$\text{[3,1,2,4]}$。
最小值为 $\text{3}$，$\text{1}$，$\text{2}$，$\text{4}$，$\text{1}$，$\text{1}$，$\text{2}$，$\text{1}$，$\text{1}$，$\text{1}$。
和为 $\text{17}$。

示例 2：

输入：$\text{arr = [11,81,94,43,3]}$
输出：$\text{444}$

数据范围

• $\text{1}\le \text{arr.length}\le \text{3}\times {\text{10}}^{\text{4}}$
• $\text{1}\le \text{arr[i]}\le \text{3}\times {\text{10}}^{\text{4}}$

解法

思路和算法

假设数组 $\text{arr}$ 的长度是 $n$，则对于 $1\le l\le n$，数组 $\text{arr}$ 的长度 $l$ 的子数组有 $n-l+1$ 个，所有长度的子数组有 $\frac{n(n+1)}{2}$ 个。如果直接遍历每个子数组寻找最小值，则子数组的数量是 $O(n^2)$，每个子数组需要 $O(n)$ 的时间遍历，总时间复杂度是 $O(n^3)$，该时间复杂度过高，需要优化。

为了得到子数组的最小值之和，对于下标 $i$，需要找到最大的下标 $j$ 和最小的下标 $k$，满足 $j<i<k$ 且 $\text{arr}[j]\le \text{arr}[i]$ 和 $\text{arr}[k]\le \text{arr}[i]$，则子数组 $\text{arr}[j+1:k-1]$（表示数组 $\text{arr}$ 从下标 $j+1$ 到下标 $k-1$ 的子数组，包含下标 $j+1$ 和下标 $k-1$）的最小值是 $\text{arr}[i]$，子数组 $\text{arr}[j+1:k-1]$ 的任何一个包含下标 $i$ 的子数组的最小值也是 $\text{arr}[i]$。

由于最小值是 $\text{arr}[i]$ 的子数组必须包含下标 $i$，其开始下标必须大于等于 $j+1$，其结束下标必须小于等于 $k-1$，因此最小值是 $\text{arr}[i]$ 的子数组的数量是 $(i-j)\times (k-i)$。在子数组的最小值之和中，$\text{arr}[i]$ 被计算的次数是 $(i-j)\times (k-i)$，因此 $\text{arr}[i]$ 对子数组的最小值之和的贡献值是 $\text{arr}[i]\times (i-j)\times (k-i)$。

特别地，当下标 $i$ 左边的元素都大于 $\text{arr}[i]$ 时 $j=-1$，当下标 $i$ 右边的元素都大于 $\text{arr}[i]$ 时 $k=n$。这道题中可以假设 $\text{arr}[-1]=\text{arr}[n]=-\infty$。

上面的描述中，$\text{arr}[j]\le \text{arr}[i]$ 和 $\text{arr}[k]\le \text{arr}[i]$ 的小于等于号也可以改成小于号，虽然每个 $\text{arr}[i]$ 被计算的次数可能不同，但是所有子数组的最小值之和是相同的。

为了得到每个下标 $i$ 对应的下标 $j$ 和 $k$，可以使用单调栈。单调栈存储数组 $\text{arr}$ 的下标，满足从栈底到栈顶的下标对应的元素单调递增。

从左到右遍历数组 $\text{arr}$，当遍历到下标 $i$ 时，如果栈不为空且栈顶下标对应的元素大于等于 $\text{arr}[i]$，需要计算栈顶下标对应的元素是最小值的子数组的数量和该元素对子数组的最小值之和的贡献值。具体做法如下：

1. 将栈顶下标出栈，记为 $\text{minIndex}$，将 $\text{arr}[\text{minIndex}]$ 记为 $\text{minNum}$，表示当前考虑的子数组最小值；

2. 在将 $\text{minIndex}$ 出栈之后，记 $\text{prevIndex}$ 为对应元素小于等于 $\text{minNum}$ 的最大下标，如果栈不为空则 $\text{prevIndex}$ 为新的栈顶下标，如果栈为空则 $\text{prevIndex}=-1$；

3. 子数组 $\text{arr}[\text{prevIndex}+1:i-1]$ 的最小值是 $\text{minNum}$，子数组 $\text{arr}[\text{prevIndex}+1:i-1]$ 的任何一个包含下标 $\text{minIndex}$ 的子数组的最小值也是 $\text{minNum}$，因此在子数组的最小值之和中，$\text{minNum}$ 被计算的次数是 $(\text{minIndex}-\text{prevIndex})\times (i-\text{minIndex})$，$\text{minNum}$ 对子数组的最小值之和的贡献值是 $\text{minNum}\times (\text{minIndex}-\text{prevIndex})\times (i-\text{minIndex})$，将该贡献值加到子数组的最小值之和；

4. 如果栈不为空且栈顶下标对应的元素大于等于 $\text{arr}[i]$，则重复上述 3 步操作，直到栈为空或者栈顶下标对应的元素小于 $\text{arr}[i]$；

5. 将 $i$ 入栈。

上述操作中，下标 $i$ 入栈的条件是栈为空或者栈顶下标对应的元素小于 $\text{arr}[i]$，因此可以保证从栈底到栈顶的下标对应的元素单调递增。

遍历结束之后，如果单调栈不为空，则需要对栈内的每个下标计算该下标对应的元素在子数组的最小值之和中被计算的次数以及对子数组的最小值之和的贡献值。具体做法如下：

1. 将栈顶下标出栈，记为 $\text{minIndex}$，将 $\text{arr}[\text{minIndex}]$ 记为 $\text{minNum}$，表示当前考虑的子数组最小值；

2. 在将 $\text{minIndex}$ 出栈之后，记 $\text{prevIndex}$ 为对应元素小于等于 $\text{minNum}$ 的最大下标，如果栈不为空则 $\text{prevIndex}$ 为新的栈顶下标，如果栈为空则 $\text{prevIndex}=-1$；

3. 子数组 $\text{arr}[\text{prevIndex}+1:n-1]$ 的最小值是 $\text{minNum}$，子数组 $\text{arr}[\text{prevIndex}+1:n-1]$ 的任何一个包含下标 $\text{minIndex}$ 的子数组的最小值也是 $\text{minNum}$，因此在子数组的最小值之和中，$\text{minNum}$ 被计算的次数是 $(\text{minIndex}-\text{prevIndex})\times (n-\text{minIndex})$，$\text{minNum}$ 对子数组的最小值之和的贡献值是 $\text{minNum}\times (\text{minIndex}-\text{prevIndex})\times (n-\text{minIndex})$，将该贡献值加到子数组的最小值之和。

4. 重复上述 3 步操作，直到栈为空。

实现时，需要注意两个方面。一是在计算子数组的最小值之和时需要对 $10^9+7$ 取模，二是使用 $\text{long}$ 数据类型存储子数组的最小值之和避免溢出，计算结束时转成 $\text{int}$ 数据类型然后返回。

代码

class Solution {
    public int sumSubarrayMins(int[] arr) {
        final int MODULO = 1000000007;
        Deque<Integer> stack = new ArrayDeque<Integer>();
        long sum = 0;
        int length = arr.length;
        for (int i = 0; i < length; i++) {
            int num = arr[i];
            while (!stack.isEmpty() && arr[stack.peek()] >= num) {
                int minIndex = stack.pop();
                int minNum = arr[minIndex];
                int prevIndex = stack.isEmpty() ? -1 : stack.peek();
                long curSum = (long) minNum * (minIndex - prevIndex) * (i - minIndex) % MODULO;
                sum = (sum + curSum) % MODULO;
            }
            stack.push(i);
        }
        while (!stack.isEmpty()) {
            int minIndex = stack.pop();
            int minNum = arr[minIndex];
            int prevIndex = stack.isEmpty() ? -1 : stack.peek();
            long curSum = (long) minNum * (minIndex - prevIndex) * (length - minIndex) % MODULO;
            sum = (sum + curSum) % MODULO;
        }
        return (int) sum;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{arr}$ 的长度。需要遍历数组 $\text{arr}$ 一次，每个下标最多入栈和出栈各一次。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{arr}$ 的长度。空间复杂度主要取决于栈空间，栈内元素个数不会超过 $n$。