[POI 2011]Lightning Conductor(DP优化)

题目链接

http://main.edu.pl/en/archive/oi/18/pio

题目大意

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

思路

容易想到DP思路，用$f[i]$表示对应于$i$的最小非负整数$p$，DP方程为

$$f[i]=\max_{1\leq j\leq n}\{0,\lceil a_j+\sqrt{|i-j|}-a_i\rceil \}(\lceil \rceil表示向上取整)$$

为了方便起见，我们约定$j<i$，这样就可以顺着推了，然后把$a[]$序列翻转过来，再推一次DP，就能得到正确的解了
这个DP无法使用斜率优化降维，但是我们不妨设$h[j]=\lceil a_j+\sqrt{|i-j|}-a_i\rceil$，则$f[i]=\max_{1\leq j\leq n}\{0, h[j]\}$。

由于函数$\sqrt{x+1}-\sqrt{x}$单调递减，因此对于$k<j\leq i$而言，若在DP $f[i]$时，$j$比$k$优，则对于$i'>i$,DP $f[i']$时，$j$永远比$k$优，因此，在DP$f[x]$时，$g[i]$为最优的$x$对应的区间是一段连续的区间$[L,R]$

那么我们可以得到一个DP优化的思路：枚举$1\leq i\leq n$，维护一个单调队列，队列里每个结点保存的是三元组$\{p,L,R\}$，就是在DP$f[x]$时，$g[p]$为最优的$x$对应的区间是一段连续的区间$[L,R]$。从队首到队尾把所有的区间拼起来，就是区间$[i,n]$。

每次枚举到一个$i$时，首先让队首区间左端点+1(以满足从队首到队尾把所有的区间拼起来，就是区间$[i,n]$的条件)，并将队首那些区间已经变为空的结点弹出。这时候，对于$f[i]$而言，队首的$g[p]$就是最优的。如果队列为空，或者对于$f[n]$而言，队尾的$g[p]$没有$g[i]$优，则可以把$\{i,L',R'\}$这个结点插入到队尾，$R'$显然为$n$,而$L'$则是将队尾的区间$[L,n]$分割为$[L,L'-1]$和$[L',n]$，对于$x\in [L,L'-1]$，队尾的$g[p]$最优，而对于$x\in [L',n],g[i]$最优

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cmath>

#define MAXN 510000
#define EPS 1e-13

using namespace std;

double f[MAXN],g[MAXN]; //!!!!f是正着做的DP值，g是倒着做的DP值
int n,a[MAXN];

int dcmp(double x)
{
    if(fabs(x)<EPS) return 0;
    if(x>EPS) return 1;
    return -1;
}

struct Node //栈里的结点信息
{
    int p,L,R;
    Node(){}
    Node(int _p,int _L,int _R):p(_p),L(_L),R(_R){};
}q[MAXN*2];

int top=0;

double func(int i,int j) //a[j]+sqrt(abs(i-j))
{
    return (double)a[j]+sqrt((double)abs(i-j));
}

int BinarySearch(int L,int R,int p,int i) //在区间[L,R]里找到临界点q，使得对于[L,q-1]，p是最优解，对于[q,R]，i是最优解
{
    int lowerBound=L,upperBound=R,ans=-1;
    while(lowerBound<=upperBound)
    {
        int mid=(lowerBound+upperBound)>>1;
        if(func(mid,p)>func(mid,i)) lowerBound=mid+1;
        else
        {
            upperBound=mid-1;
            ans=mid;
        }
    }
    return ans;
}

void DP(double ans[])
{
    int h=1,t=0;
    for(int i=1;i<=n;i++)
    {
        q[h].L++; //保证队列里的区间左端点是大于等于i的
        if(h<=t&&q[h].R<q[h].L) h++; //队首的区间为空，则队首的p不会被任何f[i]用上，弹出队首
        if(h>t||func(n,i)>func(n,q[t].p)) //将i插入到队列中的条件是，队列为空，或者用i来更新f[n]比用队尾更新f[n]更优
        {
            while(h<=t&&func(q[t].L,q[t].p)<func(q[t].L,i)) t--;
            if(h>t) q[++t]=Node(i,i,n); //队首为空，则直接加入i，此时i会是f[i]~f[n]的最优值
            else
            {
                int tmp=BinarySearch(q[t].L,q[t].R,q[t].p,i); //[q[t].L,t-1]段的最优解是q[t].p,[t,n]段的最优解是i
                q[t].R=tmp-1;
                q[++t]=Node(i,tmp,n);
            }
        }
        ans[i]=func(i,q[h].p)-a[i]; //!!!
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    DP(f);
    reverse(a+1,a+n+1);
    DP(g);
    reverse(g+1,g+n+1);
    int ans=0;
    for(int i=1;i<=n;i++)
        printf("%d\n",max(0,(int)ceil(max(f[i],g[i]))));
    return 0;
}