单调队列原理回顾和例题分析

原理

单调队列解决的问题的基本模型是滑动窗口问题，也就是给一个数组和一个窗口大小，从左面滑到最右面，问每次滑动的区间最大值和最小值

• 这里只用语言简单描述一下，具体画图可以参考https://zhuanlan.zhihu.com/p/346354943
• 如果是维护区间最大值，用一个双端队列，我们的目的是让队尾元素为区间最大值，每次入队的时候把所有队首元素比当前还小的全部弹出，然后把这个元素放在队首，同时检查队尾元素是否已经超出了窗口，如果超出了窗口，那么全部弹出，最后得到队尾元素就是区间最大值，这也就是所谓的如果有一个人比你还大比你还弱，那么那个人就可以退役了，如果维护区间最小值同理

例题

https://www.luogu.com.cn/problem/P1886

• 滑动窗口求区间最大值和最小值

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct st{
    int id;
    int val;
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    vector<st> a(n);
    for(int i=0;i<n;i++){
        cin >> a[i].val;
        a[i].id = i;
    }
    deque<int> q;
    for(int i=0;i<n;i++){
        while(!q.empty() && a[q.front()].val >= a[i].val) q.pop_front();
        q.push_front(a[i].id);
        while(a[q.back()].id <= (i - k)) q.pop_back();
        if(i >= k - 1) cout << a[q.back()].val << ' ';
    }
    cout << '\n';
    q.resize(0);
    for(int i=0;i<n;i++){
        while(!q.empty() && a[q.front()].val <= a[i].val) q.pop_front();
        q.push_front(a[i].id);
        while(a[q.back()].id <= (i - k)) q.pop_back();
        if(i >= k - 1) cout << a[q.back()].val << ' ';
    }
    return 0;
}

https://www.luogu.com.cn/problem/P2216
在一个大区域中求一个子区域，使得这个子区域中的最大值和最小值的差最小，求这个值

• 从行来看，一个固定大小的子区域相当于一个滑动窗口，我们可以横向求出滑动窗口内部的最小值和最大值
• 这样以后，我么按照列方向对行方向求出的矩阵再做两次滑动窗口，得到的答案就是一个区域的最大值和最小值，不难理解

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int a, b, n;
    cin >> a >> b >> n;
    vector<vector<int> > mp(a, vector<int>(b));

    vector<vector<int> > mxx(a, vector<int>(b));
    vector<vector<int> > mxy(a, vector<int>(b));
    vector<vector<int> > mnx(a, vector<int>(b));
    vector<vector<int> > mny(a, vector<int>(b));
    for(int i=0;i<a;i++){
        for(int j=0;j<b;j++){
            cin >> mp[i][j];
        }
    }
    vector<int> S(max(a, b));
    for(int i=0;i<a;i++){
        deque<int> q1, q2;
        for(int j=0;j<b;j++){
            while(!q1.empty() && mp[i][j] > mp[i][q1.front()]){
                q1.pop_front();
            }
            q1.push_front(j);
            while(j - q1.back() >= n) q1.pop_back();
            if(j >= n - 1) mxx[i][j] = mp[i][q1.back()];

            while(!q2.empty() && mp[i][j] < mp[i][q2.front()]){
                q2.pop_front();
            }
            q2.push_front(j);
            while(j - q2.back() >= n) q2.pop_back();
            if(j >= n - 1) mnx[i][j] = mp[i][q2.back()];
        }
    }

    for(int j=0;j<b;j++){
        deque<int> q1, q2;
        for(int i=0;i<a;i++){
            while(!q1.empty() && mxx[i][j] > mxx[q1.front()][j]){
                q1.pop_front();
            }
            q1.push_front(i);
            while(i - q1.back() >= n) q1.pop_back();
            if(i >= n - 1) mxy[i][j] = mxx[q1.back()][j];

            while(!q2.empty() && mnx[i][j] < mnx[q2.front()][j]){
                q2.pop_front();
            }
            q2.push_front(i);
            while(i - q2.back() >= n) q2.pop_back();
            if(i >= n - 1) mny[i][j] = mnx[q2.back()][j];
        }
    }
    int ans = 0x7fffffff;
    for(int i=n-1;i<a;i++){
        for(int j=n-1;j<b;j++){
            ans = min(ans, mxy[i][j] - mny[i][j]);
        }
    }
    cout << ans;
    return 0;
}

优化DP

https://www.luogu.com.cn/problem/P2034

• 用$dp[i][0/1]$表示第$i$个物品选或者不选所能达到的数字之和的最大值，$sum[i]$表示前缀和，因为不能有超过$k$个连续的数字被选择，所以转移方程显然为$$\{\begin{array}{rl}dp[i][0]& =max(dp[i-1][0],dp[i-1][1]\\ dp[i][1]& =max(dp[i][1],dp[j][0]+sum[i]-sum[j]),i-k\le j\le i\end{array}$$
  但这样第二行的时间复杂度是$O(n^2)$，考虑优化，因为$i-k\le j\le i$，我们只需要找到使得$dp[j][0]-sum[j]$最大的情况即可，使用单调队列维护它的最大值，使之处于队首，队列内部元素的$dp[j][0]-sum[j]$是单调递减的

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    vector<ll> a(n + 1), sum(n + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        sum[i] = sum[i - 1] + a[i];
    }
    vector<vector<ll> > dp(n + 1, vector<ll>(2));
    deque<int> q;
    q.push_back(0);
    for(int i=1;i<=n;i++){
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
        while(!q.empty() && i - k > q.front()) q.pop_front();
        dp[i][1] = dp[q.front()][0] - sum[q.front()] + sum[i];
        while(!q.empty() && sum[i] - dp[i][0] < sum[q.back()] - dp[q.back()][0]) q.pop_back();
        q.push_back(i);
    }
    cout << max(dp[n][0], dp[n][1]);
    return 0;
}