口胡斜率优化$DP$

关于斜率优化，我就是一个傻子啊，真的一直没弄懂……

\(T1[HNOI2018]TOY\)玩具装箱

状态和方程还是很好出来的啊：

\(f[i]=min(f[j]+(s[i]-s[j]+i-j-L-1)^2)\)其中\(s[i]\)表示前缀和，\(f[i]\)表示前\(i\)个处理后的最小值。

但是我们发现，这个东西要转移的话是个\(O(n^2)\)而\(N<=50000\)，显然转移不了。

接下来就是斜率优化的天下了！

我们要找的是在\(i\)之前的一个\(j\)使得\(f[i]\)最小，考虑怎样可以快速的找到。

令\(a[i]=s[i]+i,b[i]=s[i]+i-L-1\)。

我们将原方程变形，就可以得到这样的形式：（先不要管为啥好吧）

\(2*a[i]*b[j]+f[i]-a[i]^2=f[j]+b[j]^2\)。先明确一点，当我们在转移\(i\)时\(a[i]\)是确定的。

对应一下\(kx+b=y\)，我们令\(2*a[i]\)为\(k\)，\(b[j]\)为\(x\)，\(f[j]+b[j]^2\)为\(y\)，那么，我们所求为直线在\(y\)上的最小截距。

当我们在转移\(i\)时，前面的\(1～i-1\)可表示为一堆点（\(P_j(b[j],f[j]+b[j]^2)\)）。

转移即为，找一条过\(P_j\)的斜率为\(2*a[i]\)的直线，使得其在\(y\)轴上的截距最小。

不妨拿出三个点，其构成一个向上的凸包（如右上的图）我们发现，当我们平移直线是，\(B\)一定不为最优决策。

所以我们可以舍掉\(B\)点，即维护一个向下的凸包（如下面的图）这是我们发现，此时的\(A,B,C\)三点都有可能成为最优决策。

此时考虑用一个数据结构维护所有可以构成一个向下的凸包的点。

//回来看下之前我们说的斜率\(2*a[i]\)，显然它具有单调性（如果没有单调性就二分）

在前\(1～i-1\)中，不妨设有两个状态：\(j,k\)且\(j\)比\(k\)更优，则有：

\(f[j]+(s[i]-s[j]+i-j-L-1)^2<f[k]+(s[i]-s[k]+i-k-L-1)^2\)

经过一系列毫不人道的化简（风骨傲天很懒所以他没把将过程放上来）可以得到：

\(2*a[i]>\frac{f[j]-f[k]+b[j]^2-b[k]^2}{b[j]-b[k]}\)（好丑的式子……）

也就是说只要满足这个式子，就有\(j\)比\(k\)更优。

同样对应斜率，就有：\(P_j\)和\(P_k\)的斜率小于\(2*a[i]\)时，就有\(j\)比\(k\)更优。

又因为我们维护的是一个向下的凸包，所以我们就只用考虑相邻的两个点即可。

那么我们就可以用一个单调队列来维护，队列中相邻点间连线的斜率递增。

这张图应该说很好的反应了转移和维护的过程，上面的两张就是转移，下面的两张是维护。

转移：由图中我们可以发现，我们要求的\(j\)为斜率第一个大于\(2*a[i]\)的点，因此舍掉\(A,B\)

维护：因为单桥队列中斜率的单调性，删掉\(E\)，由转移后的\(i\)得出的点\(F(b[i],f[i]+b[i]^2)\)加入队尾。

而实际上，我们的斜率优化有一定的公式：

当方程形如：\(f[i]=min(f[j]+S(i,j))+k\)（\(k\)为常数）时，可以使用斜率优化。我们的斜率为在当次转移中的一个不变量，维护的是一堆点。不过通常用上面讲到的“假设两个状态法”来求斜率。

所以斜率优化的思考过程应该是和上面讲到的相反，先考虑斜率再变形方程并得出\(x,y\)。

啊～终于打完了，累成狗

又是快乐的代码时间：

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=50010;
int n,q[N],l,r,L;
double s[N],f[N];
inline double A(int i) {return s[i]+i;}
inline double B(int i) {return s[i]+i+L+1;}
inline double S(double x) {return x*x;}
inline double K(int i,int j) {return (f[i]-f[j]+S(B(i))-S(B(j)))/(B(i)-B(j));}
int main(){
#ifndef ONLINE_JUDGE
    freopen("A.in","r",stdin);
#endif
    n=read();L=read();l=r=1;
    for(int i=1,c;i<=n;i++) c=read(),s[i]=c*1.0+s[i-1];
    for(int i=1;i<=n;i++)
    {
        while(l<r&&2*(s[i]+i)>K(q[l],q[l+1])) l++;
        f[i]=f[q[l]]+S(A(i)-B(q[l]));
        while(l<r&&K(q[r-1],q[r])>K(i,q[r-1])) r--;
        q[++r]=i;
    }
    printf("%lld",(long long)f[n]);
}

