BZOJ P1233 干草堆tower 【单调队列优化DP】

最新推荐文章于 2025-06-05 14:06:28 发布

「已注销」

最新推荐文章于 2025-06-05 14:06:28 发布

阅读量440

点赞数 2

CC 4.0 BY-SA版权

分类专栏： OI/ACM之动态规划与递推 OI/ACM之数据结构

本文链接：https://blog.csdn.net/yanzhenhuai/article/details/80518379

OI/ACM之动态规划与递推同时被 2 个专栏收录

122 篇文章

订阅专栏

OI/ACM之数据结构

73 篇文章

订阅专栏

本文介绍了一种使用单调队列优化动态规划(DP)的方法，以解决特定类型的最短路径问题。通过分析状态转移方程，推导出了优化条件，并给出了实现代码，有效地将时间复杂度从O(n^2)降低到更优级别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目分析：

我们用 $F [I]$ 表示用第 $I N$ 包做草堆的时候最底下一层的最短长度， $G [I]$ 记录此时能到达的最高高度，显然可以得到如下的一个状态转移方程：
$i f (J > I, F [J] < = S u m [J - 1] - S u m [I - 1])$
$F [I] = m i n (S u m [J - 1] - S u m [I - 1]), G [I] = G [J] + 1$
由于这样的做法时间复杂度是 $n^2$ ，所以我们考虑优化 $D P$ 。我们注意到 $F [I]$ 的值总是只与 $S u m [J - 1] - S u m [I - 1]$ 的大小有关，也就是我们只需要考虑能够更新答案，能够发生状态转移的话那么必须满足下面的式子：
$F[J]≤Sum[J−1]−Sum[I−1]F[J]\leq Sum[J-1]-Sum[I-1]$
$Sum[i−1]≤Sum[J−1]−F[J]Sum[i-1]\leq Sum[J-1]-F[J]$
通过这个式子我们可以发现如果能够更新答案我们一定要满足式子右边尽量小，也就是说，如果存在以下的式子，那么一定不能够更新答案：
$\geq Sum[J-1]-F[J]$
分析到这里，一个单调队列优化 $D P$ 的模型也就涌现出来了，下面给出参考代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define DB double
#define SG string
#define LL long long
#define Fp(A,B,C,D) for(A=B;A<=C;A+=D)
#define Fm(A,B,C,D) for(A=B;A>=C;A-=D)
#define Clear(A) memset(A,0,sizeof(A))
#define Copy(A,B) memcpy(A,B,sizeof(A))
using namespace std;
const LL Max=1e5+5;
const LL Mod=1e9+7;
const LL Inf=1e18;
LL N,F[Max],G[Max],Q[Max],Sum[Max];
inline LL Read(){
	LL X=0;char CH=getchar();bool F=0;
	while(CH>'9'||CH<'0'){if(CH=='-')F=1;CH=getchar();}
	while(CH>='0'&&CH<='9'){X=(X<<1)+(X<<3)+CH-'0';CH=getchar();}
	return F?-X:X;
}
inline void Write(LL X){
	if(X<0)X=-X,putchar('-');
	if(X>9)Write(X/10);
	putchar(X%10+48);
}
int main(){
	LL I,J,K;
	N=Read();
	Fp(I,1,N,1){
		Sum[I]=Sum[I-1]+Read();
	}LL Head=1,Tail=1;
	Q[1]=N+1;
	Fm(I,N,1,1){
		while(Head<Tail&&Sum[Q[Head+1]-1]-Sum[I-1]>=F[Q[Head+1]]){
			++Head;
		}F[I]=Sum[Q[Head]-1]-Sum[I-1];G[I]=G[Q[Head]]+1;
		while(Head<=Tail&&Sum[Q[Tail]-1]-F[Q[Tail]]<=Sum[I-1]-F[I]){
			--Tail;
		}Q[++Tail]=I;
	}Write(G[1]);
	return 0;
}