python刷题-单调栈

力扣https://leetcode-cn.com/problems/sum-of-subarray-ranges/

暴力法：

遍历每个序列的最大值最小值，时间复杂度为o(n2)

class Solution:
    def subArrayRanges(self, nums: List[int]) -> int:
        dp = 0
        for i in range(1, len(nums)):
            dpmin = nums[i]
            dpmax = nums[i]
            for j in range(i-1, -1, -1):
                if dpmin > nums[j]:
                    dpmin = nums[j]
                if dpmax < nums[j]:
                    dpmax = nums[j]
                dp += dpmax - dpmin
        return dp

单调栈：
时间复杂度o（n）

# 单调栈为什么可行：对于每个i而言，如果能保证出现在所有子序列中，那么可以认为对i的遍历完成，例如对于[1,2,3,4]的3而言，[1,2,3][2,3][3,4]都能遍历，
# 就可以认为对3的遍历完成([2,3,4]包含在对2的遍历里面)，也可以理解为以i为起点，可以到达各个终点。
# 首先，这道题可以拆分成求所有子序列的最大值减去最小值。我们可以利用单调栈寻找最小值（最大值同理），对于i而言，寻找比i小的数，往左数到j,往右数到k
# 那么包含i且以i为最小值的序列个数为（i-k）*（j-i）个，对于其他包含i但不以i为最小值的序列的遍历，将由k和j完成
# 去重复: 对于[...3,4,5,3...]而言，[3,4,5,3]会被重复计算，所以定义第一个3的下标比第二个3的下标小，认为第一个3小于第二个3

# 单调栈一般都会有特点，一个连续序列，对于每个序列都要找左边或右边最大或最小。说白了，如果你读题后有这样的感觉，一字长龙队，问队里每个人你最远能看到都有谁的头比你高或比你低，那9成是单调栈，而且是最高是递减栈，最低是递增栈。

class Solution1:
    def subArrayRanges(self, nums: List[int]) -> int:
        n = len(nums)
        minLeft, maxLeft = [0] * n, [0] * n
        minStack, maxStack = [], []
        for i, num in enumerate(nums):
            while minStack and nums[minStack[-1]] > num:
                minStack.pop()
            minLeft[i] = minStack[-1] if minStack else -1
            minStack.append(i)

            # 如果 nums[maxStack[-1]] == num, 那么根据定义，
            # nums[maxStack[-1]] 逻辑上小于 num，因为 maxStack[-1] < i
            while maxStack and nums[maxStack[-1]] <= num:
                maxStack.pop()
            maxLeft[i] = maxStack[-1] if maxStack else -1
            maxStack.append(i)

        minRight, maxRight = [0] * n, [0] * n
        minStack, maxStack = [], []
        for i in range(n - 1, -1, -1):
            num = nums[i]
            # 如果 nums[minStack[-1]] == num, 那么根据定义，
            # nums[minStack[-1]] 逻辑上大于 num，因为 minStack[-1] > i
            while minStack and nums[minStack[-1]] >= num:
                minStack.pop()
            minRight[i] = minStack[-1] if minStack else n
            minStack.append(i)

            while maxStack and nums[maxStack[-1]] < num:
                maxStack.pop()
            maxRight[i] = maxStack[-1] if maxStack else n
            maxStack.append(i)

        sumMax, sumMin = 0, 0
        for i, num in enumerate(nums):
            sumMax += (maxRight[i] - i) * (i - maxLeft[i]) * num
            sumMin += (minRight[i] - i) * (i - minLeft[i]) * num
        return sumMax - sumMin