单调队列 monotonic queue

Posted 2021-11-10 xiaoyongyong

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单调队列 monotonic queue相关的知识，希望对你有一定的参考价值。

239. Sliding Window Maximum

Hard

You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

Return the max sliding window.

Example 1:

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3
Output: [3,3,5,5,6,7]
Explanation: 
Window position                Max
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

Example 2:

Input: nums = [1], k = 1
Output: [1]

Example 3:

Input: nums = [1,-1], k = 1
Output: [1,-1]

Example 4:

Input: nums = [9,11], k = 2
Output: [11]

Example 5:

Input: nums = [4,-2], k = 2
Output: [4]

Constraints:

1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new LinkedList();
        int[] result = new int[nums.length-k+1];
        for(int i=0;i<nums.length;i++){
            //保持队列单调递减
            while(!deque.isEmpty() && i-deque.peekFirst()>=k)
                deque.pollFirst();
            //保持windowsize
            while(!deque.isEmpty() && nums[deque.peekLast()]<nums[i])
                deque.pollLast();
            deque.offerLast(i);
            int startInd = i-k+1;
            //队列头部值即为当前window的最大值
            if(startInd>=0) result[startInd]=nums[deque.peekFirst()];
        }
        return result;
    }
}

时间复杂度：O(N)

862. Shortest Subarray with Sum at Least K

Hard

Given an integer array nums and an integer k, return the length of the shortest non-empty subarray of nums with a sum of at least k. If there is no such subarray, return -1.

A subarray is a contiguous part of an array.

Example 1:

Input: nums = [1], k = 1
Output: 1

Example 2:

Input: nums = [1,2], k = 4
Output: -1

Example 3:

Input: nums = [2,-1,2], k = 3
Output: 3

Constraints:

1 <= nums.length <= 105
-105 <= nums[i] <= 105
1 <= k <= 109

class Solution {
    public int shortestSubarray(int[] nums, int k) {
        int len = nums.length;
        if(len==1) return nums[0]>=k ? 1 : -1;
        long[] sum = new long[len+1];
        sum[0]=0;
        //先计算前缀和
        for(int i=1;i<=len;i++) sum[i]=sum[i-1]+nums[i-1];
        Deque<Integer> dq = new LinkedList();
        int result = len+1;
        for(int i=0;i<=len;i++){
            //保持队列单调递增
            while(!dq.isEmpty() && sum[dq.peekLast()]>=sum[i]) 
                dq.pollLast();
            //与队列头部元素比较，如果满足条件，pop并记录结果。   为啥满足条件时可以直接pop? 因为即使i之后还有元素满足条件，也已经不是最小长度了
            while(!dq.isEmpty() && sum[dq.peekFirst()]+k<=sum[i]) {
                result = Math.min(result,i-dq.pollFirst());
            }
            dq.offerLast(i);
        }
        return result>len ? -1 : result;
    }
}

时间复杂度：O(N)

FZU 1894 志愿者选拔单调队列monotone decreasing queue

?Problem 1894 志愿者选拔

Accept: 1770????Submit: 5523
Time Limit: 1500 mSec????Memory Limit : 32768 KB

?Problem Description

世博会立即就要开幕了，福州大学组织了一次志愿者选拔活动。
參加志愿者选拔的同学们排队接受面试官们的面试。參加面试的同学们依照先来先面试而且先结束的原则接受面试官们的考查。
面试中每一个人的人品是主要考查对象之中的一个。（提高人品的方法有扶老奶奶过街，不闯红灯等）
作为主面试官的John想知道当前正在接受面试的同学队伍中人品值最高的是多少。于是他请你帮忙编写一个程序来计算。

?Input

输入数据第一行为一整数T，表示有T组输入数据。每组数据第一行为”START”，表示面试開始
接下来的数据中有三种情况：

?	输入	含义
1	C NAME RP_VALUE	名字为NAME的人品值为RP_VALUE的同学增加面试队伍。(名字长度不大于5，0 <= RP_VALUE <= 1,000,000,000)
2	G	排在面试队伍最前面的同学面试结束离开考场。
3	Q	主面试官John想知道当前正在接受面试的队伍中人品最高的值是多少。

