单调队列，单调栈总结

最新推荐文章于 2021-07-25 22:01:04 发布
最新推荐文章于 2021-07-25 22:01:04 发布
阅读量275 收藏 1
点赞数
文章标签： php 数据结构与算法
原文链接：http://www.cnblogs.com/dacc123/p/8228806.html
版权

最近几天接触了单调队列，还接触了单调栈，就总结一下。
其实单调队列，和单调栈都是差不多的数据类型，顾名思义就是在栈和队列上加上单调，单调递增或者单调递减。当要入栈或者入队的时候，要和栈头或者队尾进行比较，满足单调的性质则入队入栈，否则将当前元素删去，直到满足单调性质。
那么问题来了，单调队列，和单调栈有什么用了。最普遍的最重要的作用就是起到优化的作用。当然我目前也只知道这个所用。
先看一道例题：
求一个n序列中，所有长度不大于lmaxin，的连续子序列中，序列和最大的是多少。最容易想到的方法，效率是O(n*lmaxin);

          for(int i=0;i<n;i++)
          {
            int s=0;
            for(int j=i;j>=max(0,i-lmaxin+1);j--)
            {
                s+=a[i];
                ans=max(ans,s);
            }

         }

上面的代码中其实有很多都是重复比较了，所以效率低
单调队列优化的代码

        rear=head=0;
        for(int i=1;i<=n;i++)
        {
           while(rear>=front&&s[i]<q[rear-1])
           {rear--;}
           q[rear++]=i;
           while(q[front]<i-m)
               front++;
           ans=max(ans,s[i]-s[q[front]]);
         }

s数组是前缀和，给定一个端点，求端点左边长度为m的区间的最小值就可以了。其实就相当于把原来的长度为m的for循环变成单调队列。区间长度是固定的m，单调队列求解区间的最小值，比暴力的for循环要高效率的多，因为元素只是一进一出，效率是O(n)。那么联系到单调栈，那么单调栈可以优化区间长度不断增加且左端点固定的最大值(个人联想)。

那么经常听到的单调队列优化背包的也很好理解了。给一道题目多重背包单调队列优化，hdu上面不用优化，poj需要优化
http://poj.org/problem?id=1742
hdu AC的代码

#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stdlib.h>

using namespace std;
#define MIN -9999
int dp[100005];
int n;
int m;
int a[100005];
int b[1005];
void ZeroOnePack(int v,int w)
{
    for(int i=m;i>=w;i--)
    {
        if(dp[i-w]!=MIN)
            dp[i]=max(dp[i],dp[i-w]+v);
    }
}
void CompletePack(int v,int w)
{
    for(int i=w;i<=m;i++)
    {
        if(dp[i-w]!=MIN)
            dp[i]=max(dp[i],dp[i-w]+v);
    }
}
void MultiplyPack(int v,int w,int c)
{
    if(c*w>m)
    {
        CompletePack(v,w);
        return ;
    }
    int k;
    k=1;
    while(k<c)
    {
        ZeroOnePack(k*v,k*w);
        c=c-k;
        k<<=1;
    }
    ZeroOnePack(c*v,c*w);
}
int main()
{
    int result;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        result=0;
        if(n==0&&m==0)
            break;
        for(int i=1;i<=n;i++)
          scanf("%d",&a[i]);
        for(int i=1;i<=n;i++)
          scanf("%d",&b[i]);
        for(int i=0;i<=m;i++)
            dp[i]=MIN;
        dp[0]=0;
        for(int i=1;i<=n;i++)
             MultiplyPack(a[i],a[i],b[i]);
         for(int i=1;i<=m;i++)
         {
             if(dp[i]!=MIN)
                 result++;
         }
        printf("%d\n",result);
    }
    return 0;

}

poj 单调队列优化的POJ的代码

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <math.h>

using namespace std;
#define MAX 100000
int dp[MAX+5];
int a[105];
int c[105];
int n,m;
int rear;
int front;
int queue[MAX+5];
int ans;
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
            break;
        ans=0;
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(int j=0;j<n;j++)
            scanf("%d",&c[j]);
        memset(dp,0,sizeof(dp));
        dp[0]=1;
        for(int i=0;i<n;i++)
        {
            if(c[i]==1)
            {
                for(int j=m;j>=a[i];j--)
                    if(!dp[j]&&dp[j-a[i]])
                        dp[j]=1;
            }
            else if(c[i]*a[i]>=m)
            {
                for(int j=a[i];j<=m;j++)
                    if(!dp[j]&&dp[j-a[i]])
                        dp[j]=1;
            }
            else
            {
                for(int k=0;k<a[i];k++)
                {
                    rear=0;front=0;int sum=0;
                    for(int j=k;j<=m;j+=a[i])
                    {
                        if((rear-front)==c[i]+1)
                            sum-=queue[front++];
                        queue[rear++]=dp[j];
                        sum+=dp[j];
                        if(!dp[j]&&sum)
                            dp[j]=1;
                    }
                }
            }
        }
        for(int i=1;i<=m;i++)
            if(dp[i]) ans++;
        printf("%d\n",ans);
    }
}

