SPOJ 694&705 后缀数组

点击打开链接

题意:问一个串的子串可以有多少种,就是将重复的去掉

思路:每个子串一定是某个后缀的前缀,对于某个后缀sa来说,它的最长前缀就是重复的个数,那么减去就好,而最长前缀可以通过后缀数组的sa数组线性求出

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1010;
int n,k,cnt;
int rank1[maxn],sa[maxn],tmp[maxn],lcp[maxn];
char str[maxn];
bool compare_sa(int i,int j){
    if(rank1[i]!=rank1[j]) return rank1[i]<rank1[j];
    else{
        int ri=i+k<=n? rank1[i+k]:-1;
        int rj=j+k<=n? rank1[j+k]:-1;
        return ri<rj;
    }
}
void construct_sa(){
    for(int i=0;i<=n;i++){
        sa[i]=i;
        rank1[i]=i<n? str[i]:-1;
    }
    for(k=1;k<=n;k*=2){
        sort(sa,sa+n+1,compare_sa);
        tmp[sa[0]]=0;
        for(int i=1;i<=n;i++){
            tmp[sa[i]]=tmp[sa[i-1]]+(compare_sa(sa[i-1],sa[i])?1:0);
        }
        for(int i=0;i<=n;i++) rank1[i]=tmp[i];
    }
}
void construct_lcp(){
    for(int i=0;i<=n;i++) rank1[sa[i]]=i;
    int h=0;
    lcp[0]=0;
    for(int i=0;i<n;i++){
        int j=sa[rank1[i]-1];
        if(h>0) h--;
        for(;j+h<n&&i+h<n;h++) if(str[i+h]!=str[j+h]) break;
        lcp[rank1[i]-1]=h;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%s",str);
        n=strlen(str);
        int ans=(n+1)*n/2;
        cnt=0;
        construct_sa();
        construct_lcp();
        for(int i=0;i<n;i++) cnt+=lcp[i];
        printf("%d\n",ans-cnt);
    }
    return 0;
}

705:题意一样,只是数据范围不一样,真的不知道出题人怎么想的,居然卡了我上边的快排的时间,好嘛交上去TLE,非要写这个长的代码才可以过,醉的透透的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int MAXN=50010;
int wa[MAXN],wb[MAXN],wv[MAXN],ww[MAXN];
int sa[MAXN],lcp[MAXN],Rank[MAXN],rank1[MAXN];
char str[MAXN];
 inline bool cmp(int *r,int a,int b,int len)
 {
     return r[a]==r[b]&&r[a+len]==r[b+len];
 }
 void construct_sa(int n,int m)
 {
     int i,j,p,*x=wa,*y=wb,*t;
     for(i=0;i<m;i++)
         ww[i]=0;
     for(i=0;i<n;i++)
         ww[x[i]=str[i]]++;
     for(i=1;i<m;i++)
         ww[i]+=ww[i-1];
     for(i=n-1;i>=0;i--)
         sa[--ww[x[i]]]=i;
     for(j=p=1;p<n;j<<=1,m=p)
     {
         for(p=0,i=n-j;i<n;i++)
            y[p++]=i;
         for(i=0;i<n;i++)
         {
             if(sa[i]>=j)
                 y[p++]=sa[i]-j;
         }
         for(i=0;i<m;i++)
             ww[i]=0;
         for(i=0;i<n;i++)
             ww[wv[i]=x[y[i]]]++;
         for(i=1;i<m;i++)
             ww[i]+=ww[i-1];
         for(i=n-1;i>=0;i--)
             sa[--ww[wv[i]]]=y[i];
         for(t=x,x=y,y=t,x[sa[0]]=0,p=i=1;i<n;i++)
             x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
     }
}
void construct_lcp(int n){
    for(int i=0;i<=n;i++) rank1[sa[i]]=i;
    int h=0;
    lcp[0]=0;
    for(int i=0;i<n;i++){
        int j=sa[rank1[i]-1];
        if(h>0) h--;
        for(;j+h<n&&i+h<n;h++) if(str[i+h]!=str[j+h]) break;
        lcp[rank1[i]-1]=h;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%s",str);
        int n=strlen(str);
        int ans=0;
        construct_sa(n+1,256);
        construct_lcp(n);
        for(int i=0;i<=n;i++) ans=ans+n-sa[i]-lcp[i];
        printf("%d\n",ans);
    }
    return 0;
}
时间: 2024-11-06 03:52:46

SPOJ 694&705 后缀数组的相关文章

SPOJ 694 705 后缀数组