最后一行为”END”，表示全部的面试结束，面试的同学们能够依次离开了。
全部參加面试的同学总人数不超过1,000,000

?Output

对于每一个询问Q,输出当前正在接受面试的队伍中人品最高的值,假设当前没有人正在接受面试则输出-1。

?Sample Input

2

START

C Tiny 1000000000

C Lina 0

Q

G

Q

END

START

Q

C ccQ 200

C cxw 100

Q

G

Q

C wzc 500

Q

END

?Sample Output

1000000000

0

-1

200

100

500

?Hint

数据较大建议使用scanf,printf 不推荐使用STL

?Source

福州大学第七届程序设计竞赛

分析题目：模拟维护人品最大值的过程。也就是单调队列维护最大值的过程。

对于单调队列的舞台：取最大/最小值最快，可是使用的前提条件就是：假设来了一个更大的值，辣么相对较小的值就没有存在的意义了。

这个题全然符合单调队列的特点和使用条件。

比如有这种一个入队顺序（数值表示人品值）：

1 2 3 5 2 4

当第一个人来的时候。由于队列为空。所以直接入队。

当第二个人来的时候，由于队列不空，而且2的优先值大于1，所以1就没有存在的意义了。如今队列里边仅仅有一个元素：2

当第三个人来的时候，由于队列不空。而且3的优先值大于2，所以2没有存在的意义了，如今队列里边仅仅有一个元素：3

当第四个人来的时候，由于队列不空，而且5的优先值大于3，所以3没有存在的意义了，如今队列里边仅仅有一个元素：5

当第五个人来的时候，由于队列不空，而且2的优先值小于2，所以直接入队列，如今队列里边有两个元素：5 2

当第六个人来的时候。由于队列不空。而且4的优先值大于2。所以2就没有存在的意义了，如今队列里边有两个元素：5 4

对于这部分操作的代码实现：

            if(str[0]==‘C‘)
            {
                scanf("%s %d",str,&val);
                while(head<=cur&&q[cur].val<val)cur--;//head表示头指针，cur表示当前指针
                q[++cur].pos=cont++;
                q[cur].val=val;
            }

这样，我们就模拟了一次单调队列入队的操作。

辣么对于没有存在意义的元素，就真的没有存在的意义了吗？答案是对的。读者可能会有这种疑问，那么对于G操作呢？对于出队列的操作呢？总不能出队列的操作在四个人进来的时候直接把队列中唯一的元素5（同一时候也是单调队列维护的最大值）直接出队吧，那不正确啊，前边的三个人就没了？对于这个问题，事实上大可不必操心，我们既然让之前的三个元素1 2 3都变得没有意义了，我们当然有相对的操作，对于这个问题，我们能够对入队的节点编上号，然后用一个变量last表示一共同拥有多少出队的节点数，假设q【head】.编号已经小于了这个last.，那么说明这个节点已经出队了。在Q操作的时候相应推断一下就可以。

对于这部分语言描写叙述的操作的代码实现：

            else if(str[0]==‘Q‘)
            {
                while(head<=cur&&q[head].pos<last)head++;
                if(head>cur)printf("-1\n");
                else printf("%d\n",q[head].val);
            }
            else last++;//当是G操作的时候。计数器++

最后是完整的AC代码：

#include<stdio.h>
#include<string.h>
using namespace std;
struct node
{
    int pos, val;
}q[1000005];
int main()
{
    int t;char str[20];
    scanf("%d",&t);
    while(t--)
    {
        int head,last,val,cur,cont;
        head=last=cont=0;
        cur=-1;
        while(scanf("%s",str))
        {
            if(str[0]==‘E‘)break;
            if(str[0]==‘S‘)continue;
            if(str[0]==‘C‘)
            {
                scanf("%s %d",str,&val);
                while(head<=cur&&q[cur].val<val)cur--;
                q[++cur].pos=cont++;
                q[cur].val=val;
            }
            else if(str[0]==‘Q‘)
            {
                while(head<=cur&&q[head].pos<last)head++;
                if(head>cur)printf("-1\n");
                else printf("%d\n",q[head].val);
            }
            else last++;
        }
    }
}