2104. 子数组范围和 :「区间 DP」&「递推」&「单调栈」-CFANZ编程社区

题目描述

这是 LeetCode 上的 2104. 子数组范围和 ，难度为中等。

Tag : 「区间 DP」、「单调栈」

给你一个整数数组 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

进阶：你可以设计一种时间复杂度为的解决方案吗？

区间 DP（预处理）

数据范围为，最为朴素的三层循环为：枚举区间（左右端点）+ 扫描区间统计最值，并累加到答案中。该做法复杂度为，会 TLE。

考虑在此基础上优化，枚举所有区间的操作不好避免，考虑通过「预处理」手段来优化「扫描区间统计最值」操作，通常会将其优化为查表。

定义为区间范围内的最值情况，其中非即：代表区间内的最小值，代表区间内的最大值。

不失一般性考虑和该如何计算：区间的最值可由与更新而来：

最后再枚举所有区间统计答案即可。

代码：

class Solution {
    public long subArrayRanges(int[] nums) {
        int n = nums.length;
        int[][][] f = new int[n][n][2];
        for (int i = 0; i < n; i++) f[i][i][0] = f[i][i][1] = nums[i];
        for (int len = 2; len <= n; len++) {
            for (int l = 0; l + len - 1 < n; l++) {
                int r = l + len - 1;
                f[l][r][0] = Math.min(nums[r], f[l][r - 1][0]);
                f[l][r][1] = Math.max(nums[r], f[l][r - 1][1]);
            }
        }
        long ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                ans += f[i][j][1] - f[i][j][0];
            }
        }
        return ans;
    }
}

时间复杂度：区间 DP 复杂度为；统计范围和的复杂度为。整体复杂度为
空间复杂度：

枚举

更进一步，我们发现在转移计算的最值情况时，仅依赖于（小区间），因此我们可以使用两变量代替动规数组，边遍历边维护并统计答案。

代码：

class Solution {
    public long subArrayRanges(int[] nums) {
        int n = nums.length;
        long ans = 0;
        for (int i = 0; i < n; i++) {
            int min = nums[i], max = nums[i];
            for (int j = i + 1; j < n; j++) {
                min = Math.min(min, nums[j]);
                max = Math.max(max, nums[j]);
                ans += max - min;
            }
        }
        return ans;
    }
}

时间复杂度：
空间复杂度：

单调栈

假设有个区间，最终的表达式为个等式之和。

若某个，如果在这个区间中充当最大值，则在最终等式中以的形式出现次，如果在个区间中充当最小值，则在最终等式中以形式出现次。

因此我们可以统计每个成为区间最大值的次数和成为区间最小值的次数，为对于最终答案的贡献。

考虑如何统计每个成为区间最值的次数：

作为区间最大值的次数：找到左右最近一个不满足「小于等于」的位置，记其为和。此时区间左端点共有个选择，区间右端点共有个选择，根据乘法原理，区间个数为个；
作为区间最小值的次数：同理，找到左右最近一个不满足「大于等于」的位置，记其为和，区间个数为个。

值得注意的是，由于存在相同元素，因此上述两边均取等号的做法会导致某些区间被重复计算，因此我们可以令最近右端点的部分不取等号，确保区间统计不重不漏。

代码：

class Solution {
    int n;
    public long subArrayRanges(int[] nums) {
        n = nums.length;
        long[] min = getCnt(nums, true), max = getCnt(nums, false);
        long ans = 0;
        for (int i = 0; i < n; i++) ans += (max[i] - min[i]) * nums[i];
        return ans;
    }
    long[] getCnt(int[] nums, boolean isMin) {
        int[] a = new int[n], b = new int[n];
        Deque<Integer> d = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            while (!d.isEmpty() && (isMin ? nums[d.peekLast()] >= nums[i] : nums[d.peekLast()] <= nums[i])) d.pollLast();
            a[i] = d.isEmpty() ? -1 : d.peekLast();
            d.addLast(i);
        }
        d.clear();
        for (int i = n - 1; i >= 0; i--) {
            while (!d.isEmpty() && (isMin ? nums[d.peekLast()] > nums[i] : nums[d.peekLast()] < nums[i])) d.pollLast();
            b[i] = d.isEmpty() ? n : d.peekLast();
            d.addLast(i);
        }
        long[] ans = new long[n];
        for (int i = 0; i < n; i++) ans[i] = (i - a[i]) * 1L * (b[i] - i);
        return ans;
    }
}