后缀数组（SA）倍增法总结

最新推荐文章于 2022-04-08 11:49:40 发布
最新推荐文章于 2022-04-08 11:49:40 发布
阅读量417 收藏 1
点赞数
文章标签： 字符串 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clever_Hard/article/details/111467501
版权

前言

听老师讲之前听说是字符串，比较虚（因为一直认为这东西很抽象）。。听后才发现只要认真听还是不难的。。

引入

读入一个长度为 n n n 的由大小写英文字母或数字组成的字符串，请把这个字符串的所有非空后缀按字典序从小到大排序，然后按顺序输出后缀的第一个字符在原串中的位置。位置编号为 1 1 1 到 n n n。

思路

法一：暴力 O ( n 2 l o g 2 ( n ) ) O(n^2log_2(n)) O(n2log2​(n))。
法二：在 s o r t sort sort 中用二分+Hash， O ( n l o g 2 ( n ) ) O(nlog^2(n)) O(nlog2(n))。
法三：SA。

正题

定义 s a [ i ] sa[i] sa[i] 为排名为 i i i 的后缀的起始位置的下标。

试想一下，我们怎么判断两个字符串谁大谁小？我们可以从最小位比起，将字典序高的放在前面，若前面的这一位 < 后面的这一位，则调换两个串。

我们每次比第 k k k 个位，可以用这个规则不断更新 s a [ i ] sa[i] sa[i]：将第 k k k 位设为第一关键字，则现在已经比好了 k k k 位之后的。将所有的第 k k k 位放进一个桶里，用基数排序的思想将这些进行排序，若第 k k k 位相等则比较第二关键字。那没有第 k k k 位怎么办呢（也可以理解为缺少第二关键字），我们就看成第二关键字为空，时间为 O ( n 2 ) O(n^2) O(n2)。

这时需要用 倍增 的思想优化。我们不用一位一位地设为第一关键字比，而是 k k k 位 k k k 位地设为关键字，每次 k < < = 1 k<<=1 k<<=1。将第一关键字放桶时，利用上一次算出来的 k k k 位后缀的大小关系，排好 2 k 2k 2k 长度的后缀，就一直这样重复即可。

代码

注: H e i g h t [ i ] Height[i] Height[i] 为以 i i i 开头的后缀与 排名为 k − 1 k-1 k−1 的后缀最大公共前缀（ k k k 为 i i i 的排名）。其中有一个性质： H e i g h t [ i ] > = H e i g h t [ i − 1 ] − 1 Height[i] >= Height[i-1]-1 Height[i]>=Height[i−1]−1。利用这个性质，就可以用 O ( n ) O(n) O(n) 的时间解决这个问题。

