【刷题笔记】DP优化-斜率优化

斜率优化，是一种利用斜率的优化（废话）

关于数论：咕咕咕

部分内容参考自学长

如果有这样的一个状态转移方程：

\[f[i]=\min\limits_{j=L_j}^{R_j}\{f[j]+val(j,i)\}
\]

如果\(val(j,i)=A(i)+B(j)\)可以用单调队列解决

当\(val(j,i)=(A(i)+B(j))^2\)时，就可以考虑斜率优化。

关键词：斜率，凸包，单调队列

特别行动队

看到这题，暴力\(DP\)应该比较好想：

\[f[i]=\max\limits^{i-1}_{j=0}\{f[j]+A\cdot(sum[i]-sum[j])^2+B\cdot(sum[i]-sum[j])+C\}
\]

看见平方，把他展开：

\[f[i]=\max\limits^{i-1}_{j=0}\{f[j]+A\cdot(sum[i]^2+sum[j]^2-2sum[i]\cdot sum[j])+B\cdot(sum[i]-sum[j])+C\}
\]

\[f[i]=\max\limits^{i-1}_{j=0}\{f[j]+A\cdot sum[i]^2+A\cdot sum[j]^2-2A\cdot sum[i]\cdot sum[j]+B\cdot sum[i]-B\cdot sum[j]+C\}
\]

一定的项就可以提出去

\[f[i]=\max\limits^{i-1}_{j=0}\{f[j]+A\cdot sum[j]^2-2A\cdot sum[i]\cdot sum[j]-B\cdot sum[j]\}+A\cdot sum[i]^2+B\cdot sum[i]+C
\]

所以，我们考虑\(val_j=f[j]+A\cdot sum[j]^2-2A\cdot sum[i]\cdot sum[j]-B\cdot sum[j]\)这一部分的取值

设当前想要转移到的状态为\(i\)，\(j,k\)是之前的两个转移点

那么当\(j<k\)，且\(val_j\leq val_k\)时，\(j\)劣于\(k\)。

写出来就是

\[f[j]+A\cdot sum[j]^2-2A\cdot sum[i]\cdot sum[j]-B\cdot sum[j]\leq f[k]+A\cdot sum[k]^2-2A\cdot sum[i]\cdot sum[k]-B\cdot sum[k]
\]

\[f[j]+A\cdot sum[j]^2-B\cdot sum[j]-f[k]-A\cdot sum[k]^2+B\cdot sum[k]\leq 2A\cdot sum[i]\cdot sum[j]-2A\cdot sum[i]\cdot sum[k]
\]

\[f[j]-f[k]+A\cdot(sum[j]^2-sum[k]^2)+B\cdot(sum[k]-sum[j])\leq 2Asum[i]\cdot(sum[j]-sum[k])
\]

\[\frac{f[j]-f[k]+A\cdot(sum[j]^2-sum[k]^2)+B\cdot(sum[k]-sum[j])}{sum[j]-sum[k]}\geq 2Asum[i]
\]

（注意最后有个变号）

令\(g[t]=f[t]+A\cdot sum[t]^2-B\cdot sum[t]\)，原式就会变成：

\[\frac{g[j]-g[k]}{sum[j]-sum[k]}\geq 2Asum[i]
\]

好——舒——服——啊——这就直接上斜率优化了

Latex打得我要死了

看题，发现\(A<0\)，而\(sum\)是递增的，所以如果一个\(sum[i]\)满足条件，之后的所有\(sum[i]\)也都满足条件，也就是说对于之后的所有转移，都有\(j\)劣于\(k\)。

冷静分析，发现是个上凸包，因为根据推出来的式子弹队头，斜率大于等于当前的都会被弹掉

然后同样的道理来弹队尾！

（最后一步的分析第一次做斜率优化想了半个小时……不过想过去是真的豁然开朗）

磕磕绊绊弄出来的混乱程序

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ZZ_zuozhe int main()
#define Arknights return 0
using namespace std;
#define MAXN 1000005

ll q[MAXN];
db f[MAXN],k[MAXN],sum[MAXN],y[MAXN];

ZZ_zuozhe
{
	ll n;
	scanf("%lld",&n);
	db a,b,c,nowk;
	scanf("%lf%lf%lf",&a,&b,&c);
	for(int i=1;i<=n;i++)
	{
		scanf("%lf",&sum[i]);
		sum[i]+=sum[i-1];
	}
	ll h=1,t=1,j;
	for(int i=1;i<=n;i++)
	{
		nowk=2*a*sum[i];
		while(h<t&&k[h]>=nowk)h++;
		f[i]=y[q[h]]-nowk*sum[q[h]]+(a*sum[i]+b)*sum[i]+c;
		y[i]=f[i]+(a*sum[i]-b)*sum[i];
		while(h<t&&k[t-1]<=(y[q[t]]-y[i])/(sum[q[t]]-sum[i]))--t;
		k[t]=(y[q[t]]-y[i])/(sum[q[t]]-sum[i]);
		q[++t]=i;
	}
	printf("%.0lf\n",f[n]);
	Arknights;
}

