单调队列/单调栈

单调队列

模型

• 滑动窗口模型

  P1886 滑动窗口 /【模板】单调队列
  

思想

维护一个单调的队列，队列中删除无意义的数，例

• 找最大值时
  维护一个单调递减的队列，假设有$a[i]<a[j]$并且$i<j$那么可以得知$a[i]$在题中无意义，因为假如$a[i]$可以当作最大值，那么$a[j]$一定也能，并且还优于$a[i]$，只维护一个单调递减队列，最大值就是队首
• 最小值同理维护单调递增序列

准备

最好使用数组模拟队列，时间上优于用STL
模版

int hh = 0, tt = 0;	//队首队尾
q[++ tt] = val;		//队尾入队
hh ++;				//队首出队
tt --;				//队尾出队
if(hh <= tt)		//队不为空

具体模版

//	区间内最大值
int hh = 0, tt = -1;
for (int i = 1; i <= n; i ++){
    if (hh <= tt &&  i - k + 1 > q[hh]) hh ++;
    while(hh <= tt && arr[q[tt]] >= arr[i]) tt--;	//最小值>=改成<=
    q[++ tt] = i;
    //cout << arr[q[hh]] << " ";	
}

例题

P1714 切蛋糕

题意：找连续m个最大值，m<=k，k已知。
思路：前缀和+单调队列
前缀和表示之后，连续个就是从i-k+1~i中找到最小值，a[i+1]-minn,可得结果

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x7fffffff;
const int maxn = 5e5 + 5;
int pre[maxn];
int q[maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m, t;
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> t, pre[i] = pre[i - 1] + t;
    int hh = 0, tt = 0;
    int maxx = pre[1];
    for (int i = 1; i < n; i ++){
        if (hh <= tt && i - m + 1 > q[hh]) hh ++;
        while (hh <= tt && pre[q[tt]] >= pre[i]) tt --;
        q[++ tt] = i;
        maxx = max(maxx, pre[i + 1] - pre[q[hh]]); 
    }
    cout << maxx << endl;
    system("pause");
    return 0;
}

P2034 选择数字

思路：首先枚举每位数$dp[i][0]$表示不取该数，$dp[i][1]$表示取该数，那么我们下一步思考方向是如何表示$dp[i][1]$要满足题目的条件，可以考虑从$dp[x][0]$转移过来，x为范围内的数字，那么可以通过得知转移条件：
$$dp[i][0]=max(dp[i-1][0],dp[i-1][1])$$$$dp[i][1]=max(dp[x][0]+sum[i]-sum[x])（i-k<=x<i）$$
可整理式子2发现$sum[i]$于max无关，提取出来
$$dp[i][1]=max(dp[x][0]-sum[x])+sum[i]（i-k<=x<i）$$
该式子时间复杂度为$O(n^2)$不满足要求，继续，发现$dp[x][0]-sum[x]$的值刚好是一个滑动窗口模型，可以用单调队列来维护最大值，因此题目可解，时间复杂度$O(n)$
代码

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x7fffffff;
const int maxn = 1e5 + 5;
ll a[maxn], s[maxn], dp[maxn][2], q[maxn], b[maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i ++) cin >> a[i], s[i] = s[i - 1] + a[i];
    int hh = 0, tt = 0;			//队列初始放入一个0，
    dp[1][0] = 0, dp[1][1] = a[1];
    for (int i = 1; i < n; i ++){
        b[i] = dp[i][0] - s[i];
        if (hh <= tt && i - k + 1 > q[hh]) hh ++;
        while (hh <= tt && b[q[tt]] <= b[i]) tt--;
        q[++ tt] = i; 
        dp[i + 1][0] = max(dp[i][0], dp[i][1]);
        dp[i + 1][1] = b[q[hh]] + s[i + 1];
    }
    cout << max(dp[n][0], dp[n][1]) << endl;

    return 0;
}

单调栈

解决的问题

求出一系列数，每个数离他最近的第一个小于/大于他数的值

思想

同单调队列大致相同，维护一个单调的栈，例求第一个最小值
每个数当他小于前面的数时，同时他又在前面的数右边，那么前面大于他的数对于后面的数便无意义

模版

stack<int> s;
for (int i = 1; i <= n; i ++){
    while(!s.empty() && a[s.top()] >= a[i]) s.pop();
    if (s.empty()) l[i] = 0;
    else l[i] = s.top();
    s.push(i);
}

例题

P2422 良好的感觉

思路：先找到每个数左右两边小于该数的第一个数，之后枚举每个数，枚举以该数为最糟糕点的范围，找出最大值即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 0x7fffffff;
const int maxn = 1e5 + 5;
ll a[maxn], sum[maxn];
int l[maxn], r[maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i ++){
        cin >> a[i];
        sum[i] = sum[i - 1] + a[i];
    }
    stack<int> s;
    for (int i = 1; i <= n; i ++){
        while(!s.empty() && a[s.top()] >= a[i]) s.pop();
        if (s.empty()) l[i] = 0;
        else l[i] = s.top();
        s.push(i);
    }
    while (!s.empty()) s.pop();
    for (int i = n; i >= 1; i --){
        while(!s.empty() && a[s.top()] >= a[i]) s.pop();
        if (s.empty()) r[i] = n + 1;
        else r[i] = s.top();
        s.push(i);
    }
    ll maxx = 0;
    for (int i = 1; i <= n; i ++){
        maxx = max(maxx, a[i] * (sum[r[i] - 1] - sum[l[i]]));
    }
    cout << maxx << endl;
    system("pause");
    return 0;
}