LeetCode 907：子数组的最小值之和

Dak2n

已于 2023-11-29 16:16:39 修改

阅读量410

点赞数 10

文章标签： leetcode 算法

于 2023-11-28 00:04:04 首次发布

本文链接：https://blog.csdn.net/weixin_61787820/article/details/134655908

版权

题目：

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

解题：

解题思路和代码来源：超小白

解题方法一：动态规划（暴力）

注意：本解法会超出时间限制，但是抛开时间限制不谈，也是一种解法。

class Solution {
    private static final int MOD = 1000000007;

    public static int sumSubarrayMins(int[] arr) {
        if (arr == null || arr.length == 0) {//检查是否非空
            return 0;
        }

        int n = arr.length;//保存数组长度
        long ans = 0;//保存求和结果

        // 起点
        for (int i = 0; i < n; i++) {
            int min = arr[i];
            // 终点
            for (int j = i; j < n; j++) {
                min = Math.min(min, arr[j]);
                ans = (ans + min) % MOD;
            }
        }
        return (int) ans;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};//这里可以任意更换数组，用于测试
        System.out.println(sumSubarrayMins(arr));
    }
}

解析：

乍一看，这个两层循环让人摸不着头脑。但是实际上理解了解题思路，这道题就变得很简单。以我用于测试的数组为例，该数组的子数组有：

[1] [1,2] [1,2,3] [1,2,3,4]

[2] [2,3] [2,3,4]

[3] [3,4]

[4]

要注意，像[1,3] [1,3,4]这种并不算子数组，因为不连续

其实，你现在就可以根据我列出来的数组返回去看这个双重循环，外层循环就是拿到每一行第一个数组，而内层循环就是与每一行的数组进行比较（包括自身）。

当外层循环i=0时，min=arr[0]=1

内层循环表面上是分别将它和arr[1]、arr[2]、arr[3]比较

实际上是将[1]和[1,2] [1,2,3] [1,2,3,4]比较

因为[1]和自身比较得到的min肯定是自身，所以和[1,2]的比较就简化成和[2]的比较

后面也是一样，在和[2]比较完后，和[1,2,3]的比较就简化成和[3]的比较,以此类推。

解题方法二：单调栈+贡献值

import java.util.Deque;
import java.util.LinkedList;

class Solution {
    private static final int MOD = 1000000007;
     static int sumSubarrayMins(int[] arr) {
        // 处理边界情况
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int n = arr.length;
        // 每个元素辐射范围的左边界
        int[] left = new int[n];
        // 每个元素辐射范围的右边界
        int[] right = new int[n];
        Deque<Integer> stack = new LinkedList<>();

        // 第一次循环先找到所有元素的左边界
        for (int i = 0; i < n; i++) {
            // 向左找第一个小于等于E的元素
            while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
                stack.pop();
            }
            // 设立一个最左边界-1
            if (stack.isEmpty()) {
                left[i] = -1;
            } else {
                left[i] = stack.peek();
            }
            // 下标入栈，方便同时得到i和A[i]
            stack.push(i);
        }

        // 第二次循环找到所有元素的右边界
        stack.clear();
        for (int i = n - 1; i >= 0; i--) {
            // 向右找第一个小于E的元素
            while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) {
                stack.pop();
            }
            // 设立一个最右边界n
            if (stack.isEmpty()) {
                right[i] = n;
            } else {
                right[i] = stack.peek();
            }
            // 下标入栈，方便同时得到i和A[i]
            stack.push(i);
        }

        // 按照贡献度计算即可
        long ans = 0;
        for (int i = 0; i < n; i++) {
            ans = (ans + (long) (i - left[i]) * (right[i] - i) * arr[i]) % MOD;
        }
        return (int) ans;
    }

    public static void main(String[] args) {
        int[] arr = {4, 7, 1, 7, 1};
        System.out.println(sumSubarrayMins(arr));
    }
}

首先，先讲这里面使用的一种数据结构Deque，只讲使用到的特征和方法。

push方法：放入Deque中，举个例子，先push(1)，再push(2)
        Deque.push(1)后，Deque中：1    Deque.push(2)后，Deque中：2，1

pop方法：从Deque中取出，拿上面的Deque直接来用
        第一次Deque.pop()后，Deque中：1    第二次Deque.pop()后，Deque中：

peek方法：与pop方法类似，但是只是取值而不是取出，举个例子，Deque中：2，1
        Deque.peek()后，返回2，但是Deque中仍然有2，再peek()也还是返回2

接下来对解法进行讲解，我将这个解法分为三个部分：取左边界、取右边界，贡献值求和。首先对第一部分取左边界进行讲解。

取左边界

首先先给出一般的结论

首位必为-1
后一位比前一位大，取前一位下标
如果遇到先小后大，则需要进行分析。

        // 数组长度
        int n = arr.length;
        // 每个元素辐射范围的左边界
        int[] left = new int[n];
        // 每个元素辐射范围的右边界
        int[] right = new int[n];
        Deque<Integer> stack = new LinkedList<>();

        // 寻找所有元素的左边界
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
                // 进入条件为stack非空并且arr[i-1] > arr[i]
                // 你会说，欸不对啊，不是arr[stack.peek()] > arr[i]吗，不急，你慢慢看
                stack.pop();
            }
            if (stack.isEmpty()) {
                // 首位下标为0，左边界一定为-1
                left[i] = -1;
            } else {
                left[i] = stack.peek();
            }
            // 每个元素的下标都会入栈
            stack.push(i);
        }

