[BZOJ4850][JSOI2016]灯塔(分块/决策单调性优化DP)

第一种方法是决策单调性优化DP。

决策单调性是指，设i>j，若在某个位置x(x>i)上，决策i比决策j优，那么在x以后的位置上i都一定比j优。

根号函数是一个典型的具有决策单调性的函数，由于根号函数斜率递减，所以i决策的贡献的增长速度必定比j快。

于是使用基础的决策单调性优化即可。

注意两个问题，一是DP函数要存实数而不能存整数，因为先取整会丢失在后面的判断中需要的信息。二是记录决策作用区间的时候左端点要实时更新，即下面的p[st].l++，否则在二分时会出现错误。

#include<cmath>
#include<cstdio>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
using namespace std;

const int N=100010;
double f[N],g[N];
int n,st,ed,h[N];
struct P{ int l,r,p; }q[N];

int Abs(int x){ return (x>0) ? x : -x; }
double cal(int x,int y){ return h[x]-h[y]+sqrt(Abs(y-x)); }

int find(P a,int b){
    int L=a.l,R=a.r;
    while (L<R){
        int mid=(L+R)>>1;
        if (cal(a.p,mid)>=cal(b,mid)) L=mid+1; else R=mid;
    }
    return L;
}

void work(double f[]){
    st=ed=1; q[1]=(P){1,n,1};
    rep(i,2,n){
        q[st].l++; if (q[st].l>q[st].r) st++;
        f[i]=cal(q[st].p,i);
        if (st>ed || (cal(q[ed].p,n)<cal(i,n))){
            while (st<=ed && cal(q[ed].p,q[ed].l)<cal(i,q[ed].l)) ed--;
            if (st>ed) q[++ed]=(P){i,n,i};
            else{
                int t=find(q[ed],i); q[ed].r=t-1; q[++ed]=(P){t,n,i};
            }
        }
    }
}

int main(){
    scanf("%d",&n);
    rep(i,1,n) scanf("%d",&h[i]);
    work(f); reverse(h+1,h+n+1);
    work(g); reverse(g+1,g+n+1);
    rep(i,1,n) printf("%d
",max((int)ceil(max(f[i],g[i])),0));
    return 0;
}

第二种方法是分块。

这题中，对于固定的i，sqrt(i-j)只有O(sqrt(n))种取值，而每种取值的区间长度也只有O(sqrt(n))个。

预处理从每个数开始后O(sqrt(n))个数中的最大值，暴力枚举sqrt(i-j)的取值更新答案。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
typedef long long ll;
using namespace std;

const int N=100010,K=620;
int n,ans,h[N],mx[N][650];

int main(){
    freopen("bzoj4850.in","r",stdin);
    freopen("bzoj4850.out","w",stdout);
    scanf("%d",&n);
    rep(i,1,n) scanf("%d",&h[i]);
    rep(i,1,n){
        mx[i][1]=h[i];
        rep(j,2,min(K,n-i+1)) mx[i][j]=max(mx[i][j-1],h[i+j-1]);
    }
    rep(i,1,n){
        ans=0;
        for (int pos=i,j=1,nxt; pos!=1; j++)
            nxt=pos-1,pos=max(pos-j*2+1,1),ans=max(ans,mx[pos][nxt-pos+1]-h[i]+j);
        for (int pos,j=1,nxt=i; nxt!=n; j++)
            pos=nxt+1,nxt=min(nxt+j*2-1,n),ans=max(ans,mx[pos][nxt-pos+1]-h[i]+j);
        printf("%d
",ans);
    }
    return 0;
}