算法：整形数组中子数组最大值减最小值达标的子数组个数

最新推荐文章于 2024-08-02 16:03:46 发布

OceanStar的学习笔记

最新推荐文章于 2024-08-02 16:03:46 发布

阅读量367

点赞数

分类专栏：算法与数据结构文章标签：算法数据结构

原文链接：https://mubu.com/doc/IodJW7cCNk

版权

算法与数据结构专栏收录该内容

1121 篇文章 80 订阅

订阅专栏

题目描述

给定一个整型数组arr，和一个整数num

某个arr中的子数组sub，如果想达标，必须满足：sub中最大值 – sub中最小值 <= num，

返回arr中达标子数组的数量

class Solution {
public:
   int AllLessNumSubArray(vector<int>& arr, int sum) {

    }
};

题目解析

暴力

先找出arr的所有子数组，一共 $O(N^2)$ 个，然后对每一个子数组遍历找出最大值和最小值，其时间复杂度为 $O (N)$ ，然后看看这个子数组是否满足条件

class Solution {
public:
    int AllLessNumSubArray(vector<int>& arr, int sum) {
        int N = arr.size();
        int count = 0;
        for (int L = 0; L < N; ++L) {
            for (int R = L; R < N; ++R) {
                int max = arr[L], min = arr[L];
                for (int i = L + 1; i <= R; ++i) {
                    max = std::max(max, arr[i]);
                    min = std::max(min, arr[i]);
                }
                if(max - min <= sum){
                    ++count;
                }
            }
        }
        return count;
    }
};

单调队列

维护两个双端队列qmax和qmin。当子数组为 $a r r [i . . . j]$ 时，

$q m a x$ 维护了窗口子数组 $a r r [i . . . j]$ 的最大值更新的结构
$q m i n$ 维护了窗口子数组 $a r r [i . . . j]$ 的最小值更新的结构

当子数组 $a r r [i . . . j]$ 向右扩一个位置变成 $a r r [i . . . j + 1]$ 使， $q m a x$ 和 $q m i n$ 结构可以在 $O (1)$ 的时间内更新，并且可以在 $O (1)$ 的时间内得到 $a r r [i . . . j + 1]$ 的最大值和最小值。

当子数组 $a r r [i . . . j]$ 向左缩一个位置变成 $a r r [i + 1 . . . j]$ 使， $q m a x$ 和 $q m i n$ 结构可以在 $O (1)$ 的时间内更新，并且可以在 $O (1)$ 的时间内得到 $a r r [i . . . j + 1]$ 的最大值和最小值。

因此：

如果子数组 $a r r [i . . . j]$ 满足条件，即 $m a x (a r r [i . . . j]) - m i n (a r r [i . . . j]) < = n u m$ ，那么 $a r r [i . . . j]$ 中的每一个子数组，都满足条件
如果子数组 $a r r [i . . . j]$ 不满足条件，即 $m a x (a r r [i . . . j]) - m i n (a r r [i . . . j]) > n u m$ ，那么 $a r r [i . . . j]$ 中的每一个子数组，都不满足条件

从而，设计方案如下：

维护两个双端队列qmax和qmin；维护两个整型变量i和j，表示子数组的范围，即 $a r r [i . . . j]$ 。
令j不断往右移动(j++)，并不断更新 $q m a x$ 和 $q m i n$ ，保持qmax和qmin时钟维持动态窗口最大值和最小值的更新结构
一旦出现 $a r r [i . . . j]$ 不满足条件的情况， $j$ 向右扩停止，此时 $a r r [i . . . j - 1] 、 a r r [i . . . j - 2] . . . . a r r [i . . . i]$ 一定都是满足条件的。也就是说，所有必须以 $a r r [i]$ 作为第一个元素的子数组，满足条件的数量为 $j - i$ 个，于是 $a n s + = j - 1$
当完成上面步骤，令 $i$ 向右移动一个位置，并更新 $q m a x$ 和 $q m i n$ ，然后重复步骤 $2 、 3$ 。也就是求所有必须以 $a r r [i + 1]$ 作为第一个元素的子数组中，满足条件的数量
更新上面步骤，依次求出以 $a r r [0] 、 a r r [1] . . . . a r r [N - 1]$ 作为第一个元素的子数组中满足条件的数量分别有多少个，累积起来就是最终的结构

上面过程中，所有下标值最多进qmax和qmin一次，出qmax和qmin一次。i、j只会往右增，从不会减小，因此其时间复杂度为O(N)

class Solution {
public:
    int AllLessNumSubArray(vector<int>& arr, int sum) {
        int N = arr.size();
        int count = 0;
        std::deque<int> qmax , qmin ;
        int R = 0;
        for (int L = 0; L < N; ++L) {
            while (R < N){
                while (!qmax.empty() && arr[qmax.back()] <= arr[R]){
                    qmax.pop_back();
                }
                qmax.push_back(R);
                while (!qmin.empty() && arr[qmin.back()] >= arr[R]){
                    qmin.pop_back();
                }
                qmin.push_back(R);
                if(arr[qmax.front()] - arr[qmin.front()] > sum){
                    break;
                }else{
                    R++;
                }
            }
            
            count += R - L;
            if(qmax.front() == L){
                qmax.pop_front();
            }
            if(qmin.front() == L){
                qmin.pop_front();
            }
        }
        return count;
    }
};