【模板】deque实现单调队列

双端队列deque容器：

关于deque最常用的有这几个函数：

都是成员函数

双端队列模板题：【洛谷】P2952 [USACO09OPEN]牛线Cow Line

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<deque>
 using namespace std;

 int n, cnt;
 deque<int> q;

 int main() {
     scanf("%d\n", &n);
     char s[];
     for(int i=; i<=n; ++i) {
         gets(s);
         if(s[] == 'A')
             if(s[] == 'L') q.push_front(++cnt);
             else q.push_back(++cnt);
         if(s[] == 'D') {
             int m = , j = ;
             while(s[j]<'' || s[j]>'') ++j;
             while(s[j]>='' && s[j]<='')
                 m = (m << ) + (m << ) + s[j] - , ++j;
             while(m--) {
                 if(s[] == 'L') q.pop_front();
                 else q.pop_back();
             }
         }

     }
     deque<int>::iterator it;
     for(it=q.begin(); it!=q.end(); ++it)
         printf("%d\n", *it);
 }

P2952 [USACO09OPEN]牛线Cow Line

单调队列deque容器实现：

设一个数组a，可以修改某一个元素的值，求a中所有元素的最小（大）值

每次从头扫到尾的时间复杂度O(n²)太高了，st表虽然是O(1)查询但不支持修改

可以使用线段树O(n log₂ n)来做但复杂度还是不够优秀，常数还大

单调队列登场了：

每次加入双端队列尾一个元素num时，从队尾将队列中所有比num大的元素都pop出去，再push_back(num)

这样就能实现单调队列了。

单调队列模板题：【洛谷】P1440 求m区间内的最小值

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<deque>
 using namespace std;

 const int MAXN =  + ;

 int n, m;
 int a[MAXN];
 deque<int> q;

 inline int read() {
     int x=, f=; char ch=getchar();
     while(ch<'' || ch>'') {
         if(ch == '-') f = -;
         ch = getchar();
     }
     while(ch>='' && ch<='')
         x=(x<<)+(x<<)+ch-, ch=getchar();
     return x * f;
 }

 int main() {
     n = read(), m = read();
     for(int i=; i<=n; ++i) a[i] = read();
     puts("");
     for(int i=; i<n; ++i) {
         if(i>m && q.front()==a[i-m]) q.pop_front();
         while(!q.empty() && q.back()>a[i]) q.pop_back();
         q.push_back(a[i]);
         printf("%d\n", q.front());
     }
 }

P1440 求m区间内的最小值

单调队列优化DP：

在用单调队列优化DP的时候，每次除维护序列的单调性外，还需要把队首已经没有用的元素pop_front()掉

能够用单调队列优化的DP一般都长成这个样子：

　　f[i] = max/min{f[k]} + ...

　　1 ≤ k < i

而优化的其实是求最值的过程：将O(n)优化到了O(1).