单调队列优化动态规划

前置知识：单调队列

1.1例题

例题1：琪露诺
常见思路：首先容易推出朴素转移方程：
令 $f_i$ 表示琪露诺在在 $i$ 格时累计能获得多少冰冻指数，$f_i=a_i+\underset{i-r\le j\le i-l}{min}{f}_j$，时间复杂度为 $O(n^2)$，考虑优化。
容易发现 $f_j$ 中 $j$ 的限制就像是一个滑动窗口，所以可以用单调队列优化。

操作：①令 $h=1$，$t=0$
②遍历到一个新的 $i$。
③先更新队尾：将在新元素（指能转移到当前 $f_i$ 的元素却无法转移到 $f_{i-1}$ 的元素）前面且不比它优的元素从队尾出队，再加入新元素。
④再更新队头：如果队头超出长度限制，从队头出队。
⑤这时已经保证了单调队列中有 $i-r\le j\le i-l$ 的所有 有可能有用的 $j$（即有可能转移到后面的 $j$）都在队列里且有单调性，此时队头为最优转移的位置，用队头更新 $f_i$ 即可。
时间复杂度：$O(n)$ 。

点击查看代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,l,r,f[200010],a[200010],q[200010],ans=-0x7fffffff;
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>l>>r;
	for(int i=0;i<=n;i++)cin>>a[i];
	for(int i=1;i<=n;i++)f[i]=-0x7fffffff;
	for(int i=l,h=1,t=0;i<=n;i++){
		while(f[q[t]]<=f[i-l]&&h<=t)t--;
		q[++t]=i-l;
		while(q[h]+r<i)h++;
		f[i]=f[q[h]]+a[i];
		if(i+r>n)ans=max(ans,f[i]);
	}
	cout<<ans<<'\n';
	return 0;
}

例题2：[NOIP2017 普及组] 跳房子
由于题目要求满足某个条件至少要花多少金币，而且容易发现 $x$ 个金币可以做到的事 $x+1$ 个金币也可以，所以考虑用二分解决。
如何判断花了 $g$ 枚金币能否获得至少 $k$ 分？求出花了 $g$ 枚金币最多能获得多少分即可。
考虑用动态规划，可以令 $f_i$ 表示小 $R$ 在第 $i$ 格时累计能获得多少分数，得到转移方程：$f_i=s_i+\underset{x_i-g-d\le x_j\le min(x_i-1,x_i+g-d)}{max}{f}_j$。
动态规划的时间复杂度为 $O(n^2)$，考虑优化。
操作：①令 $h=1$，$t=0$。
②遍历到一个新的 $i$。
③先更新队尾：将在新元素（指能转移到当前 $f_i$ 的元素却无法转移到 $f_{i-1}$ 的元素）前面且不比它优的元素从队尾出队，再加入新元素。但是注意这里的新元素可能不止 $1$ 个，所以要while套while，将所有新元素判断并入队。
④再更新队头：如果队头超出长度限制，从队头出队。
⑤这时已经保证了单调队列中有 $x_i-g-d\le x_j\le min(x_i-1,x_i+g-d)$ 的所有有可能有用的 $j$（即有可能转移到后面的 $j$）都在队列里且有单调性，此时队头为最优转移的位置，用队头更新 $f_i$ 即可。
动态规划的时间复杂度：$O(n)$，可以通过此题。

点击查看代码

#include<bits/stdc++.h>
using namespace std; 
typedef long long ll;
ll l=0,r=0,s=0,n,d,k,f[500010],q[500010],a[500010],x[500010],ans=0;
bool ch(ll p){
	memset(f,-0x3f3f3f3f3f3f3f3f,sizeof(f));
	memset(q,0,sizeof(q));
	f[0]=0;
	ll res=-0x3f3f3f3f3f3f3f3f;
	for(ll i=1,j=0,h=1,t=0;i<=n;i++){
		while(j<i&&x[i]-x[j]>=d-p){
			while(h<=t&&f[q[t]]<=f[j])t--;
			q[++t]=j++;
		}
		while(h<=t&&x[i]-x[q[h]]>d+p)h++;
		if(h<=t)f[i]=f[q[h]]+a[i];
		res=max(res,f[i]);
	}
	return res>=k;
}
int main(){
	cin>>n>>d>>k;
	for(ll i=1;i<=n;i++){
		cin>>x[i]>>a[i];
		if(a[i]>0)s+=a[i];
		r=max(r,x[i]);
	}
	if(s<k){cout<<-1<<'\n';return 0;}
	while(l<=r){
		ll mid=(l+r)>>1;
		if(ch(mid))ans=mid,r=mid-1;
		else l=mid+1;
	}
	cout<<ans<<'\n';
	return 0;
}

例题3：P6040
这一题有些复杂，但是看完题后还是可以列出转移方程：令 $f_i$ 表示在辅导第 $i$ 个同学时在前 $i$ 个同学身上花费的最小精力，则枚举上一个辅导的同学 $j$ ，表示 $f_i=a_i+\underset{i-x\le j<i}{min}fj+(i-j-1)\times d+k$。
这里好像让人无从下手，但是我们充分发扬乱搞推式子精神，拆开发现式子等同于 $f_i=k+a_i+(i-1)\times d+\underset{i-x\le j<i}{min}{f}_j-j\times d$。那我们可以把 $f_j-j\times d$ 作为一个整体，让单调队列维护的是 $f_j-j\times d$ 单调递减的 $j$ 即可。
注意，这里之所以先h++是因为在所有操作开始前已经将 $1$ 塞进了队列里。

点击查看代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
inline int read(){
	int x=0,flag=1;char c;
	while((c=getchar())<'0'||c>'9')if(c=='-')flag=0;
	while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return flag?x:-x;
}
ll n,k,d,x,tp,Seed,h=1,t=0,q[10000010],f[10000010];
inline int rnd(){
	static const int MOD = 1e9;
	return Seed = ( 1LL * Seed * 0x66CCFF % MOD + 20120712 ) % MOD;
}
int main(){
	n=read();k=read();d=read();x=read();tp=read();
	if(tp){
		Seed=read();
		f[1]=rnd();q[++t]=1;
		for(ll i=2;i<=n;i++){
			ll qwq=rnd();
			while(h<=t&&q[h]<i-x)h++;
			f[i]=f[q[h]]+k+(i-q[h]-1)*d+qwq;
			while(h<=t&&f[q[t]]-q[t]*d>=f[i]-i*d)t--;
			q[++t]=i;
		}
		cout<<f[n]<<'\n';
	}else{
		f[1]=read();q[++t]=1;
		for(ll i=2;i<=n;i++){
			ll qwq=read();
			while(h<=t&&q[h]<i-x)h++;
			f[i]=f[q[h]]+k+(i-q[h]-1)*d+qwq;
			while(h<=t&&f[q[t]]-q[t]*d>=f[i]-i*d)t--;
			q[++t]=i;
		}
		cout<<f[n]<<'\n';
	}
	return 0;
}

总结：单调队列优化动态规划适用于式子可以化为 $f_i=q(i)+\underset{l(i)\le j\le r(i)}{max}{f}_j+p(j)$ ，并且满足 $l(i)$ 和 $r(i)$ 都单不减的 $1D/1D$ 型动态规划。
有三个步骤：入队、出队、转移。

1.2 习题

咕咕咕