总时间复杂度： O ( n l o g 2 ( n ) ) O(nlog_2(n)) O(nlog2​(n))。

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <climits>
#include <iostream>
using namespace std;
const int MAXN = 3e5 + 5;
int n, c[MAXN], m = 200, hs[MAXN], sa[MAXN], tmp[MAXN], t[MAXN];
int Height[MAXN], mp[MAXN];
char s[MAXN];
//sa:当前排的顺序
//tmp:过渡序列
//hs:即 hash, 映射值
//c:统计个数 
void write(int x) {
	if(x < 0) x = -x, putchar('-');
    if(x <= 9) {
        putchar(x + '0');
        return;
    }
    write(x / 10); putchar(x % 10 + '0');
}
void Clac_SA() {
	for(int i = 1; i <= n; i ++) hs[i] = s[i], c[hs[i]] ++;
	for(int i = 1; i <= m; i ++) c[i] += c[i - 1];
	for(int i = n; i >= 1; i --) sa[c[hs[i]] --] = i; // 排好第一轮 
	for(int i = 1; i <= n; i <<= 1) {
		int num = 0;
		for(int j = n - i + 1; j <= n; j ++) tmp[++ num] = j;
		for(int j = 1; j <= n; j ++) if(sa[j] > i) tmp[++ num] = sa[j] - i;// 转换为新的序列 (以第二关键字排序)
		for(int j = 1; j <= m; j ++) c[j] = 0;
		for(int j = 1; j <= n; j ++) c[hs[j]] ++;
		for(int j = 2; j <= m; j ++) c[j] += c[j - 1];
		for(int j = n; j >= 1; j --) sa[c[hs[tmp[j]]] --] = tmp[j];//注意要倒序 
		for(int j = 1; j <= n; j ++) t[j] = hs[j];
		hs[sa[1]] = 1; num = 1;
		for(int j = 2; j <= n; j ++) hs[sa[j]] = hs[sa[j - 1]] + (!((t[sa[j]] == t[sa[j - 1]]) & (t[sa[j] + i] == t[sa[j - 1] + i])));
		num = hs[sa[n]];
		if(num == n) break; // 可加可不加
		m = num; 
	}
}
int Max(int x, int y) { return x > y ? x : y; }
void Clac_Height() {// 利用性质: H[i] >= H[i - 1] - 1 (注意 i 是下标，不是排名) 
	for(int i = 1; i <= n; i ++) mp[sa[i]] = i; // sa[i] ~ n 的排名是 i  
	//sa:排名是 i 的为 sa[i] ~ n 
	for(int i = 1; i <= n; i ++) {
		if(mp[i] == 1) {
			Height[i] = 0; continue;
		}
		Height[i] = Max(0, Height[i - 1] - 1);
		while(i + Height[i] <= n && sa[mp[i] - 1] + Height[i] <= n && s[i + Height[i]] == s[sa[mp[i] - 1] + Height[i]]) Height[i] ++;
	}
}
int main() {
	scanf("%s", s + 1); n = strlen(s + 1);
	Clac_SA(); Clac_Height();
	for(int i = 1; i <= n; i ++) write(sa[i] - 1), putchar(' ');
	putchar('\n');
	for(int i = 1; i <= n; i ++) write(Height[sa[i]]), putchar(' ');
	return 0;
}

例题

Long Long Message
题意

DM星人的基因种碱基有26种，即26个小写字母。
现在已知两个DM星人的基因序列，求你输出这两个DM星人的最长公共基因。
公共基因表示从两个基因序列的某个位置开始有一段完全相同的连续基因序列。

思路

将一个串接在另一个串的后面，跑SA，求出Height。 a n s = M a x { H e i g h t [ i ] } ans = Max\{Height[i]\} ans=Max{Height[i]}（ i f if if i − 1 i-1 i−1 与 i i i不在一个串中）。为什么这样是对的呢？这里有一个贪心：字典序排序后的字符串，他们的最优解就在相邻的两个串之间。

