[loj2572]字符串

约定：以下字符串下标从1开始，令$n=|s|$

对于字符串$s_{1}$和$s_{2}$，定义以下信息——

定义$s_{1}\approx s_{2}$当且仅当$s_{1}[1,l]=s_{2}[1,l]$（其中$l=\min(|s_{1}|,|s_{2}|)$）

定义$s_{1}\ll s_{2}$当且仅当$s_{1}<s_{2}$且$s_{1}\not\approx s_{2}$，$s_{1}\gg s_{2}$当且仅当$s_{1}>s_{2}$且$s_{1}\not\approx s_{2}$

 

定义$f(s)$为$s$中最小后缀的位置，即$s[f(s),n]=\min_{i=1}^{n}s[i,n]$

结论：若$s=caab$，则$f(s)\ne |c|+|a|+1$（其中$a,b,c$为任意字符串，且$a,b$非空）

考虑取另外$|c|+1$和$|c|+2|a|+1$的位置，即求证$aab<ab$或$b<ab$

当$ab<b$时，前者显然成立，否则由于$b\ne ab$，后者即成

 

$\forall x\in [1,n]$，$x\in S$当且仅当其满足：

1.$\forall 1\le y\le n,s[x,n]\not\ll s[y,n]$

2.$\forall 1\le y<x且2x-y\le n,s[y,n]\not\approx s[x,n]$

（这个条件即等价于不存在$s[1,n]=caab$使得$f(s)=|c|+|a|+1$）

显然，有$f(s)\in S$，下面考虑$|S|$的大小——

结论：$|S|\sim o(\log n)$

若$x,y\in S$（不妨假设$x<y$），根据第一个性质，则有$s[x,n]\approx s[y,n]$

若$2y-x\le n$，即可以得到$s[x,y)=s[y,2y-x)$，与第2个性质矛盾

因此$2y-x>n$，也即$2|s[y,n]|\le |s[x,n]|$，因此将$S$中的$x$写作$n-x+1$从小到大排列后，后一项大于等于前一项的两倍且值域为$[1,n]$，即有$|S|\sim o(\log n)$

当求出$s[l,r]$对应的$S$后，$S$中的最大值即为答案，求最大值复杂度为$o(\log n)$

 

下面，考虑两个字符串$s_{1}$和$s_{2}$，两者的$S$分别为$S_{1}S_{2}$，下面来求$s=s_{1}s_{2}$的$S$

先将$S_{2}$中所有元素加上$|s_{1}|$，注意到$S\subseteq S_{1}\cup S_{2}$，从小到大枚举$x\in S_{1}\cup S_{2}$中的元素$x$，并判定能否加入$S_{i}$中，判定只需要考虑$S$中的元素，具体即——

初始$S$为空，若$S$为空则直接加入，否则令$y$为当前$S_{i}$中的最大值，考虑$s[x,n]$和$s[y,n]$的关系：

1.$s[x,n]\approx s[y,n]$，若$2x-y>n$则加入$x$

2.$s[x,n]\gg s[y,n]$，不加入$x$

3.$s[x,n]\ll s[y,n]$，令$S_{i}=\{x\}$

比较可以使用二分+哈希，复杂度为$o(\log n)$，哈希用分块维护可以做到修改$o(\sqrt{n})$

