单调队列优化DP

最新推荐文章于 2025-05-01 18:15:21 发布
最新推荐文章于 2025-05-01 18:15:21 发布
阅读量494 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37666409/article/details/79304068

DP作为一种结果一定正确的算法，在推出了正确方程的情况下，最难解决的就是效率问题。

先来看一道题：洛谷P1725琪露诺

对于这道题，我们可以很轻松的得出下面这段代码：

for(int i = L; i <= n; i++)
        for(int j = max(0, i - R); j <= i - L; j++)
            f[i] = max(f[j] + a[i], f[i]);

这个方程很好推，但是效率为O(n * (R - L - 1))，看看数据范围，很明显是不够的（实测60分）

那么我们该怎么优化呢？

很明显a[i]是不变的，所以我们的方程等价于f[i] = max(f[j]) + a[i] (i - R <= j <= i - L)。

到了这一步可能有人就会说：这不是线段树优化DP吗？

其实也可以，就是效率多一个log，在这里献上我的同学神犇NSH的线段树AC码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>

using namespace std;
int L,R,a[200001],n;
int dp[200001];
int nxt[200001];
struct DP{
    int val,loc;
};
DP Max(DP x,DP y)
{
    return (x.val>y.val)?x:y;
}
struct note{
    int l,r;
    DP va;
}rt[2000001];
int num=0;
void build(int x,int L,int R)
{
    if(L==R)
    {
        rt[x].va.val=-2100000000;
        return;
    }
    
    int mid=(L+R)/2;
    
    rt[x].l=++num;
    build(num,L,mid);
    rt[x].r=++num;
    build(num,mid+1,R);
    rt[x].va=Max(rt[rt[x].r].va,rt[rt[x].l].va);
}

void Insert(int x,int L,int R,int aim,int v,int lo)
{
    if(L==R)
    {
        rt[x].va.val=v;
        rt[x].va.loc=lo;
        return;
    }
    
    int mid=(L+R)/2;
    
    if(aim<=mid)
    {
        Insert(rt[x].l,L,mid,aim,v,lo);
    }
    else
    {
        Insert(rt[x].r,mid+1,R,aim,v,lo);
    }
    
    rt[x].va=Max(rt[rt[x].l].va,rt[rt[x].r].va);
    
}

DP Query(int x,int L,int R,int al,int ar)
{
    if(R<al||ar<L)
    {
        DP tmp;tmp.val=-2100000000;
        return tmp;
    }
    if(al<=L&&R<=ar)
    {		
        return rt[x].va;
    }
    
    int mid=(L+R)/2;
    return Max(Query(rt[x].l,L,mid,al,ar),Query(rt[x].r,mid+1,R,al,ar));
}
int main()
{
    scanf("%d%d%d",&n,&L,&R);
    
    for(int i=0;i<=n;i++)
    {
        scanf("%d",a+i);
    }
    memset(dp,-127,sizeof(dp));
    num++;
    build(1,0,n);
    
    dp[n]=a[n];
    Insert(1,0,n,n,dp[n],n);
    
    for(int i=n-1;i>=0;i--)
    {
        DP temp;
        if(i+R>n)
        {
            if(dp[i]<a[i])
            {
                dp[i]=a[i];
            }
            if(i+L<=n)
            {
                temp=Query(1,0,n,i+L,n);
                if(dp[temp.loc]+a[i]>dp[i])
                {
                    dp[i]=dp[temp.loc]+a[i];
                    nxt[i]=temp.loc;
                }
            }
            
            
        }
        if(i+R<=n)
        {
            temp=Query(1,0,n,i+L,i+R);
            if(dp[temp.loc]+a[i]>dp[i])
            {
                dp[i]=dp[temp.loc]+a[i];
                nxt[i]=temp.loc;
            }
        }
        
        
        Insert(1,0,n,i,dp[i],i);
        //cout<<dp[i]<<endl;
    }
    printf("%d\n",dp[0]);
    return 0;
}

但是这份码在洛谷上跑了544ms，有没有什么更快的方法呢？

