2. 程式人生 > >單調佇列，單調棧總結

單調佇列，單調棧總結

阿新 • • 發佈：2019-02-02

最近幾天接觸了單調佇列，還接觸了單調棧，就總結一下。
其實單調佇列，和單調棧都是差不多的資料型別，顧名思義就是在棧和佇列上加上單調，單調遞增或者單調遞減。當要入棧或者入隊的時候，要和棧頭或者隊尾進行比較，滿足單調的性質則入隊入棧，否則將當前元素刪去，直到滿足單調性質。
那麼問題來了，單調佇列，和單調棧有什麼用了。最普遍的最重要的作用就是起到優化的作用。當然我目前也只知道這個所用。
先看一道例題：
求一個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揹包和完全揹包，直接用單調佇列就可以。多重揹包優化，要把根據餘數把體積分成幾類
參考這個資料的

//
//  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);
    }
}

這裡並不能看出單調棧的求區間最大值的功能，反而是運用了單調棧單調的特性，進行求解。這也是單調棧，單調佇列這種資料結構有魅力的地方吧

相關推薦

單調佇列，單調棧總結

最近幾天接觸了單調佇列，還接觸了單調棧，就總結一下。 其實單調佇列，和單調棧都是差不多的資料型別，顧名思義就是在棧和佇列上加上單調，單調遞增或者單調遞減。當要入棧或者入隊的時候，要和棧頭或者隊尾進行比較，滿足單調的性質則入隊入棧，否則將當前元素刪去，直到滿足單

1215 】陣列的寬度 （單調棧 或 分治 或 單調佇列，算貢獻，需去重）

題幹： N個整陣列成的陣列，定義子陣列aii..ajj的寬度為：max(ai..aj) - min(ai..aj)，求所有子陣列的寬度和。 Input 第1行：1個數N，表示陣列的長度。(1 <= N <= 50000)  第2 - N + 1行：每行1個數

NOIP2004合唱隊列（提高組T3）————單調佇列，動態規劃（最長上升序列，最長下降序列）

題解：本題主要考查單調佇列，動態規劃（最長上升序列，最長下降序列）。這個序列是一箇中間高，兩頭底的序列，先解決從T1到Ti這一段單調遞增的序列，再解決Ti到TK這一段單調遞減的序列（注意數值的更新）。 程式碼如下： #include<iostream> #include<

[模板]單調佇列與單調棧

目錄 單調佇列：滑動視窗（算是重要的板題了） 單調棧：最大矩形面積 總結 首先給一道板題：滑動視窗（十分重要，基本後面的複雜題由此題思路進行優化） 題目描述 給你一個長度為N的陣列，一個長為K的滑動的窗體從最左移至最右端，你只能見到視窗的K個數，每次窗體向右移動一位，如下

近期目標：單調佇列，尺取，分塊，塊狀連結串列

近期打算趕緊補一些遺漏的知識點 尺取：https://blog.csdn.net/consciousman/article/details/52348439 單調佇列： https://blog.csdn.net/justmeh/article/details/5844650 　　　　　&nb

#斜率優化，單調佇列，動態規劃#bzoj 2684 洛谷 4360 鋸木場選址

