[CSAcademy]Squared Ends

[CSAcademy]Squared Ends

题目大意：

给你一个长度为\(n(n\le10^4)\)的数列\(\{A_i\}(A_i\le10^6)\)。定义区间\(A_{[l,r]}\)的代价为\((A_l-A_r)^2\)。求将\(\{A_i\}\)划分成\(k(k\le100)\)个区间的最小代价。

思路：

不难想到一种动态规划，用\(f[i][j]\)表示已经划分了\(i\)个区间，结尾是\(j\)的最小代价。转移方程为:
\[ f[i][j]=\min\{f[i-1][k-1]+(A_j-A_k)^2\} \]

时间复杂度是\(\mathcal O(n^2k)\)。

变形得：
\[ f[i][j]=A_j^2+\min\{-2A_jA_k+f[i-1][k-1]+A_k^2\} \]

其中\(\min\)中的东西可以看做是关于\(A_j\)的一次函数。而寻找\(\min\)值的过程就相当于在一堆一次函数中找最小值，用李超树维护凸壳即可。

时间复杂度\(\mathcal O(nk\log\operatorname{range}(A_i))\)。

源代码：

#include<cstdio>
#include<cctype>
#include<climits>
#include<algorithm>
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=1e4+1,K=101,LIM=1e6;
typedef long long int64;
class SegmentTree {
    #define _left <<1
    #define _right <<1|1
    #define mid ((b+e)>>1)
    private:
        struct Node {
            int64 a,b,time;
        };
        Node node[LIM<<2];
    public:
        void reset(const int &p,const int &b,const int &e) {
            node[p]=(Node){0,0};
            if(b==e) return;
            reset(p _left,b,mid);
            reset(p _right,mid+1,e);
        }
        void insert(const int &p,const int &b,const int &e,const int64 &i,const int64 &j,const int &t) {
            if(node[p].time!=t) {
                node[p].a=i;
                node[p].b=j;
                node[p].time=t;
                return;
            }
            const int64 lval1=node[p].a*b+node[p].b;
            const int64 rval1=node[p].a*e+node[p].b;
            const int64 lval2=i*b+j,rval2=i*e+j;
            if(lval1<=lval2&&rval1<=rval2) return;
            if(lval2<=lval1&&rval2<=rval1) {
                node[p].a=i;
                node[p].b=j;
                return;
            }
            if(b==e) return;
            const long double c=1.*(node[p].b-j)/(i-node[p].a);
            if(lval1<=lval2&&c<=mid) {
                insert(p _left,b,mid,node[p].a,node[p].b,t);
                node[p].a=i;
                node[p].b=j;
                return;
            }
            if(lval1<=lval2&&c>=mid) {
                insert(p _right,mid+1,e,i,j,t);
                return;
            }
            if(lval1>=lval2&&c<=mid) {
                insert(p _left,b,mid,i,j,t);
                return;
            }
            if(lval1>=lval2&&c>=mid) {
                insert(p _right,mid+1,e,node[p].a,node[p].b,t);
                node[p].a=i;
                node[p].b=j;
                return;
            }
        }
        int64 query(const int &p,const int &b,const int &e,const int &x,const int &t) const {
            if(node[p].time!=t) return LLONG_MAX;
            int64 ret=node[p].a*x+node[p].b;
            if(b==e) return ret;
            if(x<=mid) ret=std::min(ret,query(p _left,b,mid,x,t));
            if(x>mid) ret=std::min(ret,query(p _right,mid+1,e,x,t));
            return ret;
        }
    #undef _left
    #undef _right
    #undef mid
};
SegmentTree t;
int a[N];
int64 f[K][N];
int main() {
    const int n=getint(),k=getint();
    for(register int i=1;i<=n;i++) {
        a[i]=getint();
        f[0][i]=INT_MAX*500ll;
    }
    t.reset(1,1,n);
    for(register int i=1;i<=k;i++) {
        for(register int j=i;j<=n+i-k;j++) {
            t.insert(1,1,LIM,-2*a[j],f[i-1][j-1]+(int64)a[j]*a[j],i);
            f[i][j]=(int64)a[j]*a[j]+t.query(1,1,LIM,a[j],i);
        }
    }
    printf("%lld\n",f[k][n]);
    return 0;
}