我的娘啊太短了吧……其实还可以再压行

有一点需要注意的是因为单调队列里存了线段斜率，这是代表两个点的，所以这里只能用\(f<t\)配\(f=t=1\)，我原来写的单调队列这里会挂……

玩具装箱

先打暴力：

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+(sum[i]-sum[j]+i-j-1-L)^2\}
\]

按照我们的一贯作风，这个时候应该化简了

这一大坨平方摆在这里化个麦乐鸡腿堡啊！

不急不急，咱们换个元，把含\(i,j\)的项合在一起，令\(g[t]=sum[t]+t\)，这里就有

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+(g[i]-g[j]-1-L)^2\}
\]

然后因为\(g[i]\)是可求的，直接把他提出来就好

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+g[i]^2+(g[j]+1+L)^2-2\cdot g[i]\cdot (g[j]+1+L)\}
\]

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+(g[j]+1+L)^2-2\cdot g[i]\cdot (g[j]+1+L)\}+g[i]^2
\]

接下来，考虑\(f[j]+(g[j]+1+L)^2-2\cdot g[i]\cdot (g[j]+1+L)\)这一部分

设当前要转移到\(i\)，之前有两个状态\(j,k\)

则当\(j<k\)，且\(val_j \geq val_k\)时，\(j\)劣于\(k\)。

列出式子：

\[f[j]+(g[j]+1+L)^2-2\cdot g[i]\cdot (g[j]+1+L)\geq f[k]+(g[k]+1+L)^2-2\cdot g[i]\cdot (g[k]+1+L)
\]

然后就是欢乐化简环节，这里就直接给结果了\(qwq\)

\[\frac{f[j]-f[k]+(g[j]+L+1)^2-(g[k]+L+1)^2}{g[j]-g[k]}\leq 2\cdot g[i]
\]

（注意变号）

令\(h[t]=f[t]+(g[t]+L+1)^2\)，则有

\[\frac{h[j]-h[k]}{g[j]-g[k]}\leq 2\cdot g[i]
\]

一般形式出来了，代码就好写了~

右面单调递增，和上一题恰恰相反，单调队列下凸包，代码仍然极短>.<

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ZZ_zuozhe int main()
#define Arknights return 0
using namespace std;
#define MAXN 50005

ll q[MAXN];
db f[MAXN],g[MAXN],h[MAXN],sum[MAXN],L,k[MAXN];
db nowk;
ll n;

inline db slope(ll j,ll k){return (h[j]-h[k])/(g[j]-g[k]);}

ZZ_zuozhe
{
	scanf("%lld%lf",&n,&L);
	h[0]=(L+1)*(L+1);
	for(int i=1;i<=n;i++)
	{
		scanf("%lf",&sum[i]);
		sum[i]+=sum[i-1];
		g[i]=sum[i]+i;
	}
	ll he=1,t=1;
	for(int i=1;i<=n;i++)
	{
		nowk=2*g[i];
		while(he<t&&k[he]<=nowk)he++;
		f[i]=f[q[he]]+(g[i]-g[q[he]]-1-L)*(g[i]-g[q[he]]-1-L);
		h[i]=f[i]+(g[i]+L+1)*(g[i]+L+1);
		while(he<t&&k[t-1]>=slope(q[t],i))t--;
		k[t]=slope(q[t],i);
		q[++t]=i;
	}
	printf("%.0lf",f[n]);
	Arknights;
}

仓库建设

上暴力！

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+C[i]+(\sum\limits_{k=j+1}^{i}P[k]\cdot(X[i]-X[k]))\}
\]

还要求和好麻烦啊……那就化简一下

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+C[i]+\sum\limits_{k=j+1}^{i}P[k]\cdot X[i]-\sum\limits_{k=j+1}^{i}P[k]\cdot X[k]\}
\]

这个求和就可以前缀和优化了呢……

设\(sP[t]=\sum\limits_{i=1}^{t}P[i]\)，\(sPX[t]=\sum\limits_{i=1}^{t}P[i]\cdot X[i]\)，就可以得到：

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+C[i]+X[i]\cdot (sP[i]-sP[j])-(sPX[i]-sPX[j])\}
\]

怎么越来越乱了，走了走了打暴力去

且慢！你似乎忘了把只含\(i\)的式子提出来……

于是：

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]-X[i]\cdot sP[j]+sPX[j]\}+C[i]+X[i]\cdot sP[i]-sPX[i]
\]

咱就只用考虑\(f[j]-X[i]\cdot sP[j]+sPX[j]\)这一块

设当前要转移到\(i\)，之前有两个状态\(j,k\)（套路出来了

则当\(j<k\)，且\(val_j \geq val_k\)时，\(j\)劣于\(k\)。

