【BZOJ】4504 K个串 主席树+堆

题目传送门

一个晚上就做了这么一道题……好颓啊……

首先我们可以对于每个 ai 维护一个 pre[ai] 表示在它之前与他最近的相同的数的位置。

然后对于每个 ai ，在 (pre[ai],i) 这个范围内都加上 ai ，可以用主席树。

题目要求 k 个区间不相同，这就是“超级钢琴”的模型，套上超级钢琴的套路就行了。

附上AC代码：

#include 
#include 
#include 
#include 
using namespace std;

typedef long long ll;
const int N=1e5+10,M=7e6+10;
struct note{
    int w,wz;
    bool operator < (const note lyf) const {return w==lyf.w?wzstruct tree{
    ll w;int wz;
}t[M],tmp;
int n,m,c[N],pre[N],root[N],size,lt[M],rt[M];
ll lz[M];
struct heap{
    ll w;int root,wz,l,r;
    bool operator < (const heap lyf) const {return w que;

inline char nc(void){
    static char ch[100010],*p1=ch,*p2=ch;
    return p1==p2&&(p2=(p1=ch)+fread(ch,1,100010,stdin),p1==p2)?EOF:*p1++;
}

inline void read(int &a){
    static char c=nc();int f=1;
    for (;!isdigit(c);c=nc()) if (c=='-') f=-1;
    for (a=0;isdigit(c);a=(a<<3)+(a<<1)+c-'0',c=nc());
    return (void)(a*=f);
}

inline tree max(tree x,tree y){return x.w>y.w?x:y;}

#define mid (l+r>>1)
inline void build(int &k,int l,int r){
    k=++size;
    if (l==r) return (void)(t[k].w=0,t[k].wz=l);
    build(lt[k],l,mid),build(rt[k],mid+1,r);
    t[k]=max(t[lt[k]],t[rt[k]]);
    return;
}

inline void ist(int &k,int lst,int l,int r,int ql,int qr,int v){
    t[k=++size]=t[lst],lt[k]=lt[lst],rt[k]=rt[lst],lz[k]=lz[lst];
    if (l>=ql&&r<=qr) return (void)(t[k].w+=v,lz[k]+=v);
    if (qr<=mid) ist(lt[k],lt[lst],l,mid,ql,qr,v);
    else if (ql>mid) ist(rt[k],rt[lst],mid+1,r,ql,qr,v);
    else ist(lt[k],lt[lst],l,mid,ql,mid,v),ist(rt[k],rt[lst],mid+1,r,mid+1,qr,v);
    t[k]=max(t[lt[k]],t[rt[k]]),t[k].w+=lz[k];
    return;
}

inline tree query(int k,int l,int r,int ql,int qr){
    if (!k) return (tree){-2e9,0};
    if (l>=ql&&r<=qr) return t[k];
    tree ret;
    if (qr<=mid) ret=query(lt[k],l,mid,ql,qr);
    else if (ql>mid) ret=query(rt[k],mid+1,r,ql,qr);
    else ret=max(query(lt[k],l,mid,ql,mid),query(rt[k],mid+1,r,mid+1,qr));
    ret.w+=lz[k];
    return ret;
}

int main(void){
    read(n),read(m);
    for (int i=1; i<=n; ++i) read(c[i]),a[i]=(note){c[i],i};
    sort(a+1,a+1+n);
    for (int i=1; i<=n; ++i)
        if (a[i].w==a[i-1].w) pre[a[i].wz]=a[i-1].wz;
        else pre[a[i].wz]=0;
    build(root[0],1,n);
    for (int i=1; i<=n; ++i){
        ist(root[i],root[i-1],1,n,pre[i]+1,i,c[i]);
        tmp=query(root[i],1,n,1,i);
        que.push((heap){tmp.w,root[i],tmp.wz,1,i});
    }
    while (--m){
        heap p=que.top();que.pop();
        if (p.l1,n,p.l,p.wz-1);
            que.push((heap){tmp.w,p.root,tmp.wz,p.l,p.wz-1});
        }
        if (p.wz1,n,p.wz+1,p.r);
            que.push((heap){tmp.w,p.root,tmp.wz,p.wz+1,p.r});
        }
    }
    return printf("%lld\n",que.top().w),0;
}