单调队列及其应用

 

单调队列

单调队列

spoiler posted @ 2011年4月09日 17:10 in  未分类 , 2027 阅读

 

一直弄不明白单调队列是什么，在网上也找不到易懂的介绍。最后结合别人博客上的介绍和程序看才理解是怎么回事。

我们从最简单的问题开始：

给定一个长度为N的整数数列a(i),i=0,1,...,N-1和窗长度k.

要求：

      f(i) = max{a(i-k+1),a(i-k+2),..., a(i)},i = 0,1,...,N-1

问题的另一种描述就是用一个长度为k的窗在整数数列上移动，求窗里面所包含的数的最大值。

解法一：

很直观的一种解法，那就是从数列的开头，将窗放上去，然后找到这最开始的k个数的最大值，然后窗最后移一个单元，继续找到k个数中的最大值。

这种方法每求一个f(i),都要进行k-1次的比较，复杂度为O(N*k)。

那么有没有更快一点的算法呢？

解法二：

我们知道，上一种算法有一个地方是重复比较了，就是在找当前的f(i)的时候，i的前面k-1个数其它在算f(i-1)的时候我们就比较过了。那么我们能不能保存上一次的结果呢？当然主要是i的前k-1个数中的最大值了。答案是可以，这就要用到单调递减队列。

单调递减队列是这么一个队列，它的头元素一直是队列当中的最大值，而且队列中的值是按照递减的顺序排列的。我们可以从队列的末尾插入一个元素，可以从队列的两端删除元素。

1.首先看插入元素：为了保证队列的递减性，我们在插入元素v的时候，要将队尾的元素和v比较，如果队尾的元素不大于v,则删除队尾的元素，然后继续将新的队尾的元素与v比较，直到队尾的元素大于v,这个时候我们才将v插入到队尾。

2.队尾的删除刚刚已经说了，那么队首的元素什么时候删除呢？由于我们只需要保存i的前k-1个元素中的最大值，所以当队首的元素的索引或下标小于 i-k+1的时候，就说明队首的元素对于求f(i)已经没有意义了，因为它已经不在窗里面了。所以当index[队首元素]

从上面的介绍当中，我们知道，单调队列与队列唯一的不同就在于它不仅要保存元素的值，而且要保存元素的索引（当然在实际应用中我们可以只需要保存索引，而通过索引间接找到当前索引的值）。

为了让读者更明白一点，我举个简单的例子。

假设数列为：8，7，12，5，16，9，17，2，4，6.N=10,k=3.

那么我们构造一个长度为3的单调递减队列：

首先，那8和它的索引0放入队列中，我们用（8，0）表示，每一步插入元素时队列中的元素如下：

0：插入8，队列为：（8，0）

1：插入7，队列为：（8，0），（7，1）

2：插入12，队列为：（12，2）

3：插入5，队列为：（12，2），（5，3）

4：插入16，队列为：（16，4）

5：插入9，队列为：（16，4），（9，5）

。。。。依此类推

那么f(i)就是第i步时队列当中的首元素：8，8，12，12，16，16，。。。

分类： 九度OJ 2012-04-03 21:54  2055人阅读  评论(2)  收藏  举报

存储

一、 什么是单调（双端）队列
单调队列，顾名思义，就是一个元素单调的队列，那么就能保证队首的元素是最小（最大）的，从而满足动态规划的最优性问题的需求。
单调队列，又名双端队列。双端队列，就是说它不同于一般的队列只能在队首删除、队尾插入，它能够在队首、队尾同时进行删除。
【单调队列的性质】
一般，在动态规划的过程中，单调队列中每个元素一般存储的是两个值：
1、在原数列中的位置（下标）
2、 他在动态规划中的状态值
而单调队列则保证这两个值同时单调。
从以上看，单调队列的元素最好用一个类来放，不这样的话，就要开两个数组。。。

单调队列：单调队列 即保持队列中的元素单调递增（或递减）的这样一个队列，可以从两头删除，只能从队尾插入。单调队列的具体作用在于，由于保持队列中的元素满足单调性，对手元素便是极小值（极大值）了。

