单调队列

单调队列典型程序：

滑动窗口

现在有一堆数字共N个数字（N<=10^6），以及一个大小为k的窗口。现在这个从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最大值和最小值。例如：The array is [1 3 -1 -3 5 3 6 7], and k = 3.

窗口最小值最大值

[1 3 -1] -3 5 3 6 7 -1 3

1 [3 -1 -3]5 3 6 7 -3 3

1 3 [-1 -3 5] 3 6 7 -3 5

1 3 -1 [-3 5 3] 6 7 -3 5

1 3 -1 -3[5 3 6] 7 3 6

1 3 -1 -35 [3 6 7] 3 7

输入格式

输入一共有两行，第一行为n,k。第二行为n个数(

输出格式

输出共两行，第一行为每次窗口滑动的最小值第二行为每次窗口滑动的最大值

样例输入

8 31 3 -1 -3 5 3 6 7

样例输出

-1 -3 -3 -3 3 33 3 5 5 6 7

维护方式（以最大值为例）：

队列单调递减，故队首即为所求

每当遇到新元素，当队尾不大于新元素时队尾出队（貌似可用二分搜索优化），新元素进队，当队首过期时队首出队。

AC代码：

var

a,b,c,f1,f2:array[1..1000000] of longint;

n,i,j,k,p1,p2,q1,q2:longint;

begin

readln(n,k);

for i:=1 to n do read(a[i]);

if k=1 then

begin

for i:=1 to n-1 do write(a[i],' ');

writeln(a[n]);

for i:=1 to n-1 do write(a[i],' ');

writeln(a[n]);

halt;

end;

p1:=1;

q1:=1;

p2:=1;

q2:=1;

b[1]:=1;

c[1]:=1;

for i:=2 to n do

begin

while (q1>=p1)and(a[i]<=a[b[q1]]) do dec(q1);

inc(q1);

b[q1]:=i;

while b[p1]

f1[i]:=a[b[p1]];

while (q2>=p2)and(a[i]>=a[c[q2]]) do dec(q2);

inc(q2);

c[q2]:=i;

while c[p2]

f2[i]:=a[c[p2]];

end;

for i:=k to n-1 do write(f1[i],' ');

writeln(f1[n]);

for i:=k to n-1 do write(f2[i],' ');

writeln(f2[n]);

end.

单调队列，顾名思义是指队列内的元素是有序的，队头为当前的最大值（单调递减队列）或最小值（单调递增序列），以单调递减队列为例来看队列的入队和出队操作：

1、入队：

如果当前元素要进队，把当前元素和队尾元素比较，如果当前元素小于队尾元素，那么当前元素直接进队，如果当前元素大于队尾元素，那么队尾出队，将当前元素和新的队尾再做比较，直到当前元素大于队尾元素或者队列为空。单调队列只能在队尾插入元素，队尾和队头都可以删除元素。

2、出队：

出队直接取队头即可，因为用单调队列就是为了取最值，而队头就是最值。

例子：将数组a[] = {3, 5, 2, 8, 1, 4, 7}依次入队，并保证队列为一个单调递减队列。

?3入队，队列为空直接入队，队列元素为：3；

?5入队，5和队尾比较，5大于3，3出队，队为空，5入队，队列元素为：5；

?2入队，2和队尾比较，2小于5，直接入队，队列元素为：5，2；

?8入队，8和队尾比较，2出队，8再和队尾比较，5出队，队为空，8入队，队列元素为：8；

?1入队，...，队列元素为：8，1；

?4入队，...，队列元素为：8，4；

?7入队，...，队列元素为：8，7。

实例应用：

1、给定一个数组a[]和一个长度为k的滑动窗口，该窗口从最左端移到最右端，找出窗口在每个位置是的最大值。

例如：a[] = {7, 3, 2, 5, 6}，k = 3。我们可以维护一个单调递减队列，这样对于每个位置，当前队列的队头就是最大值，只不过在入队的时候要检查一下队头的下标是否已经超出窗口的范围，如果超出就删除队头元素即可。为了方便写代码，单调队列很多时候保存的是下标，而不是数值本身。

?i = 0，初始队列为空，7入队，队列为：{ 0(7) }，（0为下标，括号为下标对应的值），窗口区间为[0]，最大值为队头a[0] = 7；

?i = 1，队头下标没有超出k，3入队，队列为：{ 0(7), 1(3) }，窗口区间为[0,1]，最大值为队头a[0] = 7；

?i = 2，队头下标没有超出k，2入队，队列为：{ 0{7), 1(3), 2(2) }，窗口区间为[0,1,2]，最大值为队头a[0] = 7；

?i = 3，队头下标为0超出k，删除队头，5入队，队列为：{ 3(5) }，窗口区间为[1,2,3]，最大值为队头a[3] = 5；

?i = 4，队头下标没有超出k，6入队，队列为：{ 4(6) }，窗口区间为[2, 3, 4]，最大值为队头a[4] = 6;

窗口继续向右滑动，如果当前队头下标超出范围就删除队头，然后去队头，没有超出范围就直接取队头。

这样整个算法就是O(n)的。

procedure work; {设原始数据存入q[i]中}

V ar i,top,tail:longint;

begin

top:=1; tail:=1;

queue[top]:=1; //队头指向q[i]中第一个数

for i:=2 to k do //前k个数的初始队列

begin

while (top<=tail)and(q[queue[tail]]>=q[i]) do

dec(tail);//队尾元素大于当前元素出队

inc(tail); //当前元素入队

queue[tail]:=i;

end;

min[1]:=q[queue[top]]; //第1窗口最小值

for i:=2 to n-k+1 do //窗口左端位置

begin

if queue[top]

while (top<=tail)and(q[queue[tail]]>=q[i+k-1]) do

dec(tail); //队尾元素大于当前窗口右端元素，出队

inc(tail);

queue[tail]:=i+k-1;//当前窗口右端元素入队

min[i]:=q[queue[top]];//取当前窗口最小值

end;

end;

const

maxn=1000000;

var

q1,q2:array[0..maxn shl 1] of longint;

a,b,p:array[1..maxn]of longint;

n,m:longint;

f1,f2:text;

procedure init;

var

i,j:longint;

begin

readln(n,m);

for i:=1 to n do read(f1,p[i]);

end;

procedure main;

var

i,j,h1,t1,h2,t2:longint;

begin

q1[1]:=1;q2[1]:=1;

h1:=1;t1:=1;h2:=1;t2:=1;

for i:=2 to m do

begin

//while (q1[h1]<=i-m)and(h1<=t1) do inc(h1);

//while (q2[h2]<=i-m)and(h2<=t2) do inc(h2);

while (p[q1[t1]]>=p[i])and(t1>=h1) do dec(t1);

inc(t1);q1[t1]:=i;

while (p[q2[t2]]<=p[i])and(t2>=h2) do dec(t2);

inc(t2);q2[t2]:=i;

end;

a[1]:=p[q1[h1]];b[1]:=p[q2[h2]];

for i:=m+1 to n do

begin

while (q1[h1]<=i-m)and(h1<=t1) do inc(h1); //if (q1[h1]=i-m) and (h1<=t1) then inc(h1) while (q2[h2]<=i-m)and(h2<=t2) do inc(h2);

while (p[q1[t1]]>=p[i])and(t1>=h1) do dec(t1);

inc(t1);q1[t1]:=i;

while (p[q2[t2]]<=p[i])and(t2>=h2) do dec(t2);

inc(t2);q2[t2]:=i;

a[i-m+1]:=p[q1[h1]];b[i-m+1]:=p[q2[h2]];

end;

end;

procedure print;

var

i,j:longint;

begin

for i:=1 to n-m do write(a[i],' ');

writeln(a[n-m+1]);

for i:=1 to n-m do write(b[i],' ');

writeln(b[n-m+1]);

end;

begin

assign(f1,wind.in);reset(f1); assign(f2,win.out);rewrite(f2); init;

main;

print;

close(f1);close(f2);

end.

单调队列及其应用

单调队列，望文生义，就是指队列中的元素是单调的。如：{a1,a2,a3,a4……an}满足

a1<=a2<=a3……<=an,a序列便是单调递增序列。同理递减队列也是存在的。

单调队列的出现可以简化问题，队首元素便是最大（小）值，这样，选取最大（小）值的复杂度便为o（1），由于队列的性质，每个元素入队一次，出队一次，维护队列的复杂度均摊下来便是o（1）。

如何维护单调队列呢，以单调递增序列为例：

1、如果队列的长度一定，先判断队首元素是否在规定范围内，如果超范围则增长队首。

2、每次加入元素时和队尾比较，如果当前元素小于队尾且队列非空，则减小尾指针，队尾元素依次出队，直到满足队列的调性为止

要特别注意头指针和尾指针的应用。

下面介绍单调队列的具体应用：

一、单调队列的直接应用

1.合并果子

【问题描述】

在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。

例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

【输入文件】

输入文件fruit.in包括两行，第一行是一个整数n（1 <= n <= 10000），表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai（1 <= ai <= 20000）是第i种果子的数目。【输出文件】

输出文件fruit.out包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于231。

【样例输入】

3

1 2 9

【样例输出】

15

【数据规模】

对于30%的数据，保证有n <= 1000；

对于50%的数据，保证有n <= 5000；

对于全部的数据，保证有n <= 10000。

分析:

这个题目非常的经典，发放也很多，可以采用快排或者堆，其思想都是选取当前最小的两个堆进行合并。复杂度均为O(nlogn)，如果用有序队列维护，时间复杂度为O（n）。

每次选取进行合并的两堆，不是最先给定的堆，就是合并最初堆若干次后得到的新堆，所以需要维护两个单调递增队列，一个队列存最初给定的堆的值（1），一个存合并后得到的新值（2）。每次选择时有三种状态：

1.选取队一的队首两个

2.选取队2的的队首两个

3.选取二者队首各一个

只需对每个队列的指针做相应的更改。

特别注意初始化。

这道题很好的运用了题目中决策的单调性，对初始对经行排序，保证了其单调性。而对于新产生的堆来说，一旦有新元素加入其中，则新元素一定大于原有元素。（很显然，由于队列1的单调性）。

也就是说，队列的单调性是自然而然的。是不需要维护的。要善于观察分析，才能发现。