【XSY1551】往事 广义后缀数组 线段树合并

题目大意

　　给你一颗trie树，令\(s_i\)为点\(i\)到根的路径上的字符组成的字符串。求\(max_{u\neq v}(LCP(s_u,s_v)+LCS(s_u,s_v))\)

　　\(LCP=\)最长公共前缀，\(LCS=\)最长公共后缀

　　\(1\leq n\leq 200000\)，字符集为\(\{0\ldots 300\}\)

题解

　　我们先看看这个\(LCP(s_u,s_v)\)怎么求

　　广义后缀自动机不行。广义后缀树可能可以，但我不会。广义后缀数组可以。然后我就开始手推广义后缀数组

　　广义后缀数组：和后缀数组类似，求出\(s_i\)的排名以及\(LCP(s_{sa_{}i-1},s_{sa_i})\)

　　实现也和后缀数组类似，倍增，把两段\(2^{i-1}\)的信息合并成\(2^i\)的信息。另外还要保存\(s_i\)的长度为\(2^j\)的前缀在所有字符串的长度为\(2^j\)的前缀中的排名。

　　求完\(sa_i\)和\(rk_i\)后，我们用二分+哈希求\(LCP(s_{sa_{i-1}},s_{sa_i})\)。上面保存下来的所有长度为\(2^j\)的前缀的排名可以当哈希值来用（考场上我写了哈希）。然后用st表来维护区间最小值。现在我们可以\(O(1)\)求出\(LCP(s_u,s_v)\)了

　　考虑以\(x\)为根的子树，若\(u,v\)在\(x\)的不同子树内，则\(LCS(s_u,s_v)=d_x-1\)。这里\(d_x\)为点\(x\)的深度，根的深度为1。

　　因为\(LCS(s_{sa_{i-1}},s_{sa_i})\geq LCS(s_{sa_x},s_{sa_y})~(x\leq i-1<i\leq y)\)，所以我们只用求出以\(rk_i\)为关键字排序后相邻两个点的\(LCP\)。这个可以用线段树维护。然后线段树合并即可。

　　时间复杂度：\(O(n\log n)\)

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
struct list
{
    int v[200010];
    int t[200010];
    int w[200010];
    int h[200010];
    int n;
    list()
    {
        n=0;
        memset(h,0,sizeof h);
    }
    void clear()
    {
        n=0;
        memset(h,0,sizeof h);
    }
    void add(int x,int y,int z)
    {
        n++;
        v[n]=y;
        t[n]=h[x];
        w[n]=z;
        h[x]=n;
    }
};
list l,l2;
int f[200010][20];
ll hs[200010][20];
int d[200010];
int e[200010];

int sa[200010];
int rk[200010];
int sx[200010];
int sy[200010];
int b[200010];