仔细观察代码，stack 被用于存放元素的下标，left 被用于存放对应元素的左边界，首位的下标为0，它对应的左边界一定是-1，这是固定的，而在进行下一次循环之前，本次循环的元素的下标一定会被放进 stack ，所以此时

stack=[0]

left[-1,0,0,0,0]

进行第二次循环，此时需要对元素进行比较，观察传入的数组可知，不满足 arr[0] > arr[1] ，所以不能进入 while 循环，不能进入 while 循环意味着不会出栈元素，所以 stack 也不为空，直接进入 else，left[1] 取值stack中最外面的元素0（不是取出），并将i入栈，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[1,0]

left[-1,0,0,0,0]

进行第三次循环，arr[1] > arr[2]，进入while，将stack最外层的元素1取出，并继续比较（循环条件），仍有arr[0] > arr[2]，进入while，将 stack 最外层的元素0取出，至此，stack 为空，不满足while条件，满足if条件，执行left[2] = -1，入栈i，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[2]

left[-1,0,-1,0,0]

进行第四次循环，不满足arr[2] > arr[3]，不能进入while循环，不能进入while循环意味着不会出栈元素，所以stack也不为空，直接进入else，left[3] 取值stack中最外面的元素2（不是取出），入栈i，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[3,2]

left[-1,0,-1,2,0]

进行第五次循环，满足arr[3] > arr[4]，进入while，将stack最外层的元素3取出，并继续比较（循环条件），不满足arr[2] > arr[4]，不再进入while循环，stack非空，进入else，left[4] 取值stack中最外面的元素2（不是取出），并将i入栈，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[4,2]

left[-1,0,-1,2,2]

至此，寻找左边界结束，回答一个问题，进入条件为stack非空并且arr[i-1] > arr[i]，而不是arr[stack.peek()] > arr[i]，因为无论如何，前一个元素的下标都会入栈，所以肯定需要和前一个元素进行比较。

取右边界

先说一般结论

末尾对应数组长度n（末尾下标+1）
遇到前一位比后一位大，前一位对应边界为后一位下标
其他情况具体分析

        // 数组长度
        int n = arr.length;
        // 每个元素辐射范围的左边界
        int[] left = new int[n];
        // 每个元素辐射范围的右边界
        int[] right = new int[n];
        Deque<Integer> stack = new LinkedList<>();

        //清空stack
        stack.clear();

        // 第二次循环找到所有元素的右边界
        for (int i = n - 1; i >= 0; i--) {
            //在每个元素首次while循环时arr[stack.peek()] >= arr[i]可看作arr[i+1] >= arr[i]
            while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) {
                //arr[stack.peek()] >= arr[i]就出栈stack中一个元素
                stack.pop();
            }
            //为空则添加末尾下标+1
            if (stack.isEmpty()) {
                right[i] = n;
            } else {
                right[i] = stack.peek();
            }
            // 下标入栈
            stack.push(i);
        }

仔细观察代码，stack 被用于存放元素的下标，，并且在进入循环前会执行一次清空，right 被用于存放对应元素的右边界，与取左边界不同，右边界是从末尾开始比的，末尾的右边界一定是它的下标+1，而在进行下一次循环之前，本次循环的元素的下标一定会被放进 stack ，所以此时

int[] arr = {4, 7, 1, 7, 1};

stack=[4]

right[0,0,0,0,5]

进行第二次循环，此时需要对元素进行比较，观察传入的数组可知，不满足 arr[4] >= arr[3] ，所以不能进入 while 循环，不能进入 while 循环意味着不会出栈元素，所以 stack 也不为空，直接进入 else，right[1] 取值stack中最外面的元素4（不是取出），并将i入栈，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[3,4]

right[0,0,0,4,5]

进行第三次循环，arr[3] >= arr[2]，进入while，将stack最外层的元素3取出，并继续比较（循环条件），仍有arr[0] >= arr[2]，进入while，将 stack 最外层的元素4取出，至此，stack 为空，不满足while条件，满足if条件，执行right[2] = 5，入栈i，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[2]

right[0,0,5,4,5]

进行第四次循环，不满足arr[2] >= arr[1]，不能进入while循环，不能进入while循环意味着不会出栈元素，所以stack也不为空，直接进入else，right[1] 取值stack中最外面的元素2（不是取出），入栈i，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[1,2]

right[0,2,5,4,5]

进行第五次循环，满足arr[1] >= arr[0]，进入while，将stack最外层的元素1取出，并继续比较（循环条件），不满足arr[2] >= arr[0]，不再进入while循环，stack非空，进入else，right[0] 取值stack中最外面的元素2（不是取出），并将i入栈，此时

int[] arr = {4, 7, 1, 7, 1};

stack=[0,2]

right[2,2,5,4,5]

贡献值求和

        long ans = 0;
        for (int i = 0; i < n; i++) {
            ans = (ans + (long) (i - left[i]) * (right[i] - i) * arr[i]) % MOD;
        }
        return (int) ans;

计算贡献值，我们就需要理解一下了。首先我们知道了所有元素的左右边界，元素 i 的左边界取值范围为[left,i]，，右边界的取值范围为 [i,right]，所以以该元素为最小值的子数组有 (i-left)*(right-i) 个，而每个元素对最终结果的贡献都是一比一的，元素3如果是一个子数组中的最小元素，那么它对结果的贡献率就是3。所有元素的贡献值*最小值的子数组个数之和就是最终结果。

int[] arr = {4, 7, 1, 7, 1};

left[-1,0,-1,2,2]

right[2,2,5,4,5]

Dak2n

关注

10
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
LeetCode 907：子数组的最小值之和

不求每日一题，但求懂每一题。
复制链接

扫一扫