第一个是倍增方法，第二个是单调队列优化的方法，其实不用分成0 1背包和完全背包，直接用单调队列就可以。多重背包优化，要把根据余数把体积分成几类
参考这个资料的

之间用倍增法写的多重背包都可以用单调队列优化
http://acm.hdu.edu.cn/showproblem.php?pid=2191
可以试试用单调队列进行优化

//
//  main.cpp
//  单调队列优化1
//
//  Created by 陈永康 on 16/1/16.
//  Copyright &#169; 2016年 陈永康. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>

using namespace std;
int c[105];
int w[105];
int v[105];
int dp[105];
int n,m;
int b[105];
int a[105];
int rear,front;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,0,sizeof(dp));
        scanf("%d%d",&m,&n);
        for(int i=0;i<n;i++)
            scanf("%d%d%d",&w[i],&v[i],&c[i]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<w[i];j++)
            {
                    rear=front=0;
                    for(int k=0;k<=(m-j)/w[i];k++)
                    {
                        int x=k;
                        int y=dp[k*w[i]+j]-k*v[i];
                        while(front<rear&&y>=b[rear-1])
                            rear--;
                        a[rear]=x;
                        b[rear++]=y;
                        while(a[front]<k-c[i])
                            front++;
                        dp[k*w[i]+j]=b[front]+k*v[i];
              }

            }
        }
        printf("%d\n",dp[m]);
    }
    return 0;
}

单调队列不仅可以优化多重背包，可以优化别的DP问题
一道好题目
这是时间超限的代码

//
//  main.cpp
//  单调队列优化3
//
//  Created by 陈永康 on 16/1/19.
//  Copyright &#169; 2016年 陈永康. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;
#define MAX 1<<30
int dp[2005][2005];
int w,t,MaxP;
int buy[2005];
int sell[2005];
int MaxB[2005];
int MaxS[2005];
int main()
{
    int cas;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d%d",&t,&MaxP,&w);
        for(int i=1;i<=t;i++)
            scanf("%d%d%d%d",&buy[i],&sell[i],&MaxB[i],&MaxS[i]);
        for(int i=1;i<=2000;i++)
            for(int j=1;j<=2000;j++)
                dp[i][j]=-MAX;
        for(int i=0;i<=MaxB[1];i++)
            dp[1][i]=0-buy[1]*i;
        for(int i=2;i<=t;i++)
        {
            for(int j=0;j<=MaxP;j++)
            {
                for(int k=1;k<=MaxP;k++)
                {
                    if(i-w-1<=0||j-k>MaxB[i]||j<=k)
                        continue;
                    if(dp[i-w-1][k]==MAX)
                        continue;
                    dp[i][j]=max(dp[i][j],dp[i-w-1][k]-buy[i]*(j-k));
                }
                for(int k=1;k<=MaxP;k++)
                {
                    if(i-w-1<=0||k<=j||k-j>MaxS[i])
                        continue;
                    if(dp[i-w-1][k]==MAX)
                        continue;
                    dp[i][j]=max(dp[i][j],dp[i-w-1][k]+sell[i]*(k-j));
                }
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
            }
        }
        int ans=0;
        for(int j=0;j<=MaxP;j++)
            ans=max(ans,dp[t][j]);
        printf("%d\n",ans);


    }
    return 0;
}

状态转移方程不难想到，但是写出来就是时间超限的，用单调队列优化的代码

