bzoj2216 [Poi2011]Lightning Conductor（决策单调性DP）

bzoj2216 [Poi2011]Lightning Conductor

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=2216

题意：
已知一个长度为n的序列a1,a2,…,an。
对于每个1<=i<=n，找到最小的非负整数p满足 对于任意的j, aj < = ai + p - sqrt(abs(i-j))

数据范围
1<=n<=500000，0<=ai<=1000000000

题解：
好题。
对于abs的处理就直接正反各跑一遍。

$p_i>=max(a_j+\sqrt{|i-j|})-a_i$ 决策与$a_i$无关。
因为$\sqrt{x}$这东西是涨得越来越慢的，决策点是单调的。

（于是傻逼的我想都没想就直接队列首尾弹一弹以为能O(n)然后并不行。
因为在i移动时，队列中的点的大小关系可能发生变化，不知道什么时候该弹。
反过来思考，每个点对其后方的点的影响，以它作为答案的是连续的一段区间。
需要求出每个点准确的能够控制的区间。）

于是在加入点时计算出其能够控制的区间，这个过程用二分，以便弹出。
注意，过程中必须要保证L>=i，
否则由于不能保证j< i，sqrt()谁涨得快不一定，下面弹栈不能那么弹 。

UPD：整体二分好啊，好写好调，哪像单调队列

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int N=500005;
const int inf=0x3f3f3f3f;
struct node
{
    int L,R,id;
    node(){}
    node(int L,int R,int id):L(L),R(R),id(id){}
}Q[N];
int a[N],f[N],n;
double cal(int j,int i) {return (double)a[j]-a[i]+sqrt(abs(i-j));}
int find(int x,int y,int l,int r)    
{
    int lf=l; int rg=r; 
    while(lf+1<rg)
    {
        int mid=(lf+rg)>>1;
        if(cal(x,mid)<cal(y,mid)) lf=mid;
        else rg=mid;
    }
    if(cal(x,rg)<cal(y,rg)) return rg;
    else return lf;
}
void getans()
{
    int h=1,t=0;
    for(int i=1;i<=n;i++)
    {
        Q[h].L++; 
        while(h<=t&&(Q[h].R<i||Q[h].L>Q[h].R)) h++;
        if(h>t) Q[++t]=node(i,n,i);
        else if(cal(i,n)>cal(Q[t].id,n))
        {
            while(h<=t&&cal(i,Q[t].L)>=cal(Q[t].id,Q[t].L)) t--;
            if(h<=t)
            {
                int pos=find(i,Q[t].id,Q[t].L,Q[t].R);
                Q[t].R=pos; Q[++t]=node(pos+1,n,i); 
            }
            else Q[++t]=node(i,n,i);
        }
        f[i]=max(f[i],(int)ceil(cal(Q[h].id,i)));   
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    memset(f,0,sizeof(f)); 
    getans();
    for(int i=1;i+i<=n;i++) {swap(a[i],a[n-i+1]); swap(f[i],f[n-i+1]);}
    getans();
    for(int i=1;i<=n;i++) printf("%d\n",f[n-i+1]);
    return 0;
}