后缀数组学习笔记

于 2016-07-31 13:01:22 发布
阅读量414 收藏 1
点赞数
分类专栏： 后缀数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/morejarphone/article/details/52078088
版权

要用好后缀数组要先理解里面几个数组的概念:
sa[i] 表示字典序第i大的后缀下标(字典序排名依次是 1−len(string) );
rank[i] 表示下标为i的后缀字典序排名;
height[i] 表示 sa[i] 和 sa[i−1] 最长公共前缀的长度.

一个性质:

LCP(suffix[i],suffix[j])=min{height[i+1],height[i+2]…height[j]}(rank[i]<rank[j])

倍增法求出这些数组, 记得在原串的末尾增加一个0:

int t1[maxn],t2[maxn],c[maxn];
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0; i < m; i++)c[i] = 0;
    for(i = 0; i < n; i++)c[x[i] = str[i]]++;
    for(i = 1; i < m; i++)c[i] += c[i-1];
    for(i = n-1; i >= 0; i--)sa[--c[x[i]]] = i;
    for(j = 1; j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        for(i = 0; i < m; i++)c[i] = 0;
        for(i = 0; i < n; i++)c[x[y[i]]]++;
        for(i = 1; i < m; i++)c[i] += c[i-1];
        for(i = n-1; i >= 0; i--)sa[--c[x[y[i]]]] = y[i];
        //根据sa和x数组计算新的x数组
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for(i = 1; i < n; i++)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0; i <= n; i++)rank[sa[i]] = i;
    for(i = 0; i < n; i++)
    {
        if(k)   k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])
            k++;
        height[rank[i]] = k;
    }
}

POJ 1743 最长不重叠相同子串
题意: 求两个最长的不重叠子串, 满足两个串对应下标的差值相等.
对于相邻的两个数直接做差得到一个新串, 直接对新串求最长不重叠子串. 非常经典的做法, 二分长度, 然后对height数组分组, 满足这个长度的分成一组, 然后判断组中下标最大最小之差.
数据很水~

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#define maxn 20005
using namespace std;
int t1[maxn],t2[maxn],c[maxn];
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0; i < m; i++)c[i] = 0;
    for(i = 0; i < n; i++)c[x[i] = str[i]]++;
    for(i = 1; i < m; i++)c[i] += c[i-1];
    for(i = n-1; i >= 0; i--)sa[--c[x[i]]] = i;
    for(j = 1; j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        for(i = 0; i < m; i++)c[i] = 0;
        for(i = 0; i < n; i++)c[x[y[i]]]++;
        for(i = 1; i < m; i++)c[i] += c[i-1];
        for(i = n-1; i >= 0; i--)sa[--c[x[y[i]]]] = y[i];
        //根据sa和x数组计算新的x数组
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for(i = 1; i < n; i++)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0; i <= n; i++)rank[sa[i]] = i;
    for(i = 0; i < n; i++)
    {
        if(k)   k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])
            k++;
        height[rank[i]] = k;
    }
}
int rank[maxn], height[maxn];
int str[maxn];
int sa[maxn];
int n;
#define INF 111111

bool ok (int x) {
    int Min = INF, Max = 0;
    for (int i = 1; i <= n; i++) {
        if (height[i] >= x) {
            Min = min (Min, sa[i]);
            Max = max (Max, sa[i]);
        }
        else {
            if (Max-Min >= x)
                return 1;
            Max = sa[i];
            Min = sa[i];
        }
    }
    return Max-Min >= x;
}

int solve () {
    int l = 0, r = n/2;
    while (r-l > 1) {
        int mid = (r+l)>>1;
        if (ok (mid)) l = mid;
        else r = mid;
    }
    return (ok (r) ? r : l);
}

int main(){
    while (scanf ("%d", &n) == 1 && n) {
        for (int i = 0; i < n; i++) {
            scanf ("%d", &str[i]);
        }
        if (n <= 9) {
            printf ("0\n");
            continue;
        }
        n--;
        for (int i = 0; i < n; i++) {
            str[i] = 100+str[i+1]-str[i];
        }
        str[n] = 0;
        da(str, sa, rank, height, n+1, 188);
        int ans = solve ()+1;
        printf ("%d\n", (ans >= 5 ? ans : 0));
    }
    return 0;
}

