码迷,mamicode.com
首页 > 编程语言 > 详细

hdu6704 后缀数组+主席树+ST +二分

时间:2019-08-31 16:53:30      阅读:99      评论:0      收藏:0      [点我收藏+]

标签:break   sum   历史   space   输入长度   hdu   长度   sizeof   连续   

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6704

推荐博客:https://www.cnblogs.com/1625--H/p/11403199.html

题意:输入t,接下来t组数据,每组数据输入n和q,n代表字符串长度,q代表查询次数,接下来一行输入长度为n的字符串,最后再输入q行查询,每一个查询有l,r,k,查询字符串中在区间[l,r]里的这个子串第k次出现的位置,位置就是出现这个子串的首字母位置,如果没有第k次,则输出-1。

比赛时我也没写出来,补题。

思路:我讲的可能不是很清楚,可以看上面的推荐博客。

区间[l,r]的子串在位置为l的后缀中是一定出现了的,并且是这个后缀的一个前缀,而要找到其他出现这个子串的位置,我们可以用后缀数组,先用后缀数组先把原串所有的后缀进行排序,即求出sa数组,其中出现这个子串的后缀肯定都是连续的,因为它都是这些连续后缀的前缀,这里我们可以先求出后缀数组中的height[i]数组,i是排位,height[i]代表排位为i的后缀和排位为i-1的后缀之间的最长公共前缀(LCP),我们以位置为l的后缀的排位x[l]为中心,向左右两边分别找最后一个和位置为l的后缀之间LCP>=r-l+1的后缀,得到两个后缀的排位(假设分别是L和R),那么在排位区间[L,R]中出现的所有后缀的前缀都包含着我们要查询的子串,这个过程可以用二分来实现。我们要找其中出现的第k个,实际上就只需要寻找这个排位区间中的位置第k大,这个我们可以用静态主席树做到。