//
//  main.cpp
//  单调队列优化3
//
//  Created by 陈永康 on 16/1/19.
//  Copyright &#169; 2016年 陈永康. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;
#define MAX 1<<30
int dp[2005][2005];
int w,t,MaxP;
int buy[2005];
int sell[2005];
int MaxB[2005];
int MaxS[2005];
int a[2005];
int b[2005];
int rear;
int front;
int main()
{
    int cas;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d%d",&t,&MaxP,&w);
        for(int i=1;i<=t;i++)
            scanf("%d%d%d%d",&buy[i],&sell[i],&MaxB[i],&MaxS[i]);
        for(int i=1;i<=2000;i++)
            for(int j=1;j<=2000;j++)
                dp[i][j]=-MAX;
        for(int i=1;i<=t;i++)
           for(int j=0;j<=min(MaxP,MaxB[i]);j++)
                 dp[i][j]=0-buy[i]*j;
        for(int i=2;i<=t;i++)
        {
            for(int j=0;j<=MaxP;j++)
                dp[i][j]=max(dp[i][j],dp[i-1][j]);
            if(i-w-1<=0)
                continue;
            rear=front=0;
            b[rear]=dp[i-w-1][0];
            a[rear]=0;
            for(int j=1;j<=MaxP;j++)
            {

                int x=j;
                int y=dp[i-w-1][j];
                while(front<=rear&&b[rear]-(j-a[rear])*buy[i]<y)
                    rear--;
                b[++rear]=y;
                a[rear]=x;
                while(front<=rear&&a[front]+MaxB[i]<j)
                    front++;
                dp[i][j]=max(dp[i][j],b[front]-(j-a[front])*buy[i]);

            }
            rear=front=0;
            b[rear]=dp[i-w-1][MaxP];
            a[rear]=MaxP;
            for(int j=MaxP-1;j>=0;j--)
            {
                int x=j;
                int y=dp[i-w-1][j];
                while(front<=rear&&b[rear]+(a[rear]-j)*sell[i]<y)
                    rear--;
                b[++rear]=y;
                a[rear]=x;
                while(front<=rear&&a[front]-MaxS[i]>j)
                    front++;
                dp[i][j]=max(dp[i][j],b[front]+(a[front]-j)*sell[i]);
            }

        }
        int ans=0;
        for(int j=0;j<=MaxP;j++)
            ans=max(ans,dp[t][j]);
        printf("%d\n",ans);


    }
    return 0;
}

说了这么多单调队列的，就说一下单调栈的应用
http://poj.org/problem?id=2082
题目的意思就是给你一系列矩形，求最大的矩形面积
这道题目可以用暴力的方法O(n^2),用单调栈的话就是O(n);
单调栈是递增的，这个单调栈在入栈的时候要合并矩形，合并之后再入栈。
暴力ac的代码

#include <iostream>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;
#define MAX 50000
struct Node
{
    int w;
    int h;
}a[MAX+5];
int n;
int ans;
int sum;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        if(n==-1)
            break;
        ans=0;
        sum=0;
        for(int i=0;i<n;i++)
            scanf("%d%d",&a[i].w,&a[i].h);
        for(int i=0;i<n;i++)
        {
            sum=0;
            for(int j=i+1;j<n;j++)
            {
                if(a[j].h>=a[i].h)
                    sum+=a[i].h*a[j].w;
                else
                    break;
            }
            for(int p=i-1;p>=0;p--)
            {
                if(a[p].h>=a[i].h)
                    sum+=a[i].h*a[p].w;
                else
                    break;
            }
            sum+=a[i].w*a[i].h;
            ans=max(ans,sum);

        }
        printf("%d\n",ans);
    }
    return 0;


}

单调栈优化的代码

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <math.h>
#include <stack>

using namespace std;
#define MAX 50000
int n;
struct Node
{
    int x,y;
}a[MAX+5];
stack<Node> Stack;
int ans;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {

        if(n==-1)
            break;
        while(!Stack.empty())
            Stack.pop();
        ans=0;
        for(int i=0;i<n;i++)
            scanf("%d%d",&a[i].x,&a[i].y);
        Stack.push(a[0]);
        for(int i=1;i<n;i++)
        {
            int sum=0;
            Node term=Stack.top();
            while(term.y>a[i].y)
            {
                sum+=term.x;
                ans=max(ans,sum*term.y);
                Stack.pop();
                if(Stack.empty())
                    break;
                term=Stack.top();
            }
            Node temp;
            temp.x=sum+a[i].x;
            temp.y=a[i].y;
            Stack.push(temp);
        }
        int sum=0;
        while(!Stack.empty())
        {
            Node term=Stack.top();
            sum+=term.x;
            ans=max(ans,sum*term.y);
            Stack.pop();
        }
        printf("%d\n",ans);
    }
}

这里并不能看出单调栈的求区间最大值的功能，反而是运用了单调栈单调的特性，进行求解。这也是单调栈，单调队列这种数据结构有魅力的地方吧