POJ 3261 求重复k次的最长子串
还是二分结果, 按照height分组, 判断是不是有大于k的组.
数据还是很水, 不加离散化都能过~

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#define maxn 200005
using namespace std;
int t1[maxn],t2[maxn],c[maxn];
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0; i < m; i++)c[i] = 0;
    for(i = 0; i < n; i++)c[x[i] = str[i]]++;
    for(i = 1; i < m; i++)c[i] += c[i-1];
    for(i = n-1; i >= 0; i--)sa[--c[x[i]]] = i;
    for(j = 1; j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        for(i = 0; i < m; i++)c[i] = 0;
        for(i = 0; i < n; i++)c[x[y[i]]]++;
        for(i = 1; i < m; i++)c[i] += c[i-1];
        for(i = n-1; i >= 0; i--)sa[--c[x[y[i]]]] = y[i];
        //根据sa和x数组计算新的x数组
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for(i = 1; i < n; i++)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0; i <= n; i++)rank[sa[i]] = i;
    for(i = 0; i < n; i++)
    {
        if(k)   k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])
            k++;
        height[rank[i]] = k;
    }
}
int rank[maxn], height[maxn];
int str[maxn];
int sa[maxn];
int n, k;

bool ok (int x) {
    int ans = 1;
    for (int i = 2; i <= n; i++) {
        if (height[i] >= x) {
            ans++;
            if (ans >= k)
                return 1;
        }
        else
            ans = 1;
    }
    return 0;
}

int solve () {
    int l = 0, r = n;
    while (r-l > 1) {
        int mid = (l+r) >>1;
        if (ok (mid)) l = mid;
        else r=  mid;
    }
    return (ok (r) ? r : l);
}


int cnt, num[maxn], gg[maxn];
int lisanhua () {
    cnt = 0;
    for (int i = 0; i < n; i++) num[i] = i;
    sort (num, num+n);
    for (int i = 0; i < n; i++) if (!i || num[i] != num[i-1])
        gg[cnt++] = num[i];
    for (int i = 0; i < n; i++)
        str[i] = lower_bound (gg, gg+cnt, str[i])-gg+1;
    return cnt+1;
}

int main(){
    while (cin >> n >> k) {
        int Max = 0;
        for (int i = 0; i < n; i++) {
            cin >> str[i];
            Max = max (Max, str[i]);
        }
        str[n] = 0;
        int m = lisanhua ();
        da (str, sa, rank, height, n, m+2);
        int ans = solve ();
        cout << ans << endl;
    }
    return 0;
}
/*
2 2
1 1
*/

SPOJ 694 不重复子串个数
根据 sa 数组和 height 数组的含义, sa[i] 后缀总共有 n−sa[i] 个前缀, 有 height[i] 个前缀和之前的重复, 所以要减去. 最后答案是 ∑ni=1n−sa[i]−height[i] .

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#define maxn 200005
using namespace std;
int t1[maxn],t2[maxn],c[maxn];
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0; i < m; i++)c[i] = 0;
    for(i = 0; i < n; i++)c[x[i] = str[i]]++;
    for(i = 1; i < m; i++)c[i] += c[i-1];
    for(i = n-1; i >= 0; i--)sa[--c[x[i]]] = i;
    for(j = 1; j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        for(i = 0; i < m; i++)c[i] = 0;
        for(i = 0; i < n; i++)c[x[y[i]]]++;
        for(i = 1; i < m; i++)c[i] += c[i-1];
        for(i = n-1; i >= 0; i--)sa[--c[x[y[i]]]] = y[i];
        //根据sa和x数组计算新的x数组
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for(i = 1; i < n; i++)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0; i <= n; i++)rank[sa[i]] = i;
    for(i = 0; i < n; i++)
    {
        if(k)   k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])
            k++;
        height[rank[i]] = k;
    }
}
int rank[maxn], height[maxn];
int str[maxn];
char s[maxn];
int sa[maxn];
int n, k;

int main(){
    ios::sync_with_stdio(0);
    int t;
    cin >> t;
    while (t--) {
        cin >> s;
        n = strlen (s);
        for (int i = 0; i < n; i++) str[i] = s[i];
        str[n] = 0;
        da (str, sa, rank, height, n, 233);
        long long ans = 0;
        for (int i = 1; i <= n; i++) {
            ans += n-sa[i]-height[i];
        }
        cout << ans << endl;
    }
    return 0;
}

POJ 2774 最长公共子串
把第二个串放到第一个串的后面, 中间用一个失配符隔开, 然后遍历height数组维护最大子串长度. 要避免出现在同一串中的公共子串.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#define maxn 200005
using namespace std;
int t1[maxn],t2[maxn],c[maxn];
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0; i < m; i++)c[i] = 0;
    for(i = 0; i < n; i++)c[x[i] = str[i]]++;
    for(i = 1; i < m; i++)c[i] += c[i-1];
    for(i = n-1; i >= 0; i--)sa[--c[x[i]]] = i;
    for(j = 1; j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        for(i = 0; i < m; i++)c[i] = 0;
        for(i = 0; i < n; i++)c[x[y[i]]]++;
        for(i = 1; i < m; i++)c[i] += c[i-1];
        for(i = n-1; i >= 0; i--)sa[--c[x[y[i]]]] = y[i];
        //根据sa和x数组计算新的x数组
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for(i = 1; i < n; i++)
            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0; i <= n; i++)rank[sa[i]] = i;
    for(i = 0; i < n; i++)
    {
        if(k)   k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])
            k++;
        height[rank[i]] = k;
    }
}
int rank[maxn], height[maxn];
int str[maxn];
char s1[maxn], s2[maxn];
int sa[maxn];
int n, m, len;

