单调栈 学习记录 数据结构

今天在刷leetcode的时候遇到这样一道题目

给你一个整数数组 nums 。nums 中，子数组的 范围 是子数组中最大元素和最小元素的差值。
返回 nums 中 所有 子数组范围的 和 。
子数组是数组中一个连续 非空 的元素序列。 

示例 1：
输入：nums = [1,2,3]
输出：4
解释：nums 的 6 个子数组如下所示：
[1]，范围 = 最大 - 最小 = 1 - 1 = 0 
[2]，范围 = 2 - 2 = 0
[3]，范围 = 3 - 3 = 0
[1,2]，范围 = 2 - 1 = 1
[2,3]，范围 = 3 - 2 = 1
[1,2,3]，范围 = 3 - 1 = 2
所有范围的和是 0 + 0 + 0 + 1 + 1 + 2 = 4
示例 2：
输入：nums = [1,3,3]
输出：4
解释：nums 的 6 个子数组如下所示：
[1]，范围 = 最大 - 最小 = 1 - 1 = 0
[3]，范围 = 3 - 3 = 0
[3]，范围 = 3 - 3 = 0
[1,3]，范围 = 3 - 1 = 2
[3,3]，范围 = 3 - 3 = 0
[1,3,3]，范围 = 3 - 1 = 2
所有范围的和是 0 + 0 + 0 + 2 + 0 + 2 = 4
示例 3：
输入：nums = [4,-2,-3,4,1]
输出：59
解释：nums 中所有子数组范围的和是 59

提示：
1 <= nums.length <= 1000
-109 <= nums[i] <= 109

第一眼看下来，就是一个暴力解决的问题。可以通过双重循环列举子数组的区间，同时维护max和min值解决问题。如下所示

#python3
def subArrayRanges(self, nums: List[int]) -> int:
        ans = 0
        if len(nums) == 1:
            return 0
        for i in range(len(nums)):
            Min = nums[i]
            Max = nums[i]
            for j in range(i,len(nums)):
                Max = max(nums[j],Max)
                Min = min(nums[j],Min)
                ans += Max - Min
        return ans

但是，该解法的时间复杂度有O(n²),能顺利通过完全是出于测试集给出的数组太短。那么我们把题目改一下，改成1<=nums.length<=1e6 ，会发现使用暴力解法会出现超时问题。那么，问题来了，如何将该题的时间复杂度降低到O(n)？
我们可以从单个元素的方面来考虑。以元素a_i来考虑，我们只需要了解，a是m个区间的最大值，n个区间的最小值，就可以通过a*(m-n)得到元素a对最终结果的贡献。
那么，问题就变成了如何求解m和n。显然，找到a左右两边第一个大于/小于a_i的元素的下标，再将两者相减，就可以得到想要的结果。
那么，我们的工作就很明确了，就是维护四个单调的容器，每个容器里装的都是单调增加/减少的元素的下标。
这里，我们就需要引入单调栈来解决问题了。

什么是单调栈？

从名字上就听的出来，单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈

单调递增栈：单调递增栈就是从栈底到栈顶数据是从大到小
单调递减栈：单调递减栈就是从栈底到栈顶数据是从小到大

那么使用这种思想我们重新来解决这个问题。

//C++
class Solution {
public:
    long long subArrayRanges(vector<int>& nums) {
        int n = nums.size();
        vector<int> lmin(n,0),lmax(n,0),rmin(n,0),rmax(n,0);
        stack<int> s;
        s.push(-1);
        for(int i = 0; i < n; i++){
            while(s.top() != -1 && nums[s.top()] <= nums[i])
            {
                s.pop();
            }
            lmax[i] = s.top();
            s.push(i);
        }

        s = stack<int>();
        s.push(-1);
        for(int i = 0; i < n; i++){
            while(s.top() != -1 && nums[s.top()] >= nums[i])
            {
                s.pop();
            }
            lmin[i] = s.top();
            s.push(i);
        }

        s = stack<int>();
        s.push(n);
        for(int i = n-1; i >= 0; i--){
            while(s.top() != n && nums[s.top()] < nums[i])
            {
                s.pop();
            }
            rmax[i] = s.top();
            s.push(i);
        }

        s = stack<int>();
        s.push(n);
        for(int i = n-1; i >= 0; i--){
            while(s.top() != n && nums[s.top()] > nums[i])
            {
                s.pop();
            }
            rmin[i] = s.top();
            s.push(i);
        }
        long long ans = 0;
        for (int i = 0; i < n; i++)
        {
            ans += nums[i] * 1L * (rmax[i]-i) * (i - lmax[i]);
            ans -= nums[i] * 1L * (rmin[i]-i) * (i - lmin[i]);
        }
        return ans;
    }
};