单调队列模板题（一直动态变化的队列中求当前队列的最大/最小）

也称为滑动窗口题：给定一行数，共N个。有一个长度为K的窗口从左向右滑动，窗口中始终有K个数字，窗口每次滑动一个数字。求各个时刻窗口中的最大值和最小值。

1、 双端队列
双端队列是一种线性表，是一种特殊的队列，遵守先进先出的原则。双端队列支持以下4种操作：

（1） 从队首删除
（2） 从队尾删除
（3） 从队尾插入
（4） 查询线性表中任意一元素的值

2、 单调队列
单调队列是一种特殊的双端队列，其内部元素具有单调性。最大队列与最小队列是两种比较常用的单调队列，其内部元素分别是严格单调递减（不是非递增）和严格单调递增（不是非递减）的。

单调队列的常用操作如下:

(1) 插入:若新元素从队尾插入后会破坏单调性,则删除队尾元素,直到插入后不再破坏单调性为止,再将其插入单调队列。
(2) 获取最优（最大、最小）值:访问队首元素
以下是一个单调递增队列的例子：

队列大小不能超过3，入队元素依次为3，2，8，4，5，7，6，4

3入队：（3）

3从队尾出队，2入队：（2）

8入队：（2，8）

8从队尾出队，4入队：（2，4）

5入队：（2，4，5）

2从队头出队，7入队：（4，5，7）

7从队尾出队，6入队：（4，5，6）

6从队尾出队，5从队尾出队，4从队尾出队，4入队：（4）

以上左端为队头，右端为队尾。

二.单调队列的应用
1、最大值的维护：比如我们要维护一个区间为k的最大值的单调队列，由于新插入 的节点他的“生命力”肯定比原先已经在队列中的元素“活”的时间长，将插入元素不断与队尾元素比， 如果他大于队尾元素，那么tail–将队尾元素删掉，(因为目前插入的这个元素值（设为pos）更大，而且“活”的时间 长，有pos在，队尾元素的有“生”之年永远都没法为最大值，故而直接无视比pos小的队尾了)。直到对空位置或者 找到了一个比pos大的队尾。

例题：剑指 Offer 59 - II. 队列的最大值

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：
输入:
[“MaxQueue”,“push_back”,“push_back”,“max_value”,“pop_front”,“max_value”]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

class MaxQueue {
    Deque<Integer> queue;
    Deque<Integer> max;
    public MaxQueue() {
        queue=new ArrayDeque<>();
        max=new ArrayDeque<>();
    }
    
    public int max_value() {
        return queue.isEmpty()?-1:max.peek();
    }
    
    public void push_back(int value) {
        queue.offer(value);
        while(!max.isEmpty()&&max.peekLast()<value){
            max.pollLast();
        }
        max.offer(value);
    }
    
    public int pop_front() {
        if(queue.isEmpty()){
            return -1;
        }
        int val=queue.pop();
        if(val==max.peek()){
            max.pop();
        }
        return val;
    }
}

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue obj = new MaxQueue();
 * int param_1 = obj.max_value();
 * obj.push_back(value);
 * int param_3 = obj.pop_front();
 */

附加Deque详细用法：

package test;

import org.omg.PortableInterceptor.INACTIVE;

import java.lang.reflect.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Deque<Integer> deque=new ArrayDeque<>();

        deque.push(10);  //跟栈一样，先Push进去的是最后一个元素
        deque.push(1);
        deque.push(-6);

        deque.offer(10);  //正常的queue进栈方式，先进先出
        deque.offer(1);
        deque.offer(-6);
        deque.offer(4);
        
        deque.offerFirst(200); //进入队首
        deque.offerLast(300);  //进入队尾
        deque.pollFirst();     //除去队头元素
        deque.pollLast();      //除去队尾元素
        int b=deque.element();   //取队首元素值
        int c=deque.peekFirst(); //取队首元素值
        int d=deque.peekLast();  //取队尾元素值
        deque.add(-10);          //进入队尾
        deque.addFirst(20);   //进入队首
        deque.addLast(3000);  //进入队尾
    }
}

2.841. 钥匙和房间

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，…，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，…，N-1] 中的一个整数表示，其中 N = rooms.length。 钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。
你可以自由地在房间之间来回走动。
如果能进入每个房间返回 true，否则返回 false。

示例 1：

输入: [[1],[2],[3],[]]
输出: true
解释:
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

class Solution {
    int count;
    boolean []room=new boolean[1000]; //用于记录每个房间是否被访问过。
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        count=0;
        Travese(rooms,0);
        if(count==rooms.size()){
            return true;
        }
        else{
            return false;
        }
    }

    public void Travese(List<List<Integer>> rooms,int num){
        if(num<rooms.size()){
            room[num]=true;
            count++;
            for(int j=0;j<rooms.get(num).size();j++){
                int temp=rooms.get(num).get(j);
                if(!room[temp]){
                    Travese(rooms,temp);
                }
            }
        }
    }
}