Leetcode 907. 子数组的最小值之和

907. 子数组的最小值之和

题目链接：

题目描述

给定一个整数数组 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 * 10⁴
1 <= arr[i] <= 3 * 10⁴

题目分析：

首先考虑使用暴力或者回溯的做法，发现到第78个测试用例时报超时
(1)暴力枚举（时间复杂度为 n²，会超时）

class Solution {
    private static final int MOD = 1000000007;
    public 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;
    }
}

（2）回溯（时间复杂度为 n²，和暴力枚举一样会超时）

class Solution {
    //记录数组长度
    int num = 0;
    //记录总和
    int sum = 0;
    //记录以数组中某个下标开头的子序列是否被搜索过
    boolean[] flag = null;
    // dfs 深度搜索 arr 数组中以下标为 n 结尾的连续子序列, min 记录每个连续子序列的最小值
    public void dfs(int[] arr,int n,int min){

        if(n < 0 ||flag[n] == true){
            return;
        }

        min = arr[n];
        for(int i = n; i >= 0;i--){
            min = Math.min(min,arr[i]);
            sum = (sum + min) % 1000000007;
            dfs(arr,n-1,min);
            flag[n] = true;
        }
    }

    public int sumSubarrayMins(int[] arr) {
        num = arr.length;
        flag = new boolean[num];
        Arrays.fill(flag,false);
        dfs(arr,num-1,arr[num-1]);
        return sum;
    }
}

（3）单调栈

class Solution {
    int MOD = (int)1e9+7;
    public int sumSubarrayMins(int[] arr) {
        int n = arr.length, ans = 0;
        int[] l = new int[n], r = new int[n];
        Arrays.fill(l, -1); Arrays.fill(r, n);
        Deque<Integer> d = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            while (!d.isEmpty() && arr[d.peekLast()] >= arr[i]) r[d.pollLast()] = i;
            d.addLast(i);
        }
        d.clear();
        for (int i = n - 1; i >= 0; i--) {
            while (!d.isEmpty() && arr[d.peekLast()] > arr[i]) l[d.pollLast()] = i;
            d.addLast(i);
        }
        for (int i = 0; i < n; i++) {
            int a = i - l[i], b = r[i] - i;
            ans += a * 1L * b % MOD * arr[i] % MOD;
            ans %= MOD;
        }
        return ans;
    }
}