综上，合并复杂度为$o(\log^{2}n)$，即可用线段树维护，初始复杂度为$o(n\log^{2}n)$，单次修改和查询复杂度总复杂度为$o(\log^{3}n)$，最终总复杂度为$o(n\log^{2}n+m\log^{3}n+m\sqrt{n})$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 200005
#define K 500
#define base 500000003
#define mod 998244353
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
struct Data{
    int l,r;
    vector<int>v;
}f[N<<2];
int n,m,p,x,y,z,inv,Inv,mi[N],inv_mi[N],a[N],bl[N],st[K],ed[K],tag1[K],tag2[K],sum[N];
int qpow(int n,int m){
    int s=n,ans=1;
    while (m){
        if (m&1)ans=1LL*ans*s%mod;
        s=1LL*s*s%mod;
        m>>=1;
    }
    return ans;
}
int get_sum(int x,int y){
    return 1LL*(inv_mi[x]+mod-inv_mi[y+1])*Inv%mod;
}
int get_hash(int k){
    return (sum[k]+1LL*tag1[bl[k]]*mi[k]+1LL*tag2[bl[k]]*get_sum(st[bl[k]],k)%mod*mi[k])%mod;
}
void update_hash(int x,int y,int z){
    if (bl[x]==bl[y]){
        for(int i=x;i<=y;i++)sum[i]=(sum[i]+1LL*z*get_sum(x,i)%mod*mi[i])%mod;
        int s=1LL*z*get_sum(x,y)%mod;
        for(int i=y+1;i<=ed[bl[y]];i++)sum[i]=(sum[i]+1LL*s*mi[i]%mod)%mod;
        for(int i=bl[y]+1;i<=bl[n];i++)tag1[i]=(tag1[i]+s)%mod;
    }
    else{
        for(int i=x;i<=ed[bl[x]];i++)sum[i]=(sum[i]+1LL*z*get_sum(x,i)%mod*mi[i])%mod;
        int s=1LL*z*get_sum(x,ed[bl[x]])%mod;
        for(int i=bl[x]+1;i<bl[y];i++){
            tag1[i]=(tag1[i]+s)%mod;
            tag2[i]=(tag2[i]+z)%mod;
            s=(s+1LL*z*get_sum(st[i],ed[i]))%mod;
        }
        for(int i=st[bl[y]];i<=y;i++)sum[i]=(sum[i]+(1LL*z*get_sum(st[bl[y]],i)+s)%mod*mi[i])%mod;
        s=(s+1LL*z*get_sum(st[bl[y]],y))%mod;
        for(int i=y+1;i<=ed[bl[y]];i++)sum[i]=(sum[i]+1LL*s*mi[i]%mod)%mod;
        for(int i=bl[y]+1;i<=bl[n];i++)tag1[i]=(tag1[i]+s)%mod;
    }
}
int query_hash(int x,int y){
    return (get_hash(y)-1LL*mi[y-x+1]*get_hash(x-1)%mod+mod)%mod;
}
int lcp(int x,int y,int i){
    int l=0,r=i-y+1;
    while (l<r){
        int midd=(l+r+1>>1);
        if (query_hash(x,x+midd-1)==query_hash(y,y+midd-1))l=midd;
        else r=midd-1;
    }
    return l;
}
int cmp(int x,int y,int i){
    int l=lcp(x,y,i);
    if (l==i-y+1)return 0;
    if (query_hash(x+l,x+l)<query_hash(y+l,y+l))return -1;
    return 1;
}
Data merge(Data a,Data b){
    if (!a.l)return b;
    if (!b.l)return a;
    Data ans;
    ans.l=a.l,ans.r=b.r;
    ans.v.clear();
    for(int i=0;i<a.v.size();i++){
        if (!ans.v.size())ans.v.push_back(a.v[i]);
        else{
            int x=ans.v.back(),y=a.v[i],p=cmp(x,y,b.r);
            if (p>0)ans.v.clear();
            if ((p>0)||(!p)&&(2*y-x>b.r))ans.v.push_back(y);
        }
    }
    for(int i=0;i<b.v.size();i++){
        if (!ans.v.size())ans.v.push_back(b.v[i]);
        else{
            int x=ans.v.back(),y=b.v[i],p=cmp(x,y,b.r);
            if (p>0)ans.v.clear();
            if ((p>0)||(!p)&&(2*y-x>b.r))ans.v.push_back(y);
        }
    }
    return ans;
}
void build(int k,int l,int r){
    if (l==r){
        f[k].l=f[k].r=l;
        f[k].v.push_back(l);
        return;
    }  
    build(L,l,mid);
    build(R,mid+1,r);
    f[k]=merge(f[L],f[R]);
}
void update(int k,int l,int r,int x,int y){
    if ((l>y)||(x>r))return;
    if ((x<=l)&&(r<=y))return;
    update(L,l,mid,x,y);
    update(R,mid+1,r,x,y);
    f[k]=merge(f[L],f[R]);
}
Data query(int k,int l,int r,int x,int y){
    if ((l>y)||(x>r))return f[0];
    if ((x<=l)&&(r<=y))return f[k];
    return merge(query(L,l,mid,x,y),query(R,mid+1,r,x,y));
}
int main(){
    inv=qpow(base,mod-2),Inv=qpow(mod+1-inv,mod-2);
    mi[0]=inv_mi[0]=1;
    for(int i=1;i<N;i++)mi[i]=1LL*mi[i-1]*base%mod;
    for(int i=1;i<N;i++)inv_mi[i]=1LL*inv_mi[i-1]*inv%mod;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        bl[i]=i/K+1;
        if (!st[bl[i]])st[bl[i]]=i;
        ed[bl[i]]=i;
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        a[i]+=base/2;
        sum[i]=(1LL*sum[i-1]*base+a[i])%mod;
    }
    build(1,1,n);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&p,&x,&y);
        if (p==1){
            scanf("%d",&z);
            update_hash(x,y,(z+mod)%mod);
            update(1,1,n,x,y);
        }
        if (p==2)printf("%d\n",query(1,1,n,x,y).v.back());
    }
}