[CF862F]Mahmoud and Ehab and the final stage

Description

给出n个字符串s[i]，资瓷两种操作：
1 a b 询问所有[a,b]的子区间[l,r]中LCP(l,r)*(r-l+1)的最大值。
其中LCP(l,r)表示s[l]~s[r]的LCP
2 x st 把s[x]变成st

n,q<=1e5,∑|S|<=1e5

Solution

看到总串长比较小就知道是套路题。
分三种情况考虑。
第一种情况，只有一个串，那么直接用线段树维护区间最大值即可。
第二种情况，LCP较小，那么我们可以枚举LCP=k,然后把>=k的位置看做1，其余的看做0，求最长连续1即可。
复杂度O(nklog n)
第三种情况，LCP较大，我们把所有合法的位置拉出来建笛卡尔树暴力即可。
复杂度O(n^2/k)
平衡一下总复杂度O($n\sqrt{n log n}$)

Code

#include <set>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define rep(i,a) for(int i=lst[a];i;i=nxt[i])
using namespace std;

int read() {
    char ch;
    for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
    int x=ch-'0';
    for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
    return x;
}

void write(int x) {
    if (!x) {puts("0");return;}
    char ch[20];int tot=0;
    for(;x;x/=10) ch[++tot]=x%10+'0';
    fd(i,tot,1) putchar(ch[i]);
    puts("");
}

const int N=1e5+5,K=50;

int n,q,l,r,x,y,tot,ans,opt,mx[N<<2],root[N],a[N],v[N],size[N],L[N],R[N],ls[N*K<<1],rs[N*K<<1],stack[N];

set<int> S;
typedef set<int> :: iterator it;
vector<int> s[N];
#define pb(a) push_back(a)

struct Segment_Tree{
    int lmx,rmx,mx;bool all;
    friend Segment_Tree operator + (Segment_Tree y,Segment_Tree z) {
        Segment_Tree x;
        x.lmx=y.lmx+z.lmx*y.all;
        x.rmx=z.rmx+y.rmx*z.all;
        x.mx=max(y.mx,z.mx);
        x.mx=max(x.mx,y.rmx+z.lmx);
        x.all=y.all&z.all;
        return x;
    }
}tr[N*K<<1],Null;

int LCP(int x) {
    int len=min(s[x].size(),s[x+1].size()),k=0;
    while (k<len&&s[x][k]==s[x+1][k]) k++;
    return k;
}

void change(int v,int l,int r,int x,int y) {
    if (l==r) {mx[v]=y;return;}
    int mid=l+r>>1;
    if (x<=mid) change(v<<1,l,mid,x,y);
    else change(v<<1|1,mid+1,r,x,y);
    mx[v]=max(mx[v<<1],mx[v<<1|1]);
}

int query(int v,int l,int r,int x,int y) {
    if (l==x&&r==y) return mx[v];
    int mid=l+r>>1;
    if (y<=mid) return query(v<<1,l,mid,x,y);
    else if (x>mid) return query(v<<1|1,mid+1,r,x,y);
    else return max(query(v<<1,l,mid,x,mid),query(v<<1|1,mid+1,r,mid+1,y));
}

void modify(int &v,int l,int r,int x,int y) {
    if (!v) v=++tot;
    if (l==r) {
        tr[v].mx=tr[v].lmx=tr[v].rmx=tr[v].all=y;
        return;
    }
    int mid=l+r>>1;
    if (x<=mid) modify(ls[v],l,mid,x,y);
    else modify(rs[v],mid+1,r,x,y);
    tr[v]=tr[ls[v]]+tr[rs[v]];
}

Segment_Tree find(int v,int l,int r,int x,int y) {
    if (!v||x>y) return Null;
    if (l==x&&r==y) return tr[v];
    int mid=l+r>>1;
    if (y<=mid) return find(ls[v],l,mid,x,y);
    else if (x>mid) return find(rs[v],mid+1,r,x,y);
    else return find(ls[v],l,mid,x,mid)+find(rs[v],mid+1,r,mid+1,y);
}

void get(int x) {
    s[x].clear();
    char ch;
    for(ch=getchar();ch<'a'||ch>'z';ch=getchar());s[x].pb(ch-'0');
    for(ch=getchar();ch>='a'&&ch<='z';ch=getchar()) s[x].pb(ch-'0');
    change(1,1,n,x,s[x].size());
}

void Change(int x) {
    int now=LCP(x);
    if (v[x]>K) S.erase(S.find(x));
    if (now>K) S.insert(x);
    v[x]=now;
    fo(i,1,K) modify(root[i],1,n-1,x,i<=v[x]);
}

void dfs(int x) {
    size[x]=1;
    if (L[x]) dfs(L[x]),size[x]+=size[L[x]];
    if (R[x]) dfs(R[x]),size[x]+=size[R[x]];
    ans=max(ans,v[x]*(size[x]+1));
}

int main() {
    freopen("pty.in","r",stdin);
    freopen("pty.out","w",stdout);
    n=read();q=read();
    fo(i,1,n) get(i);
    fo(i,1,n-1) {
        v[i]=LCP(i);
        if (v[i]>K) S.insert(i);
        fo(j,1,K) modify(root[j],1,n-1,i,j<=v[i]);
    }
    for(;q;q--) {
        opt=read();
        if (opt==1) {
            l=read();r=read();
            ans=query(1,1,n,l,r);
            fo(i,1,K) {
                Segment_Tree now=find(root[i],1,n-1,l,r-1);
                if (now.mx) ans=max(ans,(now.mx+1)*i);
            }

            if (!S.empty()) {
                it pos=S.lower_bound(l);
                for(int id=*pos;id<r&&pos!=S.end();) {
                    for(a[a[0]=1]=id;(id=*(++pos))<r&&id==a[a[0]]+1&&pos!=S.end();) a[++a[0]]=id;
                    int top=0;
                    fo(i,1,a[0]) {
                        L[a[i]]=R[a[i]]=0;
                        while (top&&v[stack[top]]>v[a[i]]) L[a[i]]=stack[top--];
                        R[stack[top]]=a[i];stack[++top]=a[i];
                    }
                    dfs(stack[1]);
                }
            }

            write(ans);
        }
        if (opt==2) {
            x=read();
            get(x);
            if (x<n) Change(x);
            if (x>1) Change(x-1);
        }
    }
    return 0;
}