[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]=max1≤j≤n{0,⌈aj+|i−j|−−−−−√−ai⌉}(⌈⌉表示向上取整)

为了方便起见，我们约定 j<i ，这样就可以顺着推了，然后把 a[] 序列翻转过来，再推一次DP，就能得到正确的解了
这个DP无法使用斜率优化降维，但是我们不妨设 h[j]=⌈aj+|i−j|−−−−−√−ai⌉ ，则 f[i]=max1≤j≤n{0,h[j]} 。

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

那么我们可以得到一个DP优化的思路：枚举 1≤i≤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∈[L,L′−1] ，队尾的 g[p] 最优，而对于 x∈[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;
}