单调队列！

很明显这道题的维护目标是单调的，而且是单变量的（j）

那么考虑维护一个队列，其中队列头部的元素是最大的，我们需要的最优解也就是队头元素了

但是这样有几个问题：如何维护单调性？如何维护合法性？

考虑单调性，我们的初始代码为什么慢？因为有很多没有必要的比较，如果a>b，在之后的过程中我们只需要让新来的c和a比较，因为我们只取较大的那个，但是你的程序会让c和b再比一次，这就是无意义的比较。而我们可以将一个新的元素插在队尾，在插入之前先把队尾比它小的元素删除，那么整个队列就维持了单调性，免除了无意义的比较。

再考虑合法性，在这个问题中，所谓的合法性就是指的可供转移的状态必须在i - R ~ i - L之间，我们注意到队列中的元素最初都是从队尾插入的，所以这个队列不仅满足所维护的值单调，也满足时间单调性，所以队头元素不仅是最优的，也是最老的（雾），那么在更新之前，我们检查一下队头元素是否有“过期”，是就删除，否则这就是你要的最大值。

献上本人丑陋的代码(40ms)：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;
const int MAXN = 300040;
typedef int Array[MAXN];
Array a, f, p, p2;
int n, L, R, ans, pos, cnt;
inline int read()
{
    int ch; int x = 0; int f = 1; ch = getchar();
    while(ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
    ch == '-' ? f = -1 : x = ch - '0', ch = getchar();
    while(ch >= '0' && ch <= '9')
        {x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
namespace DP {
    Array Q;int h, t;
    void init() {
        h = 0; t = 1;
        memset(Q, 0, sizeof(Q));
    }
    void dp() {
        for(int i = L; i <= n; i++) {
            while(h <= t && f[Q[t]] <= f[i - L]) t--;//删除比它小的 
            Q[++t] = i - L;//插入（顺带维护了j <= i - L） 
            while(h <= t && Q[h] < i - R) h++;//销毁过期产品 
            f[i] = f[Q[h]] + a[i];//更新 
        }
        for(int i = n - R + 1; i <= n; i++) 
            if(ans < f[i]) 
                ans = f[i], pos = i;
        printf("%d\n", ans);
    }
}
signed main() {
    n = read(), L = read(), R = read();
    for(int i = 0; i <= n; i++) a[i] = read();
    for(int i = 0; i < L; i++) f[i] = 0;
    DP::init();
    DP::dp();
    return 0;
}

再来一题：洛谷P2627修剪草坪，或bzoj2442（同一题）

这道题同样有一个比较好推的方程，不能出现连续的k个，也就等同于每k个都必须有一个断点，所以一个枚举断点的DP方程就和明显了，不取断点j，从j-1继承，然后加上a[j + 1]到a[i]：f[i] = max(f[i], f[j] + sum[i] - sum[j]);其中sum数组为前缀和数组

先献上一份70分（LG）的代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#define LL long long
using namespace std;
int n, k;
const int MAXN = 100100;
inline int read()
{
    int ch; int x = 0; int f = 1; ch = getchar();
    while(ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
    ch == '-' ? f = -1 : x = ch - '0', ch = getchar();
    while(ch >= '0' && ch <= '9')
        {x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
typedef long long Array[MAXN];
Array f, sum;
signed main() {
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (LL) read();
    for(int i = 1; i <= n; i++)
        for(int j = max(i - k, 0); j <= i; j++)
            f[i] = max(f[i], f[j - 1] - sum[j] + sum[i]);
    printf("%lld\n", f[n]);
    return 0;
}

然后同样的，sum[i]是不变的，所以可以将sum[i]提出来，那么我们需要维护的就是f[j - 1] - sum[j]，单调队列的维护同上题：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
#define LL long long
using namespace std;
int n, k;
const int MAXN = 100100;
inline int read()
{
    int ch; int x = 0; int f = 1; ch = getchar();
    while(ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
    ch == '-' ? f = -1 : x = ch - '0', ch = getchar();
    while(ch >= '0' && ch <= '9')
		{x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
typedef long long Array[MAXN];
Array f, sum;
namespace DP {
	Array Q; int h, t;
	void init() {
		h = 0; t = 1;
	}
	bool check(int x, int y) {
		return f[x - 1] - sum[x] < f[y - 1] - sum[y];
	}
	void dp() {
		for(int i = 1; i <= n; i++) {
			while(h <= t && Q[h] < i - k) h++;
			int j = (int) Q[h];
			f[i] = f[j - 1] - sum[j] + sum[i];
			while(h <= t && check((int)Q[t], i)) t--;
			Q[++t] = (LL)i;
		}
		printf("%lld\n", f[n]);
	}
}
signed main() {
	scanf("%d%d", &n, &k);
	for(int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (LL) read();
	DP::init();
	DP::dp();
	return 0;
}

单调队列同样可以用在斜率优化上

留坑，Thanks for your watching



动态规划——单调队列优化DP
m0_70897036的博客
01-16 1012
本题是一个二维单调队列问题，先对每一行求出以i位置结尾的长度不大于n的窗口的最大值与最小值，存放在数组row_max和row_min里面，再对于纵向求一遍，遍历row_max和row_min的每一列，便可以得到每一个正方形的最大值与最小值，做差即可。对于顺时针，维护一个前缀和数组s,s[i]表示从1位置出发到i+1位置时的剩余油量。集合：对于前i个烽火台，第i个烽火台被点燃的所有方案。集合：以i为右端点，长度不超过m的连续子序列的和。集合：对于前i道题，做了第i道题的所有方案。
Codeforces Round 933 (Div. 3)（F-G)(单调队列优化DP、二分+思维、01bfs求最短路）
m0_74911187的博客
03-12 901
我们可以为每个颜色建立一个虚拟节点，对于这个颜色连接的所有点，都连一条指向虚拟节点边权为1的有向边，然后从这个虚拟节点向这个颜色的所有点都连一条边权为0的所有边，这样就可以表示在一条地铁线上走不需要花费费用，因为边权只有0和1，我们就可以用01bfs，即双端队列bfs求最短路，就可以得到从起点到终点的最短路了。：这道题很明显的用单调队列优化dp，跟滑动窗口一样，用单调队列优化dp求出每一行建桥的代价后，再对列求一遍前缀和，找出最小子段和即可。,对于支架的要求是，在桥的两端必须要建支架，即。
单调队列优化dp小结
最新发布
2301_81913843的博客
05-01 1022
拿手拆一拆易得：f[i][j]=c[i]*j+min(f[i-1][k]+(x[i]-x[i-1])*k*k-c[i]*k)(max(0,j-c[i])<=k<=j)这题和单调队列毫无关系，设f[i][j]表示后两步为i,j的最大值，转移枚举j，再枚举k，用minn=max(f[i][j])转移一下即可，可以用上一个k的延续过来。拿脚推易得：f[i][j]=min(f[i-1][k]+(x[i]-x[i-1])*k*k+c[i]*(j-k))(max(0,j-c[i])<=k<=j)
单调队列优化dp
m0_74176921的博客
11-28 549
如上图，可以跳到 3−7 这个区间，跳到 3 和 4 的时候，都是消耗劳累度的，但是我们选择哪个更好呢，当然是越大的越好，因为高度越高，下一次越有利，如上图，当我们跳到 4 ，下一次跳到 3 的时候就不增加劳累度。如果暴力枚举那个区间，一般会超时，于是我们可以选择将最大值放入队头的最大值或者最小值，通过这样维护我们可以减去暴力枚举的过程，优化了时间复杂度。维护这样一个队列的好处是，当我们想求最大值的时候，我们只需要保证队列是单调递增的，于是每次取出队头就是我们的最大值。第一个元素下标进队列，此时队列为。
单调队列优化 DP
qq_56326461的博客
11-06 600
的状态转移方程，标清楚 决策 的上下界，然后依据 转移 的性质用 单调队列维护 决策集合 ，进而优化复杂度。，而 决策集合 是从左向右滑动的，这样会不会导致某些后面的有效决策被排除？那么基于 减少无用决策出发：当本层的高度最大时，只保留 最小的 长度即可。位置的决策 排除了在它后面的部分元素，现在它出队了，谁有能是最优呢？整体上看，转移时需要维护到两个信息：当前层的长度，上一层的长度。时，首先让部分决策出队，并从 set 中删除，不需要更改。这是第一步的转移，去除了有空板 / 空人的影响。
单调队列
编程资料大全
04-03 245
一、 什么是单调（双端）队列 单调队列，顾名思义，就是一个元素单调的队列，那么就能保证队首的元素是最小（最大）的，从而满足动态规划的最优性问题的需求。 单调队列，又名双端队列。双端队列，就是说它不同于一般的队列只能在队首删除、队尾插入，它能够在队首、队尾同时进行删除。 【单调队列的性质】 一般，在动态规划的过程中，单调队列中每个元素一般存储的是两个值： 1、在原数列中的位置（下标） 2...
DP的单调队列优化-Yuiffy.pdf
06-09
#### 四、单调队列优化DP的应用 在动态规划问题中，单调队列可以用来优化时间复杂度。例如，在HOJ2941问题中，我们需要将一个数组划分成多个部分，每个部分的长度介于m和n之间，求出所有划分方案中最大的加和。 **...
单调队列优化DP动态规划（1）
weixin_43908980的博客
12-23 729
目录 一.前言 二.例题1：单调队列本身的灵活应用——测量温度 1.题目 题目描述 输入 输出 输入样例 输出样例 2.思路 三.例题2：单调队列优化DP：猴子 1.题目 题目描述 输入 输出 输入样例   输出样例 2.思路  四.总结 一.前言 学好了单调队列不仅可以单独使用，他还可以有更多的广泛用途。这里我主要讲其对动态规划的优化，较简单。 二.例题...
单调队列优化DP——最大子序列和
行走天涯的豆沙包的博客
01-14 447
前言： 单调队列可以优化什么呢？我们发现单调队列是处理滑动窗口中的最值问题的。（一个固定长度的滑动窗口）。 输入一个长度为n的整数序列，从中找出一段长度不超过m的连续子序列，使得子序列中所有数的和最大。 注意： 子序列的长度至少是1。 输入格式 第一行输入两个整数n,m。 第二行输入n个数，代表长度为n的整数序列。 同一行数之间用空格隔开。 输出格式 输出一个整数，代表该序列的最大子序和。 数据范...
单调队列优化dp：
_Griefs
08-24 375
用数组模拟队列速度会更快一点。 一、Fence POJ - 1821: A team of k (1 <= K <= 100) workers should paint a fence which contains N (1 <= N <= 16 000) planks numbered from 1 to N from left to right. Each worker...
单调队列/单调栈优化dp
qq_33969563的博客
11-03 1314
单调队列/单调栈优化dp
【NOI2005】瑰丽华尔兹 - DP
weixin_30727835的博客
03-27 168
题目描述 你跳过华尔兹吗？当音乐响起，当你随着旋律滑动舞步，是不是有一种漫步仙境的惬意？ 众所周知，跳华尔兹时，最重要的是有好的音乐。但是很少有几个人知道，世界上最伟大的钢琴家一生都漂泊在大海上，他的名字叫丹尼·布德曼·T.D.·柠檬·1900，朋友们都叫他1900。 1900 在20 世纪的第一年出生在往返于欧美的邮轮弗吉尼亚号上。很不幸，他刚出生就被抛弃，成了孤儿。1900 孤...
单调队列优化DP的好题
05-14
单调队列优化DP是一种常用的优化方法，可以将时间复杂度从 $O(n^2)$ 降低到 $O(n)$ 或者 $O(n \log n)$。以下是一道利用单调队列优化DP的典型题目： 题目描述： 给定一个长度为 $n$ 的序列 $a_i$，定义 $f(i)$ 为 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值