[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 優，因此，在DPf[x] 時，g[i] 爲最優的x 對應的區間是一段連續的區間[L,R]

那麼我們可以得到一個DP優化的思路：枚舉1≤i≤n ，維護一個單調隊列，隊列裏每個結點保存的是三元組{p,L,R} ，就是在DPf[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;
}