代码:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<stack>
#include<cmath>
#include<vector>
#include<set>
#include<cstdio>
#include<string>
#include<deque> 
using namespace std;
typedef long long LL;
#define eps 1e-8
#define INF 0x3f3f3f3f
#define maxn 100005
int sa[maxn],height[maxn],x[maxn],y[maxn],c[maxn];
//这里x数组对应于rank数组,但是我个人习惯写x了 
int n,m,k,t,q,cnt;
char s[maxn]; 
int dp[maxn][20],root[maxn];
struct node{//静态主席树也是用结构体写的 
    int l,r,sum;
}tree[maxn<<6];
void getHeight(){//height数字下标表示排位,值表示排位为i的后缀和排位为i-1的后缀的LCP
                //H数组下标表示位置,H[i]=height[x[i]],有H[i]>=H[i-1]-1 
    int k=0; 
    for(int i=1;i<=n;i++) x[sa[i]]=i;
    for(int i=1;i<=n;i++){
        if(k) k--;
        int j=sa[x[i]-1];//找到位置在i的关键字的前一个排位的关键字 
        while(s[i+k]==s[j+k]&&(i+k)<=n&&(j+k)<=n) k++;
        height[x[i]]=k;
    } 
}
void build_sa(){//好久没写这个了,所以写的时候加了很多注释,就当梳理思路,复习了 
    m=256;
    for(int i=1;i<=m;i++) c[i]=0;
    for(int i=1;i<=n;i++) c[x[i]=s[i]]++;//x数组下标表示位置,值表示排位 
    for(int i=1;i<=m;i++) c[i]+=c[i-1];
    for(int i=n;i>=1;i--) sa[c[x[i]]--]=i;//sa数组下标表示排位,值表示第一关键字的位置 
    for(int k=1;k<n;k<<=1){
        int num=0;
        for(int i=n-k+1;i<=n;i++) y[++num]=i;//y数组下标表示第二关键字排位,值表示对应的第一关键字的位置
        // 有部分第一关键字没有第二关键字,这里把它们的第二关键字补‘0‘,按照出现顺序排序 
        for(int i=1;i<=n;i++){//按照关键字排位从小到大来遍历第一关键字 
            if(sa[i]>k)//排位为i的第一关键字位置如果大于k,则说明这个关键字可以作为另一个关键字的第二关键字 
            y[++num]=sa[i]-k;// 这个关键字作为第二关键字的话,它所对应的第一关键字的位置就是sa[i]-k 
        }
        
        //上面已经求出了排位为i的第一关键字和第二关键字的对应的位置,下面开始对第一关键字和对应的第二关键字进行合并
        //并求出合并之后的关键字对应的sa数组,下标表示排位,值表示位置 
        for(int i=1;i<=m;i++) c[i]=0;
        for(int i=1;i<=n;i++) c[x[i]]++;
        for(int i=1;i<=m;i++) c[i]+=c[i-1];
        //我们这里i从大到小,在第一关键字不同时,这里的y[i]没有什么影响,但是在第一关键字相同时,第二关键字
        //更大的关键字会先出现,从而获得更大的位置,这就保证了先比较第一关键字,相同时比较第二关键字 
        for(int i=n;i>=1;i--) sa[c[x[y[i]]]--]=y[i];
        
        swap(x,y);//接下来我们要求出合并之后关键字的x数组,下标表示位置,值表示排位,所以我们把x数组的值复制到y数组 
        num=1;
        x[sa[1]]=1; 
        for(int i=2;i<=n;i++)//按照排位从小到大的顺序遍历y数组 
        x[sa[i]]=y[sa[i]]==y[sa[i-1]]&&y[sa[i]+k]==y[sa[i-1]+k]?num:++num;
        m=num;
        if(m>=n) break; 
    }
}
void ST(){
    for(int i=1;i<=n;i++)
    dp[i][0]=height[i];//i代表的是排位 
    for(int j=1;(1<<j)<=n;j++){
        for(int i=1;i+(1<<j)-1<=n;i++){
            int a=dp[i][j-1];
            int b=dp[i+(1<<(j-1))][j-1];
            dp[i][j]=min(a,b);
        }
    }
}
void init(){
    memset(root,0,sizeof(root));
    memset(height,0,sizeof(height)); 
    memset(dp,0,sizeof(dp));
    cnt=0;
}
void build_0(int &root,int l,int r){
    root=++cnt;         
    tree[root].sum=0;//在这个位置卡了一天,把他写在下面了,并且这个函数中没有向上更新 
    if(l==r){
        return;
    }
    int mid=(l+r)/2;
    build_0(tree[root].l,l,mid);
    build_0(tree[root].r,mid+1,r);
}
void update(int root){
    tree[root].sum=tree[tree[root].l].sum+tree[tree[root].r].sum;
}
void build(int pre,int &root,int l,int r,int index){
    root=++cnt;
    tree[root]=tree[pre];
    if(l==r){
        tree[root].sum=1;
        return;
    }
    int mid=(l+r)/2;
    if(index<=mid)
    build(tree[pre].l,tree[root].l,l,mid,index);
    else
    build(tree[pre].r,tree[root].r,mid+1,r,index);
    update(root);
}
int RMQ(int l,int r){//这里写的有点麻烦,这里的l和r已经是后缀的排位了 
    if(l>r) swap(l,r);
    if(l==r) return n-sa[l]+1;//l==r一定满足条件,因为就是位置为l的后缀,这里返回INF也是可以的 
    l++;//这里需要l++,因为考虑到height[i]的定义
        //当我们要查询排位在区间[l,r]之间的后缀,它们两两相邻的LCP最小值,l需要++,
        //因为height[l]是排位为l的后缀和排位为l-1的后缀的LCP
        //这里我们是不需要height[l]的,只需要height[l+1]到height[r] 
    int k=0;
    while((1<<(k+1))<=r-l+1) k++;
    int a=dp[l][k];
    int b=dp[r-(1<<k)+1][k];
    return min(a,b);
}
int find_L(int l,int r,int len){
    int R=r;
    int pre=r;//其实还是不怎么会二分的,写成这个方式比较保险 
    while(l<=r){
        int mid=(l+r)/2;
        if(RMQ(mid,R)>=len){
            pre=mid;
            r=mid-1;
        }
        else
        l=mid+1;
    }
    return pre;
}
int find_R(int l,int r,int len){
    int L=l;
    int pre=l;
    while(l<=r){
        int mid=(l+r)/2;
        if(RMQ(L,mid)>=len){
            pre=mid;
            l=mid+1;
        }
        else
        r=mid-1; 
    }
    return pre;
}
int ask(int pre,int root,int l,int r,int k){
    if(tree[root].sum-tree[pre].sum<k) return -1;
    if(l==r){
        return l;
    }
    int mid=(l+r)/2;
    if(tree[tree[root].l].sum-tree[tree[pre].l].sum>=k)
    return ask(tree[pre].l,tree[root].l,l,mid,k);
    else
    return ask(tree[pre].r,tree[root].r,mid+1,r,k-(tree[tree[root].l].sum-tree[tree[pre].l].sum));
}
int main()
{
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&q);
        init();
        scanf("%s",s+1);
        build_sa();
        getHeight();
        build_0(root[0],1,n);//第0个版本的线段树,我这里直接写build_0了,个人习惯了 
        for(int i=1;i<=n;i++)//其他版本的线段树 
        build(root[i-1],root[i],1,n,sa[i]);
        ST();
        int l,r;
        while(q--){
            scanf("%d%d%d",&l,&r,&k);
            int len=r-l+1;//相邻p排位两个后缀的LCP最小要是len 
            int L=find_L(1,x[l],len);//二分找左边界 
            int R=find_R(x[l],n,len);//二分找右边界 
            LL ans;
            if(R-L+1<k) ans=-1;
            else ans=ask(root[L-1],root[R],1,n,k);//两个历史版本的线段树中查询第k大的位置 
            printf("%lld\n",ans);      
        }
    }
    return 0;
}

 

hdu6704 后缀数组+主席树+ST +二分

标签:break   sum   历史   space   输入长度   hdu   长度   sizeof   连续   

原文地址:https://www.cnblogs.com/6262369sss/p/11439511.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!