代码
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <climits>
#include <iostream>
using namespace std;
const int MAXN = 1e6 + 5;
int n, c[MAXN], m = 200, hs[MAXN], sa[MAXN], tmp[MAXN], t[MAXN];
int Height[MAXN], mp[MAXN];
char s[MAXN], s2[MAXN];
//sa:当前排的顺序
//tmp:过渡序列
//hs:即 hash, 映射值
//c:统计个数 
void write(int x) {
	if(x < 0) x = -x, putchar('-');
    if(x <= 9) {
        putchar(x + '0');
        return;
    }
    write(x / 10); putchar(x % 10 + '0');
}
void Clac_SA() {
	memset(c, 0, sizeof(c));
	for(int i = 1; i <= n; i ++) hs[i] = s[i], c[hs[i]] ++;
	for(int i = 1; i <= m; i ++) c[i] += c[i - 1];
	for(int i = n; i >= 1; i --) sa[c[hs[i]] --] = i; // 排好第一轮 
	for(int i = 1; i <= n; i <<= 1) {
		int num = 0;
		for(int j = n - i + 1; j <= n; j ++) tmp[++ num] = j;
		for(int j = 1; j <= n; j ++) if(sa[j] > i) tmp[++ num] = sa[j] - i;// 转换为新的序列 (以第二关键字排序)
		for(int j = 1; j <= m; j ++) c[j] = 0;
		for(int j = 1; j <= n; j ++) c[hs[j]] ++;
		for(int j = 2; j <= m; j ++) c[j] += c[j - 1];
		for(int j = n; j >= 1; j --) sa[c[hs[tmp[j]]] --] = tmp[j];//注意要倒序 
		for(int j = 1; j <= n; j ++) t[j] = hs[j];
		hs[sa[1]] = 1; num = 1;
		for(int j = 2; j <= n; j ++) hs[sa[j]] = hs[sa[j - 1]] + (!((t[sa[j]] == t[sa[j - 1]]) & (t[sa[j] + i] == t[sa[j - 1] + i])));
		num = hs[sa[n]];
		if(num == n) break; // 可加可不加
		m = num; 
	}
}
int Max(int x, int y) { return x > y ? x : y; }
void Clac_Height() {// 利用性质: H[i] >= H[i - 1] - 1 (注意 i 是下标，不是排名) 
	for(int i = 1; i <= n; i ++) mp[sa[i]] = i; // sa[i] ~ n 的排名是 i  
	//sa:排名是 i 的为 sa[i] ~ n 
	for(int i = 1; i <= n; i ++) {
		if(mp[i] == 1) {
			Height[i] = 0; continue;
		}
		Height[i] = Max(0, Height[i - 1] - 1);
		while(i + Height[i] <= n && sa[mp[i] - 1] + Height[i] <= n && s[i + Height[i]] == s[sa[mp[i] - 1] + Height[i]]) Height[i] ++;
	}
}
int main() {
	scanf("%s%s", s + 1, s2 + 1);
	n = strlen(s + 1);
	int len = strlen(s2 + 1);
	s[n + 1] = '#'; n ++;
	for(int i = 1; i <= len; i ++) s[i + n] = s2[i]; n += len;
	Clac_SA(); Clac_Height();
	int ans = 0;
	for(int i = 2; i <= n; i ++) {
		if((long long)(sa[i - 1] - (n - len)) * (sa[i] - (n - len)) < 0) ans = max(ans, Height[sa[i]]);// 贪心 （注意会爆int）
	}
	printf("%d\n", ans);
	return 0;
}
[JSOI2007]字符加密
题面

喜欢钻研问题的JS 同学，最近又迷上了对加密方法的思考。一天，他突然想出了一种他认为是终极的加密办法：把需要加密的信息排成一圈，显然，它们有很多种不同的读法。

例如‘JSOI07’，可以读作： JSOI07 SOI07J OI07JS I07JSO 07JSOI 7JSOI0 把它们按照字符串的大小排序： 07JSOI 7JSOI0 I07JSO JSOI07 OI07JS SOI07J 读出最后一列字符：I0O7SJ，就是加密后的字符串（其实这个加密手段实在很容易破解，鉴于这是突然想出来的，那就^^）。 但是，如果想加密的字符串实在太长，你能写一个程序完成这个任务吗？

思路

版题。注意必须把这个字符串扩展一倍（因为是环），不然会被 zaba 这样的数据卡掉。