\(T2APIO2010\)特别行动队

这一题也是一个经典的斜率优化，稍微有点不同。

状态：\(f[i]=min(f[j]+a*(s[i]-s[j])^2+b*(s[i]-s[j])+c)\)

化简：\(2*a*s[i]*s[j]+f[i]-a*s[i]^2-b*s[i]-c=f[j]+a*s[j]^2-b*s[j]\)

因为这一题的\(a<0\)，所以我们维护一个向上的凸包即可。（但是\(a<0\)时仍有单调性）

直接上代码：

#include <cstdio>
using namespace std;
#define F(x) ((x)*(x))
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=1000010;
#define int long long
int n,l,r,f[N],Q[N],a,b,c,s[N];
inline double Work(int x,int y)
{
    return 1.*(f[x]-f[y]+(F(s[x])-F(s[y]))*a)/(s[x]-s[y])-b;
}
main(){
    n=read(),a=read(),b=read(),c=read();
    for(int i=1;i<=n;i++) s[i]=read(),s[i]+=s[i-1];
    for(int i=1;i<=n;i++)
    {
        while(l<r&&Work(Q[l+1],Q[l])>s[i]*2*a) l++;
        //用于从队列中选出最值
        f[i]=f[Q[l]]+a*F(s[i]-s[Q[l]])+b*(s[i]-s[Q[l]])+c;
        while(l<r&&Work(Q[r],Q[r-1])<Work(i,Q[r])) r--;
        //维护队列单调性
        Q[++r]=i;
    }
    printf("%lld",f[n]);
}

关于不满足单调性时的特殊情况，下面来一个例题。

\(BZOJ2726\)（慎重声明，这一题和\(Luogu\)上的不一样）

数据范围：

\([1, 4] 0<N<=1000,0<=S<=2^8,0<=Ti<=2^8,0<=Fi<=2^8\)
\([5, 12] 0<N<=300000,0<=S<=2^8,0<=Ti<=2^8,0<=Fi<=2^8\)
\([13, 20] 0<N<=100000,0<=S<=2^8,-(2^8)<=Ti<=2^8,0<=Fi<=2^8\)

以下的\(F[i]\),\(T[i]\)表示相应数组的前缀和

因为我们在转移中需要前面分成的批数，所以有一个极为直接的状态：\(f[i][j]\)表示前\(i\)个，分为\(j\)组的答案。

但实际上空间上完全不行（你\(100000\)怎么开二维……）

考虑一维的状态，实际上这里用上里一个叫“费用提前计算”的思想。（先把方程写出来吧）

\(f[i]=min(f[j]+T[i]*(F[i]-F[j])+S*(F[n]-F[j]))\)

考虑这个\(S\)会对什么产生影响：显然是\(j+1～i\)的任务产生影响，因此我们将它提出来计算。

然鹅这个怎么看都不是一个好的方法。（你\(100000\)怎么跑这个……）

用斜率优化考虑转移，式子可以变形为：

\(f[j]=(S+T[i])*F[j]+f[i]-T[i]*F[i]-S*F[n]\)

设\(f[j]\)为\(y\)，\(F[j]\)为\(x\)，但我们在转移时就傻眼了，因为这一题的特殊性出题人的毒瘤性，\(T[i]\)可能为负

即我们的每次转移时那个固定的斜率不单调，我们不能将队头的点删掉！

但是至少我们的\(F[i]\)有单调性，加入的点有单调性。

这时我们可以不删除队列中的点，利用二分在队列中找最适合转移的点，再进行转移。

代码应该会感觉有些奇怪，主要是智障太懒了，直接在弱化版上魔改了……

#include<bits/stdc++.h>
using namespace std;
#define int long long
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=1000010;
int n,s,T[N],F[N],q[N],top=1,f[N];
inline bool check(int j,int i)
{
    if(j<top) return f[q[j+1]]-f[q[j]]<=(T[i]+s)*(F[q[j+1]]-F[q[j]]);
    else return 0;
}
inline bool Check(int j,int i)
{
    int a=(f[i]-f[q[j]])*(F[q[j]]-F[q[j-1]]);
    int b=(f[q[j]]-f[q[j-1]])*(F[i]-F[q[j]]);
    return a<=b;
}
main(){
#ifndef ONLINE_JUDGE
    freopen("Text1.in","r",stdin);
#endif
    n=read(),s=read();
    for(int i=1;i<=n;i++)
        T[i]=read(),F[i]=read(),T[i]+=T[i-1],F[i]+=F[i-1];
    for(int i=1;i<=n;i++)
    {
        int L=1,R=top;
        while(L<R)
        {
            int mid=(L+R)>>1;
            if(L==R) break ;
            if(check(mid,i)) L=mid+1;
            else R=mid;
        }
        int j=q[L];
        f[i]=f[j]+T[i]*F[i]+s*F[n]-F[j]*(s+T[i]);
        while(top>=2&&Check(top,i)) q[top--]=0; q[++top]=i;
    }
    printf("%lld",f[n]);
}