ll mod=1000000007;
ll pw[200010];
int ht[200010];
int st[200010][20];
int lo[200010];
int rt[200010];
int n;
int getmin(int x,int y)
{
    int t=lo[y-x+1];
    return min(st[x][t],st[y-(1<<t)+1][t]);
}
int query(int x,int y)
{
//  x=rk[x];
//  y=rk[y];
    if(x==y)
        return 0x3fffffff;
    if(x>y)
        swap(x,y);
    return getmin(x+1,y);
}
namespace seg
{
    struct p
    {
        int s,first,last,sz;
        p()
        {
            s=first=last=sz=0;
        }
    };
    int cnt;
    int ls[4000010];
    int rs[4000010];
    p s[4000010];
    void init()
    {
        memset(ls,0,sizeof ls);
        memset(rs,0,sizeof rs);
        cnt=0;
    }
    p mt(p a,p b)
    {
        if(!a.sz)
            return b;
        if(!b.sz)
            return a;
        p c;
        c.sz=a.sz+b.sz;
        c.first=a.first;
        c.last=b.last;
        c.s=max(max(a.s,b.s),query(a.last,b.first));
        return c;
    }
    int insert(int p,int x,int l,int r)
    {
        if(!p)
            p=++cnt;
        if(l==r)
        {
            s[p].sz=1;
            s[p].first=s[p].last=x;
            return p;
        }
        int mid=(l+r)>>1;
        if(x<=mid)
            ls[p]=insert(ls[p],x,l,mid);
        else
            rs[p]=insert(rs[p],x,mid+1,r);
        s[p]=mt(s[ls[p]],s[rs[p]]);
        return p;
    }
    int merge(int x,int y)
    {
        if(!x||!y)
            return x+y;
        ls[x]=merge(ls[x],ls[y]);
        rs[x]=merge(rs[x],rs[y]);
        s[x]=mt(s[ls[x]],s[rs[x]]);
        return x;
    }
};
int ans=0;
void solve(int x)
{
    rt[x]=seg::insert(rt[x],rk[x],1,n);
    int i;
    for(i=l.h[x];i;i=l.t[i])
    {
        solve(l.v[i]);
        rt[x]=seg::merge(rt[x],rt[l.v[i]]);
    }
    if(seg::s[rt[x]].sz>1)
        ans=max(ans,d[x]-1+seg::s[rt[x]].s);
}
int main()
{
    memset(rt,0,sizeof rt);
    seg::init();
    int i,j,x,y;
    pw[0]=311;
    for(i=1;i<=50;i++)
        pw[i]=pw[i-1]*pw[i-1]%mod;
    freopen("recollection.in","r",stdin);
    freopen("recollection.out","w",stdout);
    memset(f,0,sizeof f);
    scanf("%d",&n);
    d[1]=1;
    e[1]=310;
    hs[1][0]=310;
    for(i=2;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        l.add(x,i,y);
        f[i][0]=x;
        d[i]=d[x]+1;
        e[i]=y+1;
        hs[i][0]=e[i];
        for(j=1;j<=18;j++)
        {
            f[i][j]=f[f[i][j-1]][j-1];
            hs[i][j]=(hs[f[i][j-1]][j-1]*pw[j-1]+hs[i][j-1])%mod;
        }
    }
    int sz=310,k,o;
    for(i=1;i<=sz;i++)
        b[i]=0;
    for(i=1;i<=n;i++)
        b[sx[i]=e[i]]++;
    for(i=2;i<=sz;i++)
        b[i]+=b[i-1];
    for(i=n;i>=1;i--)
        sa[b[sx[i]]--]=i;
    for(j=1;(1<<j)<=n;j++)
    {
        l2.clear();
        k=0;
        for(i=1;i<=n;i++)
            if(d[sa[i]]>(1<<(j-1)))
                l2.add(f[sa[i]][j-1],sa[i],0);
        for(i=1;i<=n;i++)
            for(o=l2.h[sa[i]];o;o=l2.t[o])
                sy[++k]=l2.v[o];
        for(i=1;i<=n;i++)
            if(d[i]<=(1<<(j-1)))
                sy[++k]=i;
        for(i=1;i<=sz;i++)
            b[i]=0;
        for(i=1;i<=n;i++)
            b[sx[sy[i]]]++;
        for(i=2;i<=sz;i++)
            b[i]+=b[i-1];
        for(i=n;i>=1;i--)
            sa[b[sx[sy[i]]]--]=sy[i];
        k=0;
        swap(sx,sy);
        for(i=1;i<=n;i++)
            if(i!=1&&sy[sa[i]]==sy[sa[i-1]]&&((d[sa[i]]<=(1<<(j-1))&&d[sa[i-1]]<=(1<<(j-1)))||(d[sa[i]]>(1<<(j-1))&&d[sa[i-1]]>(1<<(j-1))&&sy[f[sa[i]][j-1]]==sy[f[sa[i-1]][j-1]])))
                sx[sa[i]]=k;
            else
                sx[sa[i]]=++k;
        if(k>=n)
            break;
        sz=k;
    }
    for(i=1;i<=n;i++)
        rk[sa[i]]=i;
    ht[0]=0;
    for(i=2;i<=n;i++)
    {
        x=sa[i-1];
        y=sa[i];
        int now=0;
        for(j=18;j>=0;j--)
            if(d[x]-1>=(1<<j)&&d[y]-1>=(1<<j)&&hs[x][j]==hs[y][j])
            {
                now+=(1<<j);
                x=f[x][j];
                y=f[y][j];
            }
        ht[i]=now;
    }
    for(i=1;i<=n;i++)
        st[i][0]=ht[i];
    for(j=1;j<=18;j++)
        for(i=1;i+(1<<j)-1<=n;i++)
            st[i][j]=min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
    lo[1]=0;
    for(i=2;i<=n;i++)
        lo[i]=lo[i/2]+1;
    solve(1);
    printf("%d\n",ans);
    return 0;
}

原文地址：https://www.cnblogs.com/ywwyww/p/8510713.html

时间： 2024-08-06 14:57:23

【XSY1551】往事 广义后缀数组 线段树合并的相关文章

CF666E Forensic Examination(广义后缀自动机+线段树合并)

Luogu 给你一个串 $ S $ 以及一个字符串数组 $ T_1 ~ T_m $ , $ q $ 次询问,每次问 $ S $ 的子串S[p_l,p_r]在 $ T_l ~ T_r $ 中的哪个串里的出现次数最多,并输出出现次数. 如有多解输出最靠前的那一个. 题解时间 SAM的毒瘤题,无论是倍增来满足长度限制,线段树合并来求区间询问,应有尽有... 对于 $ T $ 串建广义SAM,之后考虑如何使得 $ S $ 在SAM上匹配时求出 $ S $ 在每个 $ T $ 的出现次数. 很明显用线段树

