leetcode 907. 子数组的最小值之和

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

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

leetcode题目链接

示例 1：

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

提示：
1 <= arr.length <= 3 * 10^4
1 <= arr[i] <= 3 * 10^4

本来想用动态规划暴力破解，无奈数据庞大，O(n^2)超时
思路稍微说一下：二维数组存储长度为1~n的连续子数组中的最小值，
例如示例一：
3 1 2 4
1 1 2 0
1 1 0 0
1 0 0 0

• 第一层表示子数组长度为1，则有4个这样的子数组，每一个子数组的最小值为其自身的一个元素
• 第二层表示子数组长度为2，则有3个这样的子数组，每一个子数组的最小值，
  即arr[ i ][ j ]的值为上一行 arr[ i-1] [ j ] 和arr[ i-1] [ j+1]二者中的最小值
• 第三层同理，相当于将3个元素比较了2次

超时代码如下

class Solution {
public:
    int sumSubarrayMins(vector<int>& arr) {
        int n = arr.size();
        int mod = 1000000007;
        vector<vector<int>> dp(n);
        dp[0] = arr;
        for(int i=1; i<n; i++){
            dp[i] = vector<int>(n-i, 0);
        }

        int res = accumulate(arr.begin(), arr.end(), 0);
        for(int i=1; i<n; i++){
            for(int j=0; j<n-i; j++){
                dp[i][j] = min(dp[i-1][j], dp[i-1][j+1]);
                res = (res + dp[i][j])%mod;
            }
        }
        return res;
    }
};

看了大部分题解，统一单调栈思想。
如果说上述方法是正向思维：从所有的子数组找最小值，求和
那么单调栈则是逆向思维：以每个元素为最小值，找出其作为最小值的子数组的个数，求积
对于一个数组arr = [8, 4, 6, 5, 7, 9, 3, 0], 比如要找到 5 作为最小元素，所属于的子数组的个数

• 可以从 5 向左搜索，直到遇到第一个小于 5 的元素，也就是arr[ 1 ] = 4。 此时，5的左侧，比5小的元素个数left = 1个。
• 同理从5向右搜索，直到遇到第一个小于 5 的元素 , 找到arr[ 6 ] = 3, 此时，5的右侧，比5小的元素个数right = 2个。
• 则6, 5, 7, 9 可以组成 (left + 1) * (right + 1) = 2 * 3 = 6个满足5是最小元素的子数组，

class Solution {
public:
    int sumSubarrayMins(vector<int>& arr) {
        const int mod = 1000000007;
        //存储索引位置，方便计算个数
        stack<int> stack;
        //加入一个最小值，保证最后栈中的元素都能够弹出
        arr.push_back(0);
        int n = arr.size();
        long res = 0;
        for(int i=0; i<n; i++){
            //栈中元素以递增顺序插入
            while(!stack.empty() && arr[i] <= arr[stack.top()]){
                //当前参照的元素索引，注意：和arr[index]作比较
                int index = stack.top();
                stack.pop();
                //前一个索引位置，当栈为空时，值为-1
                int prev_index = -1;
                if (!stack.empty()) prev_index = stack.top();
                //index索引左侧比arr[index]大的元素个数
                int left = index - prev_index - 1;
                //index索引右侧比arr[index]大的元素个数
                int right = i - index - 1;
                res += long(arr[index]) * (left + 1) * (right + 1) % mod;
                res %= mod;
            }
            stack.push(i);
        }
        return res;
    }
};

执行用时：
88 ms, 在所有 C++ 提交中击败了86.15%的用户
内存消耗：38.5 MB, 在所有 C++ 提交中击败了75.57%的用户