字符串前缀:从字符串开头到字符串某个位置
字符串后缀:从字符串某个位置到字符串结尾
( 原串 和 空字符串 也是 前缀(后缀))
后缀数组:将所有后缀按字典序排序后,得到的数组
① 方法
如果我们直接将每个后缀字符串直接进行比较
复杂度为 O( n * n * logn )
代码如下:
string S;
int sa[105], rk[105];
bool cmp(int a, int b)
{
return S.substr(a) < S.substr(b);
}
void construct_sa()
{
for(int i = 0; i <= S.length(); i++)
{
sa[i] = i;
}
sort(sa, sa + S.length() + 1, cmp);
rk[sa[0]] = 0;
for(int i = 1; i <= S.length(); i++)
{
rk[sa[i]] = rk[sa[i-1]] + 1;
}
}
字符串 S 为 abeacadabea
sa: 11 10 7 0 3 5 8 1 4 6 9 2
rk: 3 7 11 4 8 5 9 2 6 10 1 0
② 方法
字符之间的比较所消耗的复杂度为 O( n ),而数字之间的比较复杂度为 O( 1 ),如果我们能将字符之间比较转化为数字之间比较,是否可以降低复杂度呢
思路:我们用倍增思想,先比较长度为 2 的子串,再利用该结果比较长度为 4 的子串,再利用该结果比较长度为 8 的子串 … ( 长度为 1 的子串不用比较,因为自身的 ASCII 值就已经相当于比较了)
( 如果 剩余字符 不足 长度 2^k ,则表示到 字符串S的末尾 )
我们应该怎么利用上次比较的结果呢,比如长度为 k 的子串我们已经比较好了,那么长度为 2 * k 的子串,我们就只用看 i 开头长度为 k 的子串排序序号,和 i + k 开头长度为 k 的子串排序序号,然后比较序号之间就行,这样就把字符串之间的比较,转换成了数字比较
复杂度为 O( n * log n * log n )
代码如下:
string S;
int sa[105], rk[105], tmp[105];
int k;
bool cmp(int a, int b)
{
if(rk[a] == rk[b])
{
int i = a + k <= S.length() ? rk[a + k] : -1;
int j = b + k <= S.length() ? rk[b + k] : -1;
return i < j;
}
return rk[a] < rk[b];
}
void construct_sa()
{
for(int i = 0; i <= S.length(); i++)
{
sa[i] = i;
rk[i] = i < S.length() ? S[i] - 'a' + 1 : 0;
}
for(int i = 1; i <= S.length(); i = i * 2)
{
k = i;
sort(sa, sa + S.length() + 1, cmp);
tmp[sa[0]] = 0;
for(int i = 1; i <= S.length(); i++)
{
tmp[sa[i]] = tmp[sa[i-1]] + (cmp(sa[i-1], sa[i]) ? 1 : 0);
}
for(int i = 0; i <= S.length(); i++)
{
rk[i] = tmp[i];
}
}
}
字符串 S 为 abeacadabea
sa: 11 10 7 0 3 5 8 1 4 6 9 2
rk: 3 7 11 4 8 5 9 2 6 10 1 0
感觉注释写代码里看不清(注释颜色太浅),我就在这解释下:
- tmp 是一个临时的数组,因为如果我们直接更新 rk 结果数组,这样我们在判断长度为 k 的字符子串时,可能会有已经更新过的 长度为 2k 的字符子串混入,会影响判断结果
- 我们对于每次的排序都需要再处理一次,因为当两个字符子串大小相同时,我们需要让排序序号相同,不然会影响下次的判断
③ 方法
我们是否可以用字符串匹配的思想,把每个后缀列用数字表达出来,然后排个序
例:字符串 S 为 abeacadabea 时,部分后缀为:
11个空字符
a + 10 个空字符
ea + 9 个空字符
bea + 8 个空字符
abea + 7 个空字符
…
如果给每种字符编上号,例如 空字符 等于 0,a 等于 1,b 等于 2 …
那我们只用比较这几个数的大小就可以了( 当最大种数小于 10 的时候 )
00000000000
10000000000
51000000000
25100000000
12510000000
…
但这种十进制的表达只有字符最大种数小于等于 10 的情况才能用,那如果情况不为 10 种的情况,我们可以将 十进制 改为 n进制 就行,这样每一位仍然可以表达字符是什么
但是这个很不靠谱,因为我们比较的是大小,所以我们不能取模,这就导致很容易就出现一个巨大无比的数,很容易就无法判断了
复杂度为 O( n * logn ),但也就数据很小很小的时候可以用用,大多数没用
代码如下:
const ll B = 10;
string S;
pair<ll, int> sa[105];
int rk[105];
int k;
void construct_sa()
{
ll T = 1;
for(int i = 0; i < S.length(); i++)
{
T = T * B;
}
ll t = 0;
sa[S.length()] = make_pair(t, S.length());
for(int i = S.length() - 1; i >= 0; i--)
{
t = t / B + (S[i] - 'a' + 1) * T;
sa[i] = make_pair(t, i);
}
sort(sa, sa + S.length() + 1);
rk[sa[0].second] = 0;
for(int i = 1; i <= S.length(); i++)
{
rk[sa[i].second] = rk[sa[i-1].second] + 1;
}
}
字符串 S 为 abeacadabea
sa: 11 10 7 0 3 5 8 1 4 6 9 2
rk: 3 7 11 4 8 5 9 2 6 10 1 0
后缀数组的用处
例如可以应用于字符串匹配 ( 假设已经算好了 字符串S 的后缀数组 )
在 字符串S 中找 字符串T ,字符串S 的长度为 n,字符串T 的长度为 m,则复杂度为 O( m log n )
如果用 Rabin-Karp算法写的话复杂度为 O( n + m )(上篇文章写了)
在 n 较大的时候,后缀数组的优势更大,所以当我们对同一个 字符串S 找多个不同字符串 Ti 时,我们可以用这个后缀数组处理
bool contain(string S, string T)
{
int l = 0, r = S.length(), mid = (l + r) / 2;
while(l < r - 1)
{
if(S.compare(sa[mid], T.length(), T) == -1)
{
l = mid;
mid = (l + r) / 2;
}
else
{
r = mid;
mid = (l + r) / 2;
}
}
return S.compare(sa[r], T.length(), T) == 0;
}
注释放下面:
- compare函数,比较两个字符串大小,若相同返回 0,若小于返回 -1,若大于返回 1
如果只有一个参数,则两个字符串直接比较 s1.compare(s2)
若有三个参数,则比较 s1 从 下标a 开始 b个字符 组成的子字符串和 s2 比较 s1.compare(a,b,s2)
若有五个参数,则比较 s1 从下标a 开始 b个字符 组成的子字符串和 s2 从下标c 开始 d个字符组成的子字符串 s1.compare(a,b,s2,c,d) - 这个二分是 左开右闭 ( l , r ] ,因为不可能是 0,那是空串