所以我们做个总结，斜率优化\(DP\)适用于状态转移方程为：
\(f[i]=min(f[j]+S(i,j))+k\)（\(k\)为常数）且\(S(i,j)\)计算时有\((i)*(j)\)的部分。
同时我们设的\(x,k\)必定要有单调性，如果\(k\)没有，就不删点二分，如果都没有，就用\(CDQ\)（相当于是动态插点，动态查找）当然没人拦你用平衡树……

\(NOI2019D1T1\)回家路线

据说……这道题被许多人嘲讽为水题，可我不这么想啊（果真是因为我太弱了吗……

但考场上就真的要……\(WOC\)你给我解释一下\(O_{(mt)}\)都能过是什么情况啊！！

你确定你真的不是用脚在造数据？！

正解（你\(™\)别给老子想什么暴力卡常）：斜率优化\(DP\)，推方程完全不难，设\(f[i]\)为最后乘编号为\(i\)的车的最小烦躁值，转移方程为：
\[ f[i]=min(f[j]+A*(p_i-q_j)^2+B*(p_i-q_j)+C) \]

决策点为\((q_i,f[j]+A*q_j^2-B*q_j)\)，当\(j\)比\(k\)更优时，满足：
\[ \frac{f[j]-f[k]+A*(q_j^2-q_k^2)-B*(q_j-q_k)}{q_j-q_k}<2*A*p_i \]
但是，我们转移时要满足\(p_i>=q_j,y_j=x_i\)，所以我们不能像以前一样维护一个凸包，从所有的决策中转移。

仔细思考一下，我们的决策来自部分满足条件的前面已经做出的决策，不妨我们对决策按\(i\)到达的位置分个组。

即在每个节点处维护一个凸包（这样一定满足单调性，不解释了），凸包中的点为\(f[j]\)（\(j\)为目的地为该节点的列车编号），这样我们转移时就可以满足空间限制了。

再考虑时间限制怎么做，我们可以枚举时间，再开一个等待队列，存在\(q[i]\)时到的列车\(i\)，但他们不能被利用，因为还没枚举到他们的到达时间，然后枚举到时间\(t\)时，将等待队列中所有到达时间为\(t\)的列车加进相应的凸包中（并维护凸包的单调性），说明他们可以被利用来转移。

最后在每次转移后将该次转移加入等待队列中，判断是否到达\(n\)，如果到达，就更新答案（记得加上\(q_i\)）

给泥萌看我丑陋的代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define S(x) ((x)*(x))
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=200010,M=1001;
queue<int> res[M];
int n,m,A,B,C,MaxT,ans=1e18;
vector<int> Tbg[M],Q[N];
int q[N],p[N],x[N],y[N],head[N],f[N];
inline double K(int j,int k)
{
    return (double)(f[j]-f[k]+A*(S(q[j])-S(q[k]))-B*(q[j]-q[k]))/(double)(q[j]-q[k]);
}
main(){
#ifndef ONLINE_JUDGE
    //freopen("A.in","r",stdin);//Ans=94;
    freopen("B.in","r",stdin);//Ans=34;
#endif
    n=read(),m=read(),A=read(),B=read(),C=read();
    for(int i=1;i<=m;i++)
    {
        x[i]=read(),y[i]=read(),p[i]=read();
        q[i]=read(),Tbg[p[i]].push_back(i);
        MaxT=max(MaxT,q[i]);
    }
    Q[1].push_back(0);
    for(int t=0;t<=MaxT;t++)
    {
        while(!res[t].empty())
        {
            int pos=y[res[t].front()];
            while(Q[pos].size()-head[pos]>=2)
            {
                int len=Q[pos].size();
                if(K(Q[pos][len-1],Q[pos][len-2])<K(Q[pos][len-2],res[t].front())) break;
                Q[pos].pop_back();
            }
            Q[pos].push_back(res[t].front()),res[t].pop();
        }
        for(int i=0;i<(int)Tbg[t].size();i++)
            if((int)Q[x[Tbg[t][i]]].size()>head[x[Tbg[t][i]]])
            {
                int id=Tbg[t][i],pos=x[id];
                while((int)Q[pos].size()-head[pos]>=2)
                {
                    if(K(Q[pos][head[pos]],Q[pos][head[pos]+1])>2.0*A*p[id]) break ;
                    head[pos]++;
                }
                int j=Q[pos][head[pos]];
                f[id]=f[j]+A*S(p[id]-q[j])+B*(p[id]-q[j])+C;
                res[q[id]].push(id);if(y[id]==n) ans=min(ans,f[id]+q[id]);
            }
    }
    printf("%lld",ans);
}

转载于:https://www.cnblogs.com/wo-shi-zhen-de-cai/p/11015133.html