http://poj.org/problem?id=2823

 //poj-2823--单调队列
 #include
 #include
 using namespace std;

 const int MAX = 1000001;
 //两个单调队列
 int dq1[MAX];    //一个存单调递增
 int dq2[MAX];    //一个存单调递减
 int a[MAX];

 inline bool scan_d(int &num)  //  这个就是 加速的 关键了
 {
     char in;bool IsN=false;
     in=getchar();
     if(in==EOF)
         return false;
     while(in!='-'&&(in<'0'||in>'9')) in=getchar();
     if(in=='-')   { IsN=true;num=0;}
     else num=in-'0';
     while(in=getchar(),in>='0'&&in<='9')
     {
         num*=10,num+=in-'0';
     }
     if(IsN)
         num=-num;
     return true;
 }

 int main(void)
 {
     int i,n,k,front1,front2,tail1,tail2,start,ans;

     while(scanf("%d %d",&n,&k)!=EOF)
     {
         for(i = 0 ; i < n ; ++i)
             scan_d(a[i]);
         front1 = 0, tail1 = -1;
         front2 = 0, tail2 = -1;
         ans = start = 0;
         for(i = 0 ; i < k ; ++i)
         {
             while(front1 <= tail1 && a[ dq1[tail1] ] <= a[i])   //当前元素大于单调递增队列的队尾元素的时候，队尾的元素依次弹出队列，直到队尾元素大于当前当前元素的时候，将当前元素插入队尾
                 --tail1;
             dq1[ ++tail1 ] = i;    //只需要记录下标即可

             while(front2 <= tail2 && a[ dq2[tail2] ] >= a[i])   //当前元素小于单调递减队列的队尾元素的时候，队尾的元素依次弹出队列，直到队尾元素小于当前当前元素的时候，将当前元素插入队尾
                 --tail2;
             dq2[ ++tail2 ] = i;    //只需要记录下标即可
         }
         printf("%d ",a[ dq2[ front2 ] ]);
         for( ; i < n ; ++i)
         {
             while(front2 <= tail2 && a[ dq2[tail2] ] >= a[i])
                 --tail2;
             dq2[ ++tail2 ] = i;
             while(dq2[ front2 ] <= i - k)
                 ++front2;
             if(i != n-1)
                 printf("%d ",a[ dq2[ front2 ] ]);
         }
         printf("%d\n",a[ dq2[ front2 ] ]);

         //输出最大值
         printf("%d ",a[ dq1[ front1 ] ]);
         for(i=k ; i < n ; ++i)
         {
             while(front1 <= tail1 && a[ dq1[tail1] ] <= a[i])
                 --tail1;
             dq1[ ++tail1 ] = i;
             while(dq1[ front1 ] <= i - k)
                 ++front1;
             if(i != n-1)
                 printf("%d ",a[ dq1[ front1 ] ]);
         }
         printf("%d\n",a[ dq1[ front1 ] ]);
     }
     return 0;
 }

http://acm.hdu.edu.cn/showproblem.php?pid=3530    Subsequence

 /*
 题意：给出一个序列，求最长的连续子序列，使得 M<=Max-Min<=K
        n <= 10^5
 依次枚举剩下的N-1个元素，并且将当前未入队的第一个元素和队尾元素比较，当且仅当队列为非空并且队尾元素的值小于当前未入队的元素时，
 将队尾元素删除(也就是队尾指针-1），因为当前的元素比队尾元素大，所以在区间内队尾元素不会是最大值了。
 重复这个过程直到队列空或者队尾元素比当前元素大，
 */
 #include
 #include
 using namespace std;

 const int MAX = 100001;
 //两个单调队列
 int dq1[MAX];    //一个存单调递增
 int dq2[MAX];    //一个存单调递减
 int a[MAX];

 inline bool scan_d(int &num)  //  这个就是 加速的 关键了
 {
     char in;bool IsN=false;
     in=getchar();
     if(in==EOF)
         return false;
     while(in!='-'&&(in<'0'||in>'9')) in=getchar();
     if(in=='-')   { IsN=true;num=0;}
     else num=in-'0';
     while(in=getchar(),in>='0'&&in<='9')
     {
         num*=10,num+=in-'0';
     }
     if(IsN)
         num=-num;
     return true;
 }

 int main(void)
 {
     int i,n,m,k,front1,front2,tail1,tail2,start,ans;
     while(scanf("%d %d %d",&n,&m,&k) != EOF)
     {
         for(i = 0 ; i < n ; ++i)
             scan_d(a[i]);
         front1 = 0, tail1 = -1;
         front2 = 0, tail2 = -1;
         ans = start = 0;
         for(i = 0 ; i < n ; ++i)
         {
             while(front1 <= tail1 && a[ dq1[tail1] ] <= a[i])   //当前元素大于单调递增队列的队尾元素的时候，队尾的元素依次弹出队列，直到队尾元素大于当前当前元素的时候，将当前元素插入队尾
                 --tail1;
             dq1[ ++tail1 ] = i;    //只需要记录下标即可

             while(front2 <= tail2 && a[ dq2[tail2] ] >= a[i])   //当前元素小于单调递减队列的队尾元素的时候，队尾的元素依次弹出队列，直到队尾元素小于当前当前元素的时候，将当前元素插入队尾
                 --tail2;
             dq2[ ++tail2 ] = i;    //只需要记录下标即可

             /*
             Max - Min 为两个队列的队首之差
             while(Max-Min>K)  看哪个的队首元素比较靠前，就把谁往后移动
             */
             while(a[ dq1[front1] ] - a[ dq2[front2] ] > k)
             {
                 if(dq1[front1] < dq2[front2] )
                 {
                     start = dq1[front1] + 1;
                     ++front1;
                 }
                 else
                 {
                     start = dq2[front2] + 1;
                     ++front2;
                 }
             }
             if(a[ dq1[front1] ] - a[ dq2[front2] ] >= m)
             {
                 if(i - start +1 > ans)
                     ans = i - start + 1;
             }
         }
         printf("%d\n",ans);
     }
     return 0;
 }