代入就是

\[f[j]-X[i]\cdot sP[j]+sPX[j]\geq f[k]-X[i]\cdot sP[k]+sPX[k]
\]

\[f[j]-f[k]+sPX[j]-sPX[k]\geq X[i]\cdot (sP[j]-sP[k])
\]

\[\frac{f[j]-f[k]+sPX[j]-sPX[k]}{sP[j]-sP[k]}\leq X[i]
\]

令\(g[t]=f[t]+sPX[t]\)，强行搞出一般形式：

\[\frac{g[j]-g[k]}{sP[j]-sP[k]}\leq X[i]
\]

舒服了，上兵器，和上一题类似，单调队列下凸包。

这题数据很大时\(double\)似乎精度堪忧……换了\(long long\)就没事了，不过记得把所有不等号的等于都去掉……

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ZZ_zuozhe int main()
#define Arknights return 0
using namespace std;
#define MAXN 1000005

ll n;
ll q[MAXN];
ll p[MAXN],x[MAXN],c[MAXN],sp[MAXN],spx[MAXN],f[MAXN],nowk,k[MAXN],g[MAXN];

inline db slope(ll j,ll k){return 1.0*(g[j]-g[k])/(sp[j]-sp[k]);}

ZZ_zuozhe
{
	scanf("%lld",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld%lld%lld",&x[i],&p[i],&c[i]);
		sp[i]=sp[i-1]+p[i];
		spx[i]=spx[i-1]+p[i]*x[i];
	}
	ll h=1,t=1;
	for(int i=1;i<=n;i++)
	{
		nowk=x[i];
		while(h<t&&k[h]<nowk)h++;
		f[i]=f[q[h]]-x[i]*sp[q[h]]+spx[q[h]]+c[i]+x[i]*sp[i]-spx[i];
		g[i]=f[i]+spx[i];
		while(h<t&&k[t-1]>slope(q[t],i))t--;
		k[t]=slope(q[t],i);
		q[++t]=i;
	}
	printf("%lld",f[n]);
	Arknights;
}

土地购买

发现每次买地是按最大长和最大宽的乘积计费的，所以如果某块土地的长和宽都小于另外某块土地的，这块土地实际上就不会对答案产生贡献了

然后就可以写dp：（记得考虑已知性质

\[f[i]=\min\limits_{j=1}^{i-1}\{f[j]+w[j+1]*l[i]\}
\]

通过排序使\(l\)单调递增，\(w\)单调递减，就可以上斜率优化了

设当前要转移到\(i\)，之前有两个状态\(j,k\)（我又开始复读了

则当\(j<k\)，且\(val_j \geq val_k\)时，\(j\)劣于\(k\)。

代入：

\[f[j]+w[j+1]*l[i]\geq f[k]+w[k+1]*l[i]
\]

\[\frac{f[j]-f[k]}{w[k+1]-w[j+1]}\leq l[i]
\]

莫名很好化……

右面单调递增，单调队列维护个下凸包即可

讲个笑话，我输出\(f[n]\)，\(Wa\) \(10\)调了半上午：）

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ZZ_zuozhe int main()
#define Arknights return 0
#define MAXN 50005
using namespace std;

struct land
{
	ll w,l;
}a[MAXN],b[MAXN];
ll cnt=0;

inline bool cmp(land a,land b){return (a.l!=b.l?a.l<b.l:a.w<b.w);}

ll n,q[MAXN];
db f[MAXN],k[MAXN];

inline db slope(ll j,ll k){return 1.0*(f[j]-f[k])/(b[k+1].w-b[j+1].w);}

ZZ_zuozhe
{
	scanf("%lld",&n);
	for(int i=1;i<=n;i++)scanf("%lld%lld",&a[i].w,&a[i].l);
	sort(a+1,a+n+1,cmp);
	for(int i=1;i<=n;i++)
	{
		while(cnt&&(a[i].w>=b[cnt].w||a[i].l==b[cnt].l))cnt--;
		b[++cnt].w=a[i].w;
		b[cnt].l=a[i].l;
	}
	//for(int i=1;i<=cnt;i++)cout<<b[i].l<<' '<<b[i].w<<endl;
	ll h=1,t=1;
	db nowk;
	for(int i=1;i<=cnt;i++)
	{
		nowk=b[i].l;
		//cout<<"i:"<<i<<' '<<k[h]<<' '<<nowk<<endl;
		while(h<t&&k[h]<nowk)h++;
		f[i]=f[q[h]]+b[q[h]+1].w*b[i].l;
		while(h<t&&k[t-1]>slope(q[t],i))t--;
		k[t]=slope(q[t],i);
		q[++t]=i;
		//cout<<"head:"<<h<<' '<<"f["<<i<<"]="<<f[i]<<endl;
	}
	printf("%.0lf",f[cnt]);
	Arknights;
}