CF.666E.Forensic Examination(广义后缀自动机 线段树合并)

题目链接 \(Description\) 给定串S和m个串Ti.Q次询问,每次询问l,r,pl,pr,求S[pl~pr]在Tl~Tr中的哪个串出现次数最多,输出最多次数及其T的下标.若有多个,输出下标最小的. \(Solution\) 挺好的题吧 对T个串建SAM,然后要求出SAM每个节点上|right|最大的是哪个串. 每个节点的|right|可以在DFS parent树时合并子节点得到,如果用线段树维护,|right|最大的位置也可以合并得到. 这样可以离线处理询问,最后DFS一遍得到答案.

HDU - 6704 K-th occurrence (后缀数组+主席树/后缀自动机+线段树合并+倍增)

题意:给你一个长度为n的字符串和m组询问,每组询问给出l,r,k,求s[l,r]的第k次出现的左端点. 解法一: 求出后缀数组,按照排名建主席树,对于每组询问二分或倍增找出主席树上所对应的的左右端点,求第k大的下标即可. 1 #include<bits/stdc++.h> 2 using namespace std; 3 typedef long long ll; 4 const int N=1e5+10,mod=998244353; 5 char buf[N]; 6 int s[N],sa[

[XSY 1551] 往事 广义后缀数组

题意 给定一棵 n 个点的树, 每条边上有字符 c . 定义 s[i] 为从 i 到根的所有字符组成的字符串. 求 $\max_{1 \le u < v \le n} [ LCP(s[u], s[v]) + LCS(s[u], s[v]) ]$ . n <= 200000 . 实现1 n log^2 n 广义后缀数组 + 启发式合并 1 #include <cstdio> 2 #include <cstring> 3 #include <cstdlib> 4

CF666E Forensic Examination（后缀自动机+线段树合并）

给你一个串S以及一个字符串数组T[1..m],q次询问,每次问S的子串S[pl..pr]在T[l..r]中的哪个串里的出现次数最多,并输出出现次数. 如有多解输出最靠前的那一个. 我们首先对m个字符串数组建出后缀自动机,然后我们可以通过跳trans边找到S前i个字符代表的前缀的最长后缀.我们要找的是S[pl..pr]并不是以pr结束最长的后缀,但我们可以确定S[pl..pr]一定是当前点的祖先所以当我们跳到pr代表的点时我们倍增往上跳知道找到一个点的长度刚好大于等于pr-pl+1,这个点就是询问

CF700E:Cool Slogans(后缀自动机,线段树合并)

Description 给你一个字符串,如果一个串包含两个不重叠的相同子串,那么这个串的价值就是子串的价值+1.问你给定字符串的最大价值子串的价值. Input 第一行读入字符串长度$n$,第二行是字符串. Output 一行答案. Sample Input1 3abc Sample Output1 1 Sample Input2 5ddddd Sample Output2 5 Sample Input3 11abracadabra Sample Output3 3 Solution 首先把后缀

bzoj 3413: 匹配 后缀自动机+线段树合并

并不是很难啊,把细节想好了再写就很轻松了~ code: #include <bits/stdc++.h> #define N 200003 #define LL long long #define setIO(s) freopen(s".in","r",stdin) ,freopen(s".out","w",stdout) using namespace std; struct SAM { int tot,last

BZOJ 1396: 识别子串( 后缀数组 + 线段树 )

这道题各位大神好像都是用后缀自动机做的?.....蒟蒻就秀秀智商写一写后缀数组解法..... 求出Height数组后, 我们枚举每一位当做子串的开头. 如上图(x, y是height值), Heights数组中相邻的3个后缀, 假如我们枚举s2的第一个字符为开头, 那我们发现, 长度至少为len = max(x, y)+1, 才能满足题意(仅出现一次). 这个很好脑补...因为s2和其他串的LCP是RMQ, 肯定会<=LCP(s1,s2)或<=LCP(s2,s3). 然后就用len去更新s2中

CF1037H Security 后缀自动机 + right集合线段树合并 + 贪心

后缀自动机 + 线段树合并的裸题. 我这种大菜逼都秒切的题目,一定是送分题. #include<bits/stdc++.h> #define setIO(s) freopen(s".in","r",stdin) #define maxn 220000 using namespace std; int n; int rt[maxn]; namespace tr { #define mid ((l+r)>>1) #define lson t[x]