后缀数组求不同子序列数量的简单题. 对于一个已经处理好的后缀数组,对于每一个suffix(i),必然会产生len - sa[i]个前缀(假设从0开始), 然后这len - sa[i]个前缀里面有height[i]个是和前面那个前缀相同的,所以是len - sa[i] - height[i]个,求一下和就好.. #include <cstdio> #include <cstring> #include <algorithm> #include <queue>

SPOJ 694、705 后缀数组:求不同子串

思路:这题和wikioi 1306一样,也都是求的不同子串的个数,但是wikioi 时间比较长,然后用Trie树就过了.但是我用那个代码提交这题的时候就WA了,比较晕--因为这题有多组样例,所以超了点时间. 所以这题当然就是用后缀数组做的啦! 算法分析: 每个子串一定是某个后缀的前缀,那么原问题等价于求所有后缀之间的不相同的前缀的个数.如果所有的后缀按照suffix(sa[1]),suffix(sa[2]),suffix(sa[3]),--,suffix(sa[n])的顺序计算,不难发现,对于每

SPOJ 694 || 705 Distinct Substrings ( 后缀数组 &amp;&amp; 不同子串的个数 )

题意 : 对于给出的串,输出其不同长度的子串的种类数 分析 : 有一个事实就是每一个子串必定是某一个后缀的前缀,换句话说就是每一个后缀的的每一个前缀都代表着一个子串,那么如何在这么多子串or后缀的前缀中找出不同的并计数呢?思路就是所有的可能子串数 - 重复的子串数.首先我们容易得到一个长度为 len 的串的子串数为 len * ( len + 1) / 2.那如何知道重复的子串数呢?答案就是利用后缀数组去跑一遍 Height ,得到所有的最长公共前缀(LCP),这些最长公共前缀的值都存在了 He

spoj Distinct Substrings 后缀数组

给定一个字符串,求不相同的子串的个数. 假如给字符串“ABA";排列的子串可能: A B A AB  BA ABA 共3*(3+1)/2=6种; 后缀数组表示时: A ABA BA 对于A和AB height[i]=1; 表明一个长度公共,所以ABA中多出现了A这个子串,所以6-1=5: 对于ABA BA height[i]=0,所以不需要减去. 最后答案为5: #include<iostream> #include<stdio.h> #include<string

Lexicographical Substring Search SPOJ - SUBLEX (后缀数组)

Lexicographical Substrings Search \[ Time Limit: 149 ms \quad Memory Limit: 1572864 kB \] 题意 给出一个字符串,求出这个字符串上字典序第 \(k\) 小的子串. 思路 对于给出的字符串,求出后缀数组,根据后缀数组的 \(height\) 数组,我们可以很容易得到一个字符的总子串个数是 \(\sum_{i=1}^{n} (n-sa[i]+1+height[i])\),利用这个式子,就可以求出第 \(k\) 小

SPOJ - REPEATS Repeats (后缀数组)

A string s is called an (k,l)-repeat if s is obtained by concatenating k>=1 times some seed string t with length l>=1. For example, the string s = abaabaabaaba is a (4,3)-repeat with t = aba as its seed string. That is, the seed string t is 3 charac

SPOJ Repeats(后缀数组+RMQ)

REPEATS - Repeats no tags A string s is called an (k,l)-repeat if s is obtained by concatenating k>=1 times some seed string t with length l>=1. For example, the string s = abaabaabaaba is a (4,3)-repeat with t = aba as its seed string. That is, the

SPOJ 687. Repeats(后缀数组求最长重复子串)

题目大意:给你一个串让你求出重复次数最多的连续重复子串的重复次数. 解题思路:论文上给出的解答是: 这还没完,因为经过这两个点的情况还不完备,应还可以假设起点在 [ i*j-i+1, i*j-d],其中 d = i-L/i (d = i-L%i)其意义为根据已知的匹配长度,可以将起点往前移动的范围,太靠后将不能够构造出比之前更好的解.如果要求出某个最多的连续重复子串的最小字典序子需要枚举所有起点,但如果只是要的到最多的重复次数或者任意最多的连续重复子串,那么只需要枚举i*j-d处的起点即可,因为

SPOJ 687 Repeats 后缀数组

和上一题差不多的方法..没什么好说的 #include <cstdio> #include <cstring> #include <algorithm> using namespace std; const int maxn = (5e4 + 10) * 4; #define F(x) ((x) / 3 + ((x) % 3 == 1 ? 0 : tb)) #define G(x) ((x) < tb ? (x) * 3 + 1 : ((x) - tb) * 3