维修机器人

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=101000;
const long long oo=20000000;
long long h[MAXN];
int n;
long long st[MAXN][30];
int pow2[21];
int lg[MAXN];
long long cost;
long long sum[MAXN];
long long sumsqr[MAXN];
void init_st()
{
    pow2[0]=1;
    for(int i=1;i<=20;i++)pow2[i]=pow2[i-1]*2;
    int p=-1;
    for(int j=1;j<=n;j++)
    {
        st[j][0]=h[j];
        if(j==pow2[p+1])p++;
        lg[j]=p;
    }
    for(int k=1;pow2[k]<=n;k++)
    {
        for(int j=1;j+pow2[k]-1<=n;j++)
        st[j][k]=max(st[j][k-1],st[j+pow2[k-1]][k-1]);
    }
}
int RMQ(int a,int b)
{
    int del=b-a+1;
    del=lg[del];
    return max(st[a][del],st[b-pow2[del]+1][del]);
}
void init_sum()
{
    sum[0]=sumsqr[0]=0;
    for(int i=1;i<=n;i++)
    {
        sum[i]=sum[i-1]+h[i];
        sumsqr[i]=sumsqr[i-1]+(long long)h[i]*(long long)h[i];
    }
}
void init()
{
    scanf("%d%I64d",&n,&cost);
    for(int i=1;i<=n;i++)scanf("%I64d",&h[i]);
    h[0]=h[n+1]=oo;
    init_st();
    init_sum();
}

int stack[MAXN],top;
long long f[MAXN];
long long fmin(long long A,long long B,long long C,long long mn,long long mx)
{
    long long ret=oo*oo;
    long long topx=(-B)/(2*A);
    for(int i=0;i<=1;i++)
    {
        if(mn<=topx&&topx<=mx)ret=min(ret,A*topx*topx+B*topx+C);
        topx++;
    }
    ret=min(ret,min(A*mn*mn+B*mn+C,A*mx*mx+B*mx+C));
    return ret;
}
long long H(int a,int b)
{
    if(a==b-1)return cost*abs(h[b]-h[a]);
    int mn=RMQ(a+1,b-1)+1;
    int mx=min(h[a],h[b]);
    long long A=b-a-1,
                 B=-2*(sum[b-1]-sum[a]),
                C=sumsqr[b-1]-sumsqr[a];
    if(a!=0)B-=cost,C+=cost*h[a];
    if(b!=n+1)B-=cost,C+=cost*h[b];
    return fmin(A,B,C,mn,mx);
}
void work()
{
    top=0;
    stack[top++]=0;
    stack[top++]=1;
    f[1]=0;
    for(int i=2;i<=n+1;i++)
    {
        if(i!=n+1)f[i]=f[i-1]+cost*abs(h[i]-h[i-1]);
        else f[i]=f[i-1];
        while(h[stack[top-1]]<h[i])
        {
            f[i]=min(f[i],f[stack[top-1]]+H(stack[top-1],i));
            top--;
        }
        f[i]=min(f[i],f[stack[top-1]]+H(stack[top-1],i));
        if(h[stack[top-1]]==h[i])top--;
        stack[top++]=i;
    }
    printf("%I64d
",f[n+1]);
}
int main()
{
    freopen("repair.in","r",stdin);
    freopen("repair.out","w",stdout);
    init();
    work();
}

**对于这道题哇。我当初想的特别美好。看到样例我以为就是从左往右轮遇到最大的就把前面的值全变成这个值然后计算代价啥的哇，然后继续轮。。后来是我天真了。。。

***题解说：只有当 a > b 且 c > b 时，才可能对 b 进行调整，否则将b 增大不可能减小差值导致的代价，另一方面还有调整本身的代价，那么不妨设

b < c≤a。

另外一个显然的结论是，b 调整后不会超过 c，否则的话将 b 的调整量减小，调整的代价减小，差值的代价不会增大，整个方案会更优。

所以仅当 b < a 且 b < c 时需要进行调整，设调整后的数为 B，那么 B 的范围为［ b, min(a,c) ］ ( 将不调整也算入 ) 。调整后的总代价为

cost(B)=(B-b)2+(a-B)×C+(c-B)×C，这是一个二次函数，B 有确定的取值范围，要对其进行最优化是很容易的。

再到后来题解又转到了单调队列。RMQ啥的。。

实际上刚好符合单调队列的结构：从前往后扫描，维护单降队列，则每次插入一个元素时，从队首踢出的元素就是第二类转移的位置，踢完后队首的元素就是第一类转移的位置，而且也不需要专门实现一个 RMQ，每次转移时从队列中踢出的前一个元素就是 RMQ 的值。

然后这道题就结束了？！。。。。。先持保留意见等我哪天脑子灵光了估计可能就看懂了。。然后就可以翻译成我的小仙语啦。。。。