[BJWC2018]Border 的四种求法——SAM+线段树合并+DSU+链分治-优快云博客

Border 的四种求法

给定一个串，q次询问[l,r]的border长度。

思路

首先先对整个串建sam，然后我们对包含r的每一个状态去计算。

设当前状态的最大长度为len，如果一个结束位置i是合法的，当且仅当\(l\leq i < r\)，且\(i < l+len\)，然后我们需要找到一个最大的i满足这个条件，不难发现此时最暴力的做法就是在parent树上面暴力跳，然后在每个节点endpos集合的线段树上二分查找位置即可。

考虑如何将上面的暴力跳祖先的步骤给优化掉，如果我们可以一次处理一段树上的路径，那么复杂度就更优秀了。

将上面的式子化一下，\(l > i-len\)，我们对于每一个节点维护一个以i为下标的线段树，每个节点的权值为\(i-len\)，如果我们要查找l的答案，我们需要找到最大的i满足\(i < r\)且\(i-len < l\)，这个也可以在线段树上二分查找来实现。

既然线段树中以i为下标，那么我们完全可以将一条链上的线段树合并，每个节点的权值为\(\min(i-len)\)。

这样不难发现每个位置都会在所有祖先的线段树里面出现，这样复杂度就不对了，考虑每个位置的\(\min(i-len)\)在什么时候取得，这个len取最大值的时候代表的即r和i的lcp，两个位置的lcp一定是parent树上的lca处取得（越往上面跳len会越小），所以我们可以只在lca处将每个节点加入线段树，也就是r的每一个祖先只计算不包含r的那些子树的endpos集合。

最后考虑如何维护上面的那个“只考虑不包含r的子树的endpos集合”，对于不同的r，显然每一个点考虑的子树是不一样的，为了解决这个问题，便可以用经典的链分治来解决，也就是树链剖分，一条重链上的每一个节点只维护所有轻儿子，然后对于每一条链记录一个前缀线段树，轻边连接的部分我们可以暴力做，重链上的部分直接在前缀线段树上查询即可。

由于至多跳\(\log n\)条重链，所以时间复杂度为\(n\log ^2 n\)。

/*=======================================
 * Author : ylsoi
 * Time : 2019.3.13
 * Problem : luogu4482
 * E-mail : ylsoi@foxmail.com
 * ====================================*/
#include<bits/stdc++.h>

#define REP(i,a,b) for(int i=a,i##_end_=b;i<=i##_end_;++i)
#define DREP(i,a,b) for(int i=a,i##_end_=b;i>=i##_end_;--i)
#define debug(x) cout<<#x<<"="<<x<<" "
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define pii pair<int,int>
typedef long long ll;

using namespace std;

void File(){
    freopen("luogu4482.in","r",stdin);
    freopen("luogu4482.out","w",stdout);
}

template<typename T>void read(T &_){
    _=0; T f=1; char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
    for(;isdigit(c);c=getchar())_=(_<<1)+(_<<3)+(c^'0');
    _*=f;
}

string proc(){
    ifstream f("/proc/self/status");
    return string(istreambuf_iterator<char>(f),istreambuf_iterator<char>());
}


const int maxn=4e5+10;
const int inf=0x3f3f3f3f;
int n,q,mp[maxn];
char str[maxn];
vector<int>G[maxn];

namespace Suf{
    int ch[maxn][26],len[maxn],fa[maxn],pos[maxn],last=1,cnt=1;
    void insert(int x,int y){
        int p=last,np=last=++cnt;
        len[np]=len[p]+1;
        pos[np]=y,mp[y]=np;
        while(p && !ch[p][x])ch[p][x]=np,p=fa[p];
        if(!p)fa[np]=1;
        else{
            int q=ch[p][x];
            if(len[q]==len[p]+1)fa[np]=q;
            else{
                int nq=++cnt;
                memcpy(ch[nq],ch[q],sizeof(ch[nq]));
                len[nq]=len[p]+1,fa[nq]=fa[q];
                fa[q]=fa[np]=nq;
                while(p && ch[p][x]==q)ch[p][x]=nq,p=fa[p];
            }
        }
    }
}

using Suf::len;
using Suf::fa;
using Suf::pos;

namespace Tree{
    int tp[maxn],son[maxn],sz[maxn];
    void dfs1(int u){
        sz[u]=1;
        for(int v:G[u]){
            dfs1(v);
            sz[u]+=sz[v];
            if(sz[v]>sz[son[u]])son[u]=v;
        }
    }
    void dfs2(int u,int t){
        tp[u]=t;
        if(son[u])dfs2(son[u],t);
        for(int v:G[u])if(v!=son[u])
            dfs2(v,v);
    }
}

using Tree::tp;
using Tree::son;

namespace Smt{
#define mid ((l+r)>>1)
    int mn[maxn<<5],ch[maxn<<5][2],root[maxn],cnt;
    void insert(int &o,int l,int r,int p,int x){
        if(!o)o=++cnt;
        mn[o]=min(mn[o],x);
        if(l==r)return;
        else{
            if(p<=mid)insert(ch[o][0],l,mid,p,x);
            else insert(ch[o][1],mid+1,r,p,x);
        }
    }
    int query(int o,int l,int r,int R,int x){
        if(l>R || (r<=R && mn[o]>x))return -inf;
        if(l==r)return l;
        else{
            int ret=query(ch[o][1],mid+1,r,R,x);
            if(ret!=-inf)return ret;
            return query(ch[o][0],l,mid,R,x);
        }
    }
#undef mid
}

using Smt::root;
using Smt::insert;
using Smt::query;

set<int>st[maxn];
pii qu[maxn];
int ans[maxn];
vector<int>lis[maxn];

void dfs(int u,int o){
    if(pos[u])insert(root[o],1,n,pos[u],pos[u]-len[o]);
    for(int v:G[u])dfs(v,o);
}

void solve(int u){
    if(son[fa[u]]==u)root[u]=root[fa[u]];
    for(int id:lis[u])ans[id]=max(ans[id],query(root[u],1,n,qu[id].se-1,qu[id].fi-1));

    for(int v:G[u])if(v!=son[u])dfs(v,u);
    if(pos[u])insert(root[u],1,n,pos[u],pos[u]-len[u]),st[u].insert(pos[u]);

    for(int v:G[u]){
        solve(v);
        if(st[u].size()<st[v].size())swap(st[u],st[v]);
        for(int x:st[v])st[u].insert(x);
    }

    for(int id:lis[u]){
        auto it=st[u].lower_bound(min(qu[id].fi+len[u],qu[id].se));
        if(it!=st[u].begin()){
            --it;
            ans[id]=max(ans[id],*it);
        }
    }
}

int main(){
    File();

    using Suf::insert;
    scanf("%s",str+1);
    n=strlen(str+1);
    REP(i,1,n)insert(str[i]-'a',i);

    REP(i,2,Suf::cnt)G[fa[i]].pb(i);
    Tree::dfs1(1);
    Tree::dfs2(1,1);

    memset(Smt::mn,63,sizeof(Smt::mn));

    read(q);
    REP(i,1,q){
        read(qu[i].fi),read(qu[i].se);
        int u=mp[qu[i].se];
        while(u){
            lis[u].pb(i);
            u=fa[tp[u]];
        }
        ans[i]=qu[i].fi-1;
    }

    solve(1);

    REP(i,1,q)printf("%d\n",ans[i]-qu[i].fi+1);

    cerr<<proc()<<endl;
    return 0;
}

转载于:https://www.cnblogs.com/ylsoi/p/10523989.html