数组 [线段树]-CSDN博客

题面

思路

考虑所有右端点确定为位置$R$的区间，显然它们的左端点取值可以在某个区间$[L,R]$中

因此我们只需要对每个$R$确定对应的$L$

我们令$pre[i]$表示$i$位置前面第一个和$i$颜色一样的位置

那么$L=max_{1\leq i\leq R}(pre[i])+1$也就是不能有同时2个出现在区间内

我们枚举$R=1\cdots n$，得到答案表达式：

$ans=\sum_{R=1}^n R-max{1\leq i\leq R}(pre[i])=\frac{n*(n+1)}{2}-\sum_{R=1}^n max{1\leq i\leq R}(pre[i])$

我们只需要处理后面那个东西

考虑用线段树维护这个值，令线段树上区间$[x,y]$表示：$\sum_{R=x}^{y} maxn{x\leq i leq R}(pre[i])$

我们同时再记录一个最大值，表示区间$[x,y]$中$pre[i]$的最大值

线段树上update的时候，最大值很好维护，但是这个和不太好处理

父亲显然可以直接继承左儿子的值，而右儿子则不行

因为右儿子记录的是$\sum_{R=mid+1}^{y} maxn{mid+1\leq i leq R}(pre[i])$

但是我们需要的是$\sum_{R=mid+1}^{y} maxn{x\leq i leq R}(pre[i])$

那么我们可以用左儿子的最大值$val$，带着它递归进入右儿子处理

每次进入右边的一个区间，首先判断当前最大值是否小于等于$val$，如果是，则整个区间一定全部取$val$，直接返回即可

否则判断当前区间的左儿子是否小于等于$val$，如果是，那么左边儿子可以全部取$val$，递归进入右边处理

否则，需要递归进入左儿子，注意到此时右儿子中一定全部大于$val$，直接返回即可，不需要再递归进入右儿子

（如果上面这段没有看懂，可以参考代码，有注释）

这样处理完之后，每次修改的复杂度是$O(\log ^2 n)$，查询就是输出线段树根的值

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cassert>
#include<set>
#define ll long long
using namespace std;
inline ll read(){
    ll re=0,flag=1;char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-') flag=-1;
        ch=getchar();
    }
    while(isdigit(ch)) re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
    return re*flag;
}
set<ll>s[200010];
ll n,p[200010],a[200010];
namespace seg{
    ll maxn[500010],sum[500010];
    ll comb(ll l,ll r,ll num,ll val){//递归更新
//      cout<<"combine "<<l<<' '<<r<<' '<<num<<' '<<maxn[num]<<' '<<val<<'\n';
        if(maxn[num]<=val) return (r-l+1)*val;//直接返回
        if(l==r) return sum[num];
        ll mid=(l+r)>>1;
        if(maxn[num<<1]<=val) return (mid-l+1)*val+comb(mid+1,r,num<<1|1,val);//左儿子全军覆没，右儿子不知道，递归进入右儿子
        else return comb(l,mid,num<<1,val)+sum[num]-sum[num<<1];//左儿子可能还有比val小的，右儿子一定全部比val大（因为继承了左儿子中大于val的某一项），递归进入左儿子
                //注意这里不能写sum[num<<1|1]，因为在当前这一层意义下的右儿子的值和下一层意义下右儿子的和是不一样的
    }
    void update(ll l,ll r,ll num){
        ll mid=(l+r)>>1;
        maxn[num]=max(maxn[num<<1],maxn[num<<1|1]);
        sum[num]=sum[num<<1]+comb(mid+1,r,num<<1|1,maxn[num<<1]);
    }
    void build(ll l,ll r,ll num){
        if(l==r){maxn[num]=sum[num]=p[l];return;}
        ll mid=(l+r)>>1;
        build(l,mid,num<<1);build(mid+1,r,num<<1|1);
        update(l,r,num);
    }
    void change(ll l,ll r,ll num,ll pos,ll val){
        if(l==r){maxn[num]=sum[num]=val;return;}
        ll mid=(l+r)>>1;
        if(mid>=pos) change(l,mid,num<<1,pos,val);
        else change(mid+1,r,num<<1|1,pos,val);
        update(l,r,num);
    }
}
int main(){
    n=read();ll i,t1,t2,t3;
    set<ll>::iterator it,pre,suf,ppre,ssuf;
    for(i=1;i<=n;i++) a[i]=read(),s[a[i]].insert(i);
    for(i=1;i<=n;i++){
        for(it=s[i].begin();it!=s[i].end();it++){
            if(it==s[i].begin()) continue;
            it--;pre=it;it++;
            p[(*it)]=*pre;
        }
    }
    seg::build(1,n,1);
    ll Q=read();
    while(Q--){
        t3=read();
        if(t3){//pre数组用set来维护
            t1=read();t2=read();

            it=s[a[t1]].find(t1);
            it++;suf=it;it--;
            if(suf!=s[a[t1]].end()){
                if(it!=s[a[t1]].begin()){
                    it--;pre=it;it++;
                    seg::change(1,n,1,(*suf),(*pre));
                }
                else seg::change(1,n,1,(*suf),0);
            }
            s[a[t1]].erase(it);

            s[t2].insert(t1);
            it=s[t2].find(t1);
            it++;suf=it;it--;
            if(suf!=s[t2].end()) seg::change(1,n,1,*suf,t1);
            if(it!=s[t2].begin()){
                it--;pre=it;it++;
                seg::change(1,n,1,t1,*pre);
            }
            else seg::change(1,n,1,t1,0);

            a[t1]=t2;
        }
        else printf("%lld\n",(ll)(n*(n+1)/2)-seg::sum[1]);
    }
}

转载于:https://www.cnblogs.com/dedicatus545/p/9728276.html