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

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

示例 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。
示例 2：

输入：arr = [11,81,94,43,3]
输出：444
 

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/sum-of-subarray-minimums

容易想到的一个思路是 确定区间的起始，遍历从该起点开始的所有区间，采用动态规划dp[s][i+1]=min(dp[s][i],arr[i+1]);

时间复杂度为n*(n-1)/2 后续测试用例规模增大会超时

思路:

考虑到每个元素都会作为某个区间的最小值，那么我们求出以该元素为最小值的区间，则该区间内任意包含该元素的子区间的最小值均为该元素，那么该元素乘以以

该元素作为最小值的子区间的个数就是该元素对最小值的和的贡献值

求出该元素为最小值的区间需要分别在该元素的左侧和右侧找到第一个比该元素小的元素

我们借助单调栈实现

单调栈

根据设置的元素排列顺序

在元素入栈时,将不满足排列顺序的 元素删去

例如 单调递减的单调栈在元素入栈时，依此检查栈顶的元素，如果栈顶元素比当前入栈元素大,出栈

直至栈空或者出现栈顶元素比入栈元素小 是否加入等于条件也决定是否为严格单调

非严格单调递减栈示例代码

1 stack<int> s;
2 void Push(int i){
3    while(!s.empty()&&s.top()>i){
4       s.pop();  
5      }
6     s.push(i);
7 }

对于数组的每个元素需要记录其左右找到的第一个比其小的元素的位置

首先向左遍历数组,如果单调栈为空,也就是说向左没有比自身还小的元素,我们用-1作为左边界,同时将其加入到栈中，

遍历下一个元素时，会依此检查栈顶元素是不是比自己大,找到的第一个比自己小的元素存到数组left中

？这里为什么只检查栈中元素是否比自身小呢？

由于我们连续遍历数组 下一个元素遍历开始时其前一个元素在栈顶，栈中依次是小于前一个元素的元素下标，也就是说没有被记录到栈中的是

比该元素的前一个元素要大的元素，我们为每一个元素向左寻找第一个比自身元素小的元素,如果前一个元素比当前元素大,那么比前一个元素大的元素肯定

不是第一个比自己小的元素，将其出栈判断比前一个元素小的元素是否符合要求，省去不必要的遍历，如果上一个元素比自身小,那么栈顶元素肯定是最接近自己的

并且比自己小的元素，也就是第一个比自己小的元素。

向右寻找第一个比自己小的元素思路类似，只不过从相反的方向开始遍历

AC代码如下

后续可能会做优化

class Solution {
public:
    int sumSubarrayMins(vector<int>& arr) {
     //子数组的最小值之和
     //最小栈 滑动窗口的最小值 动态规划
     //单调栈
     int res=0;
     int n=arr.size();
     vector<int> left(n,0);//向左找到第一个比自己大的元素
     vector<int> right(n,0);
     stack<int> l;
     stack<int> r;
     for(int i=0;i<n;i++){
         while(!l.empty()&&arr[l.top()]>arr[i]){
                 l.pop();
         }
         if(l.empty()){
             //当前元素的左边没有比当前元素更小的元素
             left[i]=-1;
         }
         else left[i]=l.top();
         l.push(i);
     //向右找第一个比自己大的元素
     while(!r.empty()&&arr[r.top()]>=arr[n-1-i]){
         r.pop();
     }
     if(r.empty()){
         right[n-1-i]=n;
     }else right[n-1-i]=r.top();
     r.push(n-1-i);
    }
    for(int i=0;i<n;i++){
      res=(res+(long)(i-left[i])*(right[i]-i)*arr[i])%(int)(1e9+7);
    }
    return res;
    }
};

注意 向左和向右寻找第一个比自己小的元素时，有一端是小于 另一端是小于等于，避免出现某个区间算重获算漏的情况