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

单调队列优化DP详解

最新推荐文章于 2025-04-17 18:59:16 发布

原创最新推荐文章于 2025-04-17 18:59:16 发布 · 363 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #动态规划

数据结构专栏收录该内容

10 篇文章

订阅专栏

本文介绍了单调队列原理及其在滑动窗口问题中的应用，包括区间最大值和最小值的求解，并通过实例展示了如何利用单调队列优化动态规划算法，减少时间复杂度。

单调队列

原理
例题
优化DP

原理

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

这里只用语言简单描述一下，具体画图可以参考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

用 $d p [i] [0 / 1]$ 表示第 $i$ 个物品选或者不选所能达到的数字之和的最大值， $s u m [i]$ 表示前缀和，因为不能有超过 $k$ 个连续的数字被选择，所以转移方程显然为 $\left\{ \begin{aligned} 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\leq j\leq i \end{aligned} \right.$
但这样第二行的时间复杂度是 $O(n^2)$ ，考虑优化，因为 $i-k\leq j\leq i$ ，我们只需要找到使得 $d p [j] [0] - s u m [j]$ 最大的情况即可，使用单调队列维护它的最大值，使之处于队首，队列内部元素的 $d p [j] [0] - s u m [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;
}