題目連結 分析 設 d p [ i

單調佇列和單調棧

目錄 單調棧 什麼是單調棧 單調棧的應用 排隊遞減單調棧 最大長方形遞增單調棧 單調佇列 什麼是單調佇列 單調佇列的應用 單調佇列的基本模板 單調佇列的重要應用DP 單調棧 什麼是單調棧 什麼叫做單調棧？ 什麼是單調？ 單調也就是序

矩形牛棚——淺談C++單調佇列和單調棧

矩形牛棚    BZOJ    1114 目錄 前言 正文 解析 單調棧 前言 厲害的是，這道題在LGOJ上面又沒有。 這道題也算花了我比較多的時間哈，不過其實只是利用單調棧求解一個最大長方形。 正文 題目描述

單調佇列與單調棧用法詳解

基本資料結構的應用一 棧和佇列 單調棧 單調佇列 和  優先佇列的應用 1.單調棧 單調棧是指一個棧內部的元素是具有嚴格單調性的一種資料結構，分為單調遞增棧和單調遞減棧。 單調棧有兩個性質 1.滿足從

單調佇列 和 單調棧

單調佇列 定義 有一個佇列(雙端佇列)， 佇列中的元素滿足下面四種狀態的任何一種都為單調佇列: 單調遞增 (如 1 2 3 5 9) 單調不減 (如 1 2 3 3 5

單調棧，單調佇列的入門

轉載地址：https://www.cnblogs.com/tham/p/8038828.html 我自己的話單調棧是也用陣列模擬出來的，我是根據這個部落格學的，原理挺簡單的，但是做題思想的轉變有點麻煩，最後陣列模擬的單調佇列其實是雙向佇列。 下邊是大佬的部落格： 單調佇列是什麼呢？可以直

單調隊列，單調棧相關

剔除 地址 logs www. += 夠快 ash 簡單 數組 說起這個話題，應該很多人會有一種似有所悟，但又不敢確定的感覺。 （我差不多就是那樣） 沒錯，這正是因為其中“單調”一詞的存在。 那麽單調是什麽？ 學過函數的人都知道單調函數或

[USACO18JAN]Lifeguards P 洛谷黑題，單調佇列優化DP

傳送門：戳我 這道題有兩個版本，S和P，S是K等於1的情況，顯然可以用線段樹水過。 P版本就難了很多，洛谷黑題（NOI/NOI+/CTSC），嘿嘿。 我自己也不是很理解，照著題解寫了一遍，然後悟到了一點東西。 dp方程很好想： dp[i][j]表示處理到第i個元素，已經刪掉了j個，但取了第i個。

[HDU2191] 悼念512汶川大地震遇難同胞——珍惜現在，感恩生活 [單調佇列][多重揹包]

[ L i n

BZOJ2806: [Ctsc2012]Cheat（廣義字尾自動機，單調佇列優化Dp）

Description Input 第一行兩個整數N，M表示待檢查的作文數量，和小強的標準作文庫的行數接下來M行的01串，表示標準作文庫接下來N行的01串，表示N篇作文 Output N行，每行一個整數，表示這篇作文的Lo 值。 Sample Input

筆記——單調佇列&&單調棧優化DP

眾所周知 動態規劃 的 題 往往 推了a long time 但是o(n^3) 於是就自閉了 所以我們有了 單調佇列和棧 這種東西 神奇的單調佇列 有這麼一道題 樸素 o(n^2) 亂搞 o(nlog n)（線段樹、RMQ） 然後。。。 單調佇列 o(

蒟蒻的單調佇列orz，真的蒻

（……打了這麼久orz我今天才知道這玩意是啥意思……） 沒有老師就是飄啊……我居然學完樹狀陣列和線段樹連個佇列都不會……orz orz orz 這篇是單調佇列哦，不是優先佇列（優先佇列那種東西queue不就好了嘛） 咳咳咳廢話說的真多，回到正題 什麼是單調佇列 咳咳

牛可樂發紅包脫單ACM賽$ C-區區區間間間（單調棧or單調佇列）

思路來源 題解 看標程那個看不懂，只好看這個 反正就是求一個區間最值的貢獻，以後見到用這個板子就好了... 很固定很套路很裸的區間最值... 標程給了我們這個提示，化簡式把負號放進後項裡去，相當於 求數列an最大值的區間貢獻+數列bn最大值的區間貢

揹包模板（01，完全，多重揹包的二進位制優化和單調佇列優化

揹包問題 1，01揹包 揹包問題的基礎，總體積為V的揹包，有n件體積v【i】，價值w【i】的物品，求能裝物品的最大總價值 void zero(int v,int w) { for(int j=V;j>=v;j--) { dp[j]=max(dp[j],dp[j

【洛谷 P1419】 尋找段落（二分答案，單調佇列）

題目連結 開始還以為是尺取。發現行不通。 一看標籤二分答案，恍然大悟。 二分一個\(mid\)(實數)，把數列裡每個數減去\(mid\)，然後求字首和，在用單調佇列維護\(sum[i-t\text{~}i-s]\)的最小值，用\(sum[i]\)減去它，如果大於等於\(0\)就說明\(mid\)可行。 #