栈和队列----最大值减去最小值小于等于num的子数组的数量

Posted 2020-12-04 demrystv

最大值减去最小值小于等于num的子数组的数量

　　

　　给定数组arr和整数 num，共返回有多少个数组满足下列情况： max(arr[i..j])-min(arr[i..j])<=num。其中max(arr[i..j]) 表示子数组arr[i..j] 中的最大值，min(arr[i..j]) 表示子数组arr[i..j] 中的最小值。如果数组的长度为N，要求时间复杂度是 O(N)。

 

　　【解析】

　　使用双端队列，qmax维护着窗口子数组arr[i..j]的最大值更新的结构，qmin维护着窗口子数组arr[i..j]的最小值更新的结构，所有下标值最多进qmax和qmin 一次，出qmax和qmin 一次，i 和j 的值也不断增加，从不减小，所以时间复杂度是O(N)。

　　通过题目可以分析得到以下两个结论：

　　1）如果子数组arr[i..j]满足条件，即max(arr[i..j])-min(arr[i..j])<=num，那么arr[k..l](i<=k<=l<=j)肯定都满足条件，即若一个数组满足条件，它的所有子数组肯定满足条件。

　　2）如果子数组arr[i..j]不满足条件，即max(arr[i..j])-min(arr[i..j])>num，那么arr[k..l](k<=i<=j<=l)肯定不满足条件，即若一个数组不满足条件，所有包含它的数组肯定都不满足条件。

　　

package com.test;

import java.util.LinkedList;

/**
 * Created by Demrystv.
 *
 * 所有下标值最多进qmax和qmin 一次，出qmax和qmin 一次，i 和j 的值也不断增加，从不减小，所以时间复杂度是O(N)
 */
public class GetNum {
    public int getNum(int[] arr, int num){
        if (arr.length==0 || arr==null){
            return 0;
        }

        //双端队列，qmax维护着窗口子数组arr[i..j]的最大值更新的结构，qmin维护着窗口子数组arr[i..j]的最小值更新的结构，

        //若某个数组满足条件，那么它所包含的子数组肯定都满足条件
        //若某数组不满足条件，那么包含它的所有数组肯定不满足条件
        LinkedList<Integer> qmax = new LinkedList<Integer>();
        LinkedList<Integer> qmin = new LinkedList<Integer>();
        int i = 0;
        int j = 0;
        int res = 0;
        while (i<arr.length){
            while (j<arr.length){
                while (!qmin.isEmpty() && arr[qmin.peekLast()]>= arr[j]){
                    qmin.pollLast();
                }
                qmin.addLast(j);

                while (!qmax.isEmpty() && arr[qmax.peekLast()]<= arr[j]){
                    qmax.pollLast();
                }
                qmax.addLast(j);

                if (arr[qmax.getFirst()] - arr[qmin.getFirst()] > num){
                    break;
                }

                j++;
            }

            //双端队列的队头到了起始点，就将他弹出来
            if (qmin.peekFirst() == i){
                qmin.pollFirst();
            }
            if (qmax.peekFirst() == i){
                qmax.pollFirst();
            }

            //利用的结论是 若arr[i..j]满足条件，那么arr[i..j-1]必定满足条件；若arr[i..j]满足条件，那么包含arr[i..j]的数组必定不满足条件
            res += j - i;
            i++;
        }
        return res;
    }
}