转载于:https://www.cnblogs.com/dacc123/p/8228806.html

躲不过这哀伤
关注
深入浅出单调栈与单调队列
⚡
02-11 7671
深入浅出单调栈与单调队列
单调队列与单调栈总结
skysys的研究小屋
10-04 576
Ref:http://blog.sina.com.cn/s/blog_6ffc3bde01015l2m.html 单调栈解决的是以某个值为最小（最大）值的最大区间，实现方法是：求最小值（最大值）的最大区间，维护一个递增（递减）的栈，当遇到一个比栈顶小的值的时候开始弹栈，弹栈停止的位置到这个值的区间即为此值左边的最大区间；同时，当一个值被弹掉的时候也就意味着比它更小（更大）的值来了，也可以计算被弹掉
单调队列和单调栈详解
小楼吹彻玉笙寒
12-14 6308
这里是我的blog：有更多算法分享=v= https://endlesslethe.com/monotone-queue-and-stack-tutorial.html 前言 单调栈和单调队列算是栈和队列的高级应用吧，在公司面试中应该是不怎么会出现的（除非算法岗？）。因为原理比较简单，网络上的相关资料反而对于这两个东西说得都不甚清楚，尤其是它们的应用方法。最基本的两本中文算法书“紫书”和“白皮”都
单调队列
爱.NET
04-06 111
现在有一个数列{An}，假设它有n项，问题是：求出每个区间长度为k的连续区间内数列的最小值。 有种很容易想到的解法： 遍历每个所求区间，依次找出它们的最小值。复杂度为O( (n-k)*k ) 分析上面的解法我们不难发现，在找最小值时，我们做了很多重复的比较。这样的做法无疑使复杂度变大，有没有一个好的办法可以不要做这些重复比较呢？ 于是，引出了我们本文的主角：单调队列。 单调队列是这样一个...
单调队列【总结】
算法小猪的博客
07-12 1933
一、基本概念 单调队列是指：单调递增或单调递减的队列。所以它也有如下几个性质： 1.队列中的元素在原来的列表中的位置是由前往后的(随着循环顺序入队)。 2.队列中元素的大小是单调递增或递减的。 3.从队尾入列，队首或队尾出列 时间复杂度：O(N) 二、例题 1.最大子序和（dp+单调队列优化） 题目描述 输入一个长度为n的整数序列，从中找出一段不超过m的连续子序列，使得整个序列的和最大。 例如 1,-3,5,1,-2,3 当m=4时，S=5+1-2+3=7 当m=2或m=3时，S=5+1=6 输入 第一行两
单调队列总结
老李2009
04-17 586
poj 2823     N个数，每次从左到右选取K个数，第一行选取每个区间中的最小值输出，第二行选取最大值并输出。
单调栈和单调队列的本质区别
qq_37957064的博客
04-21 1292
栈和队列   栈个队列的区别我们都知晓，栈是只有一端可以插入和删除的线性表，它是一个先进后出的结构，而队列则是有两个端口可以分别进行插入和删除，满足先进先出的特性。   但是实际情况中，我们维持的单调栈与栈的数据结构式吻合的，而维持的单调队列则大部分可能都是双端队列，那么看到一个问题，我们如何确定到底使用来个结构来维持一个单调的序列的？ 单调栈   我想有很多小伙伴其实也不明白，有时候看着直到要使用单调序列来求解，但是却不直到到底用的是单调栈还是单调队列，这就给人一种隔着一层膜，但是始终都捅不破的感觉，这里
CJ2-05-数据结构-单调栈和单调队列.pdf
最新发布
02-17
### 数据结构：单调栈与单调队列 ...**总结**：单调栈和单调队列是两种重要的数据结构，能够高效地解决特定类型的问题。通过掌握它们的基本原理和实现细节，可以更灵活地应对编程竞赛和实际工程中的问题。
【总结】单调队列
cqbzlydd的博客
11-27 145
[CEOI2020]花式围栏 题意 在所给的围栏中算出所含矩形的个数。 solution: 对于计算一个长为lll，宽为rrr的矩形，可以算出方案为： (l+12)∗(r+12){l+1 \choose 2}*{r+1 \choose 2}(2l+1​)∗(2r+1​) 考虑将围栏分割成若干个规则的矩形，分别计算贡献并相加。 如图，可以将围栏分成若干个由红色矩形组成的区域，相加即可。（注意，这里是求左端点在给定矩形内时的矩形数，而且必须是极大矩阵，即左右都不能扩展） 如右图，第一个的方案为： (l+12)∗
单调队列内容总结
雨潇的博客
05-05 292
单调队列: 定义：队列中元素之间的关系具有单调性，而且，队首和队尾都可以进行出队操作，只有队尾可以进行入队操作。 常用操作： （1）插入：若新元素从队尾插入后会破坏单调性，则删除队尾元素，直到插入后不再破坏单调性为止，再将其插入单调队列。 （2）获取最优（最大、最小）值：访问首尾元素。 单调队列最重要的是要进入的元素的能否进入，之前已经进入队列的元素都会为其让路。 标准模板： in...
单调队列详解
包磊磊的博客
02-08 4538
刚学单调队列时，在网上各大博客找文章学，说实话，写得很杂，表示自己懵逼了些许，最后硬是啃出来了，所以我决定要写一篇能让大部分人都看懂的博客来。 说单调队列，那我们就先说说这个单调队列是个什么物种。单调队列从字面上看，无非就是有某种单调性的队列，没错，这就是所谓的单调队列。单调队列它分两种，一种是单调递增的，另外一种是单调递减的。 在这搬出百度百科的解释：不断地向缓存数组里读入元素，也不时地去掉最老的元素，不定期的询问当前缓存数组里的最小的元素。 用单调队列来解决问题，一般都是需要得到当前的某个..
P1886 滑动窗口 /【模板】单调队列
tomjobs的博客
01-19 1728
展开 题目描述 有一个长为 nn 的序列 aa，以及一个大小为 kk 的窗口。现在这个从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最大值和最小值。 例如： The array is [1,3,-1,-3,5,3,6,7][1,3,−1,−3,5,3,6,7], and k = 3k=3。 输入格式 输入一共有两行，第一行有两个正整数 n,kn,k。 第二行 nn 个整数，表示序列...
单调队列和单调栈
Ellen的博客
07-25 586
概念 一种具有单调性的队列，分为单调递增队列和单调递减队列。 适合场景 维护区间最值，即，适合解决RMQ（rang maximum/minimum query）问题，也称之为滑动窗口区间最值问题。 若维护区间最小值，则需要维护一个单调递增的序列；若维护区间最大值，则需要维护一个单调递减的序列。 维护单调队列性值的操作 入队操作：队尾入队，会把之前破坏单调性的元素都从队尾移出（维护单调性）。 出队操作：如果队首元素超出区间范围，就将元素从队首出队。 1.1 习题 1） 239. 滑动窗口最大值 一个整数数组
单调队列 和 单调栈
duaduac.com
08-06 580
单调队列定义 有一个队列(双端队列)， 队列中的元素满足下面四种状态的任何一种都为单调队列: 单调递增 (如 1 2 3 5 9) 单调不减 (如 1 2 3 3 5) 单调递减 (如 9 5 3 2 1) 单调不增 (如 5 3 3 2 1) 性质 (以单增队列为例)  插入时，需要将尾部大于此数的全部出队。  删除时，根据需要使队首或者队尾的元素出队(所
python单调栈和单调队列
09-15
在Python中，单调栈和单调队列是两种不同的数据结构。单调栈是一个栈，它的特点是栈内的元素是单调的，可以是递增或递减的。在构建单调栈时，元素的插入和弹出都是在栈的一端进行的。与此类似，单调队列也是一个队列，它的特点是队列内的元素是单调的，可以是递增或递减的。在构建单调队列时，元素的插入是在队列的一端进行的，而弹出则是选择队列头进行的。 单调队列在解决某些问题时，能够提升效率。例如，滑动窗口最大值问题可以通过使用单调队列来解决。单调队列的结构可以通过以下代码来实现： ```python class MQueue: def __init__(self): self.queue = [] def push(self, value): while self.queue and self.queue[-1 < value: self.queue.pop(-1) self.queue.append(value) def pop(self): if self.queue: return self.queue.pop(0) ``` 上述代码定义了一个名为MQueue的类，它包含一个列表作为队列的存储结构。该类有两个方法，push和pop。push方法用于向队列中插入元素，它会删除队列尾部小于插入元素的所有元素，并将插入元素添加到队列尾部。pop方法用于弹出队列的头部元素。 总结来说，单调栈和单调队列都是为了解决特定问题而设计的数据结构。单调栈在构建时元素的插入和弹出都是在栈的一端进行的，而单调队列则是在队列的一端进行的。在Python中，可以通过自定义类来实现单调队列的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值