代码
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <climits>
#include <iostream>
using namespace std;
const int MAXN = 2e5 + 5;
int n, c[MAXN], m = 200, hs[MAXN], sa[MAXN], tmp[MAXN], t[MAXN];
int Height[MAXN], mp[MAXN];
char s[MAXN], s2[MAXN];
//sa:当前排的顺序
//tmp:过渡序列
//hs:即 hash, 映射值
//c:统计个数 
void write(int x) {
	if(x < 0) x = -x, putchar('-');
    if(x <= 9) {
        putchar(x + '0');
        return;
    }
    write(x / 10); putchar(x % 10 + '0');
}
void Clac_SA() {
	memset(c, 0, sizeof(c));
	for(int i = 1; i <= n; i ++) hs[i] = s[i], c[hs[i]] ++;
	for(int i = 1; i <= m; i ++) c[i] += c[i - 1];
	for(int i = n; i >= 1; i --) sa[c[hs[i]] --] = i; // 排好第一轮 
	for(int i = 1; i <= n; i <<= 1) {
		int num = 0;
		for(int j = n - i + 1; j <= n; j ++) tmp[++ num] = j;
		for(int j = 1; j <= n; j ++) if(sa[j] > i) tmp[++ num] = sa[j] - i;// 转换为新的序列 (以第二关键字排序)
		for(int j = 1; j <= m; j ++) c[j] = 0;
		for(int j = 1; j <= n; j ++) c[hs[j]] ++;
		for(int j = 2; j <= m; j ++) c[j] += c[j - 1];
		for(int j = n; j >= 1; j --) sa[c[hs[tmp[j]]] --] = tmp[j];//注意要倒序 
		for(int j = 1; j <= n; j ++) t[j] = hs[j];
		hs[sa[1]] = 1; num = 1;
		for(int j = 2; j <= n; j ++) hs[sa[j]] = hs[sa[j - 1]] + (!((t[sa[j]] == t[sa[j - 1]]) & (t[sa[j] + i] == t[sa[j - 1] + i])));
		num = hs[sa[n]];
		if(num == n) break; // 可加可不加
		m = num; 
	}
}
int Max(int x, int y) { return x > y ? x : y; }
void Clac_Height() {// 利用性质: H[i] >= H[i - 1] - 1 (注意 i 是下标，不是排名) 
	for(int i = 1; i <= n; i ++) mp[sa[i]] = i; // sa[i] ~ n 的排名是 i  
	//sa:排名是 i 的为 sa[i] ~ n 
	for(int i = 1; i <= n; i ++) {
		if(mp[i] == 1) {
			Height[i] = 0; continue;
		}
		Height[i] = Max(0, Height[i - 1] - 1);
		while(i + Height[i] <= n && sa[mp[i] - 1] + Height[i] <= n && s[i + Height[i]] == s[sa[mp[i] - 1] + Height[i]]) Height[i] ++;
	}
}
int main() {
	scanf("%s", s + 1);
	n = strlen(s + 1);
	for(int i = n + 1; i <= (n << 1); i ++) s[i] = s[i - n]; n <<= 1;
	Clac_SA(); Clac_Height();
	for(int i = 1; i <= n; i ++) {
		if(sa[i] <= n / 2) printf("%c", s[sa[i] + n / 2 - 1]);
	}
	return 0;
}
nKessi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
后缀数组的倍增法实现
12-13
后缀数组模板，后缀数组的倍增法实现，名次数组，高度数组
彻底弄懂后缀数组
weixin_30790841的博客
03-26 546
什么叫后缀数组 首先要知道什么叫后缀 ？ 比如 字符串 abcdef 那么 abcdef bcdef cdef def ef f 就叫做后缀 也就是从最后一个字母之前的一个字母开始一直到最后一个字母（所以所 bcd不是后缀 因为没有到最后一位f） 所构成的字符串就叫做后缀 至于后缀数组能干什么？我在这就不介绍了 这不是本文的重点！...
后缀数组的倍增算法
anzhi7214的博客
09-05 106
一、基数排序。 题目描述：给你n个字符串，把它们排序。 n<=100000 （不要用sort水过，除非你在NOI的考场上） 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include<string> 5 #include...
后缀数组（倍增）学习记录，我尽可能详细的讲了
PatchouKnowledge的博客
04-08 302
我觉的我尽可能详细的来讲解后缀数组了，我尽力了~ 还有就是还有点内容可能之后会补，今天是实在写不动了。
后缀数组之倍增算法
Sunshine_cfbsl
08-12 2415
后缀数组是后缀树的替代品。它不仅时间效率高，而且代码比较简单，不易写错。 后缀数组可以查询模板串P[0...m−1]P[0...m-1]，是否为文本串s[0...n−1]s[0...n-1]的子串，并在n很大，查询次数多时效率很高。 我们定义： 后缀k：后缀s[k…n-1] k前缀：对于字符串u，u的前k个字符组成的字符串（k过大即为整个u） 后缀数组（sa[i]）：对所有后缀排序之后排名第i（
Java后缀数组之求sa数组的实例代码
08-27
后缀数组就是一个字符串所有后缀大小排序后的一个集合，然后我们根据后缀数组的一些性质就可以实现各种需求。这篇文章主要介绍了Java后缀数组-求sa数组,需要的朋友可以参考下
11.罗穗骞《后缀数组——处理字符串的有力工具》.zip
08-08
罗穗骞《后缀数组——处理字符串的有力工具》(有算法源码和解题源码) IOI2009论文，有源码，简单易懂，方便学习后缀数组的构造和各种应用。 后缀数组是一种优秀的数据结构，在字符串匹配方面有诸多应用。
后缀数组详解
08-26
非常详细的后缀数组讲解~~~既看既懂
后缀数组倍增算法实现
09-02
后缀数组倍增算法实现 + RMQ问题ST算法实现
后缀数组 倍增法详解
weixin_34309543的博客
07-22 310
算法思路 主要是基于基数排序，如果基数排序没弄懂代码就会很难理解： 首先从k=0开始，从后缀数组里面选取步长为2^k的后缀数组的前子串 然后进行基数排序 如果排序后所有的名次数组的值都不相同，那么排序结束； 否则，k++（也就是步长翻倍），继续排序。 几个概念 数组sa(sorted array)：构造完成前表示关键字数组，下标表示名次，值表示关键字的首字符位置，值相同的时候名次根据在原串中相...
后缀数组倍增法
reverie_mjp的博客
04-17 2306
那夜风，宫灯昏暗，小楼听雨灯辉摇梦
字符串处理-SA数组
Evan_song1234的博客
11-05 277
后缀数组 SA\tt SASA 可以用于各方面字符串问题，其目的是求出这个字符串的所有后缀的按照字典序的排名。 前置知识 倍增 / DC3 算法用途 可以用来求最长公共子串，最长回文串等 算法复杂度 字符串长度为 n\tt nn 时间 O(nlog⁡n)\tt O(n\log n)O(nlogn) 空间 O(n)\tt O(n)O(n) 算法实现 要知道，最暴力算法就是把所有后缀找出来，然后用 sort\tt sortsort 排序 虽然时间复杂度和这个算法一样 O(nlog⁡n)\tt O(n\log n
后缀数组——倍增算法
ZouCharming的专栏
06-22 518
最近在做字符串方面的训练，做到后缀数组时卡了好久，后缀数组的实现有两种方法，而我看的是倍增算法，其实倍增算法的思路还是很简单的（详见白书），只是给的模板代码对于我这种渣渣来说有点艰难，弄了好久才弄懂。 虽说是字符串方面的算法，但是它的实现过程是以数字的形式进行的，也正因如此，该算法同样适用于数字串（字符串应先转换成ASCII码） 在使用倍增算法时应注意的两点： 1，如果是求一
后缀数组
weixin_30566063的博客
11-19 80
后缀数组就是将字符串所有后缀排序后的数组，设字符串为S，令后缀Suffix(i)表示S[i..len(S)]。用两个数组记录所有后缀的排序结果： Rank[i]记录Suffix(i)排序后的序号，即Suffix[i]在所有后缀中是第Rank[i]小的后缀 SA[i]记录第i位后缀的首字母位置，即Suffix[SA[i]]在所有后缀中是第i小的后缀 然后就是...
后缀数组——罗穗骞倍增算法代码详解
一个码农
12-19 4490
首先解释一下用到的几个数组。 数组sa：构造完成前表示关键字数组，下标表示名次，值表示关键字的首字符位置，值相同的时候名次根据在原串中相对位置的先后决定；构造完成后表示后缀数组，下标表示名次，值表示后缀的首字符位置。 数组x：表示rank数组，下标表示关键字的位置，值表示关键字大小（rank），相同的值有相同的rank。初始化为字符串r的每个字符大小（此时x并不代表rank，只借助其值比较相对
后缀数组（倍增法）
H煊的博客
09-07 1445
后缀数组（Suffix Array）：将某个字符串的所有后缀按字典序排序后得到的数组。 算法：朴素实现：直接将所有后缀进行排序，将n个长度为O(n)的字符串进行排序，时间复杂度O(n^2*logn)；倍增算法：通过充分利用各个后缀之间的联系，将构造后缀数组的最坏时间复杂度成功降至O(n*logn)。 倍增法实现：首先计算从每个位置开始的长度为1的子串的顺序，再利用这个结果计算长度为2的子串的顺
后缀数组倍增构造算法说解
Foliciatarier的博客
03-10 710
算法：倍增 数据结构：后缀数组
后缀数组 python
最新发布
11-21
抱歉，Python标准库中没有后缀数组的实现。不过，你可以使用第三方库PyPi中的suffix_array来实现后缀数组。安装方法如下： ```shell pip install suffix-array ``` 下面是一个简单的示例代码，展示如何使用suffix_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值