bgm(雾)

luogu

首先是那个区间的价值比较奇怪,如果推导后可以发现只有左右端点元素都是同一种\(s_x\)的区间才有可能贡献答案,并且价值为\(s_x(cnt(x)_r-cnt(x)_{l-1})^2\),这是因为如果选出来的这种元素的端点的左右两边还有其他元素,那么显然的把那些其他的元素另外划分在别的区间里可以获得更优的答案

然后现在就可以\(O(n^2)\)了,转移大概为\(f_i=\min_{jj\)的\(k\)位置的贡献减少速度更快的,如果在某个位置\(j\)比\(k\)更优,那么以后\(k\)都不会更优了.所以考虑用单调栈维护这些决策点,在转移的时候如果栈顶下面的元素比栈顶元素更优了就弹栈顶,这个判断一个元素比另一个更优的时刻可以看做是维护凸壳,然后求一下直线交点.转移时用栈顶转移,接着把这个位置的dp值插入单调栈

不过这样做可能会出现栈顶下面两个元素比栈顶元素更优的时刻 要比 栈顶下面一个元素比栈顶元素更优的时刻 要早的情况,可以发现这种情况下栈顶下面一个元素就一定不优了,所以在插入元素的时候弹掉不优的就好了

#include<bits/stdc++.h>
#define LL long long
#define uLL unsigned long long
#define db double

using namespace std;
const int N=1e5+10,M=1e4+10;
int rd()
{
    int x=0,w=1;char ch=0;
    while(ch<'0'||ch>'9') {if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
    return x*w;
}
struct line
{
    db k,b;
}li[N];
db crs(line aa,line bb){return (bb.b-aa.b)/(aa.k-bb.k);}
int n,a[N],nt[N],bk[M],s[N];
LL f[N];
vector<int> stk[M];
vector<int>::iterator it;

int main()
{
    n=rd();
    for(int i=1;i<=n;++i) a[i]=rd();
    li[0].k=li[0].b=0;
    stk[a[1]].push_back(0);
    for(int i=1;i<=n;++i)
        nt[i]=bk[a[i]],s[i]=s[nt[i]]+1,bk[a[i]]=i;
    for(int i=1;i<=n;++i)
    {
        int x=a[i],nn=stk[x].size();
        while(nn>1&&crs(li[stk[x][nn-1]],li[stk[x][nn-2]])<=(db)s[i]) --nn,stk[x].pop_back();
        it=--stk[a[i]].end();
        f[i]=(LL)li[*it].k*s[i]+(LL)li[*it].b+1ll*a[i]*s[i]*s[i];
        li[i].k=-2ll*a[i+1]*s[nt[i+1]],li[i].b=f[i]+1ll*a[i+1]*s[nt[i+1]]*s[nt[i+1]];
        x=a[i+1],nn=stk[x].size();
        while(nn>1&&crs(li[stk[x][nn-2]],li[i])<=crs(li[stk[x][nn-1]],li[i])) --nn,stk[x].pop_back();
        stk[x].push_back(i);
    }
    printf("%lld\n",f[n]);
    return 0;
}