2104 子数组范围和（ST表求解区间最值）

最新推荐文章于 2024-11-20 21:45:28 发布

原创最新推荐文章于 2024-11-20 21:45:28 发布 · 1.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

力扣专栏收录该内容

904 篇文章

订阅专栏

该篇博客介绍了如何使用ST表（区间最值表）解决一个关于求解整数数组所有子数组范围之和的问题。博主提供了详细的思路分析，包括使用ST表求解区间最值的方法，并给出了Python代码实现。最终，通过算法优化，虽然Python运行时间较长，但成功实现了求解目标。

1. 问题描述：

给你一个整数数组 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
-10 ^ 9 <= nums[i] <= 10 ^ 9
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sum-of-subarray-ranges/

2. 思路分析：

分析题目可以知道需要求解每一个区间的最值，而且区间的数字不会发生改变，所以想到ST表来求解区间静态最值问题（默写对应的ST算法模板），ST表预处理的时间复杂度为O(nlogn)，因为最终要求解每一个区间的最值所以总的算法时间复杂度为O(n ^ 2 + nlogn) ≈ O(n ^ 2) = 10 ^ 6，python运行比较慢，提交上去运行时间为8s多。除了使用ST表求解区间最值之外，还可以使用线段树来求解，只是线段树的代码会比较麻烦。

3. 代码如下：

from typing import List

import math
class Solution:
    def get(self, nums: List[int], maxv: List[List[int]], minv: List[List[int]]):
        # ST表求解区间最值
        n = len(nums)
        for j in range(n + 1):
            i = 0
            while i + (1 << j) - 1 < n:
                # 区间长度为1
                if j == 0:
                    maxv[i][j] = minv[i][j] = nums[i]
                else:
                    maxv[i][j] = max(maxv[i][j - 1], maxv[i + (1 << j - 1)][j - 1])
                    minv[i][j] = min(minv[i][j - 1], minv[i + (1 << j - 1)][j - 1])
                i += 1
                
                    
    def subArrayRanges(self, nums: List[int]) -> int:
        n = len(nums)
        k = int(math.log(n, 2))
        # nums最大值为10 ^ 9所以这里最大值可以取10 ^ 10
        INF = 10 ** 10
        maxv, minv = [[-INF] * (k + 10) for i in range(n + 10)], [[INF] * (k + 10) for i in range(n + 10)]
        self.get(nums, maxv, minv)
        res = 0
        for i in range(n):
            for j in range(i + 1, n):
                # k是中间的分割点
                k = int(math.log(j - i + 1, 2))
                res += max(maxv[i][k], maxv[j - (1 << k) + 1][k]) - min(minv[i][k], minv[j - (1 << k) + 1][k])
        return res