bool legal (int i, int j) {
    if (i > j) swap (i, j);
    return (i < n && j > n);
}

void solve () {
    int Max = 0;
    for (int i = 2; i <= len; i++) {
        if (height[i] >= Max && legal (sa[i], sa[i-1]))
            Max = height[i];
    } 
    cout << Max << endl;
}

int main(){
    ios::sync_with_stdio(0);
    while (cin >> s1 >> s2) {
        n = strlen (s1), m = strlen (s2);
        for (int i = 0; i < n; i++) str[i] = s1[i];
        str[n] = 1;
        for (int i = n+1; i <= n+m; i++) str[i] = s2[i-n-1];
        len = n+m+1;
        str[len] = 0;
        da (str, sa, rank, height, len, 233);
        solve ();
    }
    return 0;
}
morejarphone
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后缀数组学习笔记！！！
04-28
容我多说几句，让更多人看到我的资源 推荐格式：内容概要+适用人群+使用场景及目标+其他说明
后缀数组 学习笔记
glorious_dream的博客
09-15 436
后缀数组学习笔记
后缀数组详解
08-26
非常详细的后缀数组讲解~~~既看既懂
11.罗穗骞《后缀数组——处理字符串的有力工具》.zip
08-08
罗穗骞《后缀数组——处理字符串的有力工具》(有算法源码和解题源码) IOI2009论文，有源码，简单易懂，方便学习后缀数组的构造和各种应用。 后缀数组是一种优秀的数据结构，在字符串匹配方面有诸多应用。
后缀数组1
08-03
【摘要】本文介绍后缀数组的基本概念、方法以及应用。首先介绍 O(nlogn)复杂度构造后缀数组的倍增算法，接着介绍了配合后缀数组的最长公共前缀 LCP（Long
Java后缀数组之求sa数组的实例代码
08-27
后缀数组就是一个字符串所有后缀大小排序后的一个集合，然后我们根据后缀数组的一些性质就可以实现各种需求。这篇文章主要介绍了Java后缀数组-求sa数组,需要的朋友可以参考下
2024年全球嵌入式配电盘行业总体规模、主要企业国内外市场占有率及排名.docx
04-15
2024年全球嵌入式配电盘行业总体规模、主要企业国内外市场占有率及排名
AccessControl-6.3-cp39-cp39-manylinux_2_17_aarch64.whl.zip
04-15
AccessControl-6.3-cp39-cp39-manylinux_2_17_aarch64.whl.zip
AccessControl-6.0-cp37-cp37m-manylinux_2_5_x86_64.whl.zip
04-15
AccessControl-6.0-cp37-cp37m-manylinux_2_5_x86_64.whl.zip
【Python-WEB自动化-06课-对验证码的处理】
最新发布
04-15
【Python-WEB自动化-06课-对验证码的处理】
AccessControl-5.4-cp38-cp38-manylinux_2_17_aarch64.whl.zip
04-15
AccessControl-5.4-cp38-cp38-manylinux_2_17_aarch64.whl.zip
AX3_Mercadopago-0.2.4-py3-none-any.whl.zip
04-15
AX3_Mercadopago-0.2.4-py3-none-any.whl.zip
Acquisition-4.12-cp37-cp37m-manylinux_2_17_aarch64.whl.zip
04-15
Acquisition-4.12-cp37-cp37m-manylinux_2_17_aarch64.whl.zip
AXX_AIAPI-1.2.0-py3-none-any.whl.zip
04-15
AXX_AIAPI-1.2.0-py3-none-any.whl.zip
一款高效的数据库连接工具，支持多种数据库类型，简洁易用的界面，帮助用户轻松管理和操作数据库，提高工作效率
04-15
一款高效的数据库连接工具，支持多种数据库类型，简洁易用的界面，帮助用户轻松管理和操作数据库，提高工作效率
OPENCV目标跟踪车辆检测和跟踪绘制车辆的轨迹opencv
04-15
OPENCV目标跟踪车辆检测和跟踪，绘制车辆的轨迹opencv提取方式是百度网盘分享地址
4-3 TCP的连接管理.pka
04-15
4-3 TCP的连接管理.pka
ANSYS帮助文档Advanced Analysis Guide
04-15
ANSYS帮助文档、ANSYS操作帮助、APDL教程、APDL操作指南
后缀数组 python
11-21
抱歉，Python标准库中没有后缀数组的实现。不过，你可以使用第三方库PyPi中的suffix_array来实现后缀数组。安装方法如下： ```shell pip install suffix-array ``` 下面是一个简单的示例代码，展示如何使用suffix_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值