目录
1 K M P KMP KMP算法
简介:
字符串中查找子串,是前缀函数的一个典型应用
引入: 朴素字符串匹配做法
具体实现:
- 在字符串 s s s 中一位一位比较模式串P的每一位;
- 若失败,则移位到字符串 s s s 的下一位,继续从头比较模式串 p p p
时间复杂度: O ( n ∗ m ) O(n * m) O(n∗m)
KMP算法
我们不难看出朴素做法中有很多信息没有利用起来,从而做了很多重复匹配
我们的KMP算法就是把朴素做法中的信息最大化利用,从而将时间复杂度降低至线性
首先分析 n e x t next next 数组:
如图所示:假设我们分析到了 字符
s
[
i
]
s[i]
s[i] 与
p
[
j
+
1
]
p[j + 1]
p[j+1] 的关系
若, 字符
s
[
i
]
s[i]
s[i] 与
p
[
j
+
1
]
p[j + 1]
p[j+1]相等,则继续匹配下一位
若, 字符
s
[
i
]
s[i]
s[i] 与
p
[
j
+
1
]
p[j + 1]
p[j+1] 不相等,则 字符串 s 与 p 开始匹配的位置向右移动一位,
i
i
i 倒回之前
s
s
s 匹配的开头的后一位,
j
j
j 倒回字符串
p
p
p 的开头,重新从
p
[
1
]
p[1]
p[1] 开始匹配,当匹配到下图情况时,再一次(最先的一次)匹配到了 字符
s
[
i
]
s[i]
s[i] 与
p
′
[
j
+
1
]
p'[j + 1]
p′[j+1],即、最下面的一条线
则可知:下图的五段字符都相等
如果我们直接令其匹配 p ′ [ j + 1 ] p'[j + 1] p′[j+1] 位置,就可以不用使 i i i 倒回前面的位置,从而使 i i i 一直向右走,达到线性的时间复杂度 O ( n ) O(n) O(n)
但,此时我们的 p p p 字符串该如何移动,才能使其恰好再次匹配到 p ′ [ j + 1 ] p'[j + 1] p′[j+1] ?
这就是我们的 n e x t [ i ] next[i] next[i] 数组的含义:(四种说法,帮助理解)
- 当匹配失败时, p p p 向后移动的最小步数,
- 同义于 最大程度保留 p p p 字符串后缀的最小移动步数
- 即、以 p [ i ] p[i] p[i] 结尾的后缀中,能够匹配前缀的最大长度
- 通俗来讲就是,前后缀相等的最大长度
这样当我们匹配失败时,接下来的步骤为:
- 将 j j j 变为 n e x t [ j ] next[j] next[j] 可最大程度的帮助我们的下一次匹配成功
- 若
n
e
x
t
[
j
]
next[j]
next[j] 再次失败,则变为
n
e
x
t
[
n
e
x
t
[
j
]
]
next[next[j]]
next[next[j]] 我们的
n
e
x
t
[
j
]
next[j]
next[j] 的边界
n
e
x
t
[
1
]
next[1]
next[1] 为
0
0
0
即一个字符也没匹配成功,只能重新匹配……
转化为代码为:
// KMP匹配过程
for(int i = 1, j = 0; i <= n; i ++ )
{
// 到达边界,或者匹配成功了,就退出next的循环,
// 否则则为匹配失败,j = next[j],进行next[j]过后的下一位字符匹配
while(j && s[i] != p[j + 1]) j = ne[j];
if(s[i] == p[j + 1]) j ++; // 若匹配成功,则 j ++
if(j == m) // 完全匹配,输出完全匹配的s串的开头的下标(题目内容于本模板无关)
{
cout << i - j << " ";
j = ne[j];
}
}
如何求 n e x t next next 数组?
接下来我们将问题转化为如何求 n e x t next next 数组 ?
含义:
n e x t [ j ] next[j] next[j] 为:在 p p p 中以 p [ j ] p[j] p[j] 结尾的与前缀相等的最大后缀, n e x t [ i ] next[i] next[i] = = = 最大前缀的末尾下标 。
可类似于利用字符串匹配时的 n e x t next next 数组的思想,线性求 n e x t next next 数组,时间复杂度:O(n)
可转化为 字符串
p
p
p 匹配字符串
p
p
p
即如图所示匹配:
现,假设我们已经求出
1
到
(
n
−
1
)
1到(n-1)
1到(n−1) 中任意下标的
n
e
x
t
[
i
]
next[i]
next[i]
则,当前匹配的情况即为
n
e
x
t
[
i
−
1
]
next[i - 1]
next[i−1] ,即为
j
=
n
e
x
t
[
i
−
1
]
j = next[i-1]
j=next[i−1]
解释如下:图中所示的两段和第二根紫线都相等,如此,即为
p
[
i
−
1
]
p[i-1]
p[i−1] 结尾的,最大前缀和后缀相等,即为
n
e
x
t
[
i
−
1
]
next[i-1]
next[i−1] 的定义;
若,
p
[
i
]
p[i]
p[i] 和
p
[
j
+
1
]
p[j+1]
p[j+1] 匹配成功,则
j
+
+
j ++
j++ ,即、
n
e
x
t
[
i
]
=
n
e
x
t
[
i
−
1
]
+
1
next[i] = next[i - 1] + 1
next[i]=next[i−1]+1
若,
p
[
i
]
p[i]
p[i] 和
p
[
j
+
1
]
p[j+1]
p[j+1] 匹配失败,则将
j
j
j 变为
n
e
x
t
[
j
]
next[j]
next[j] 即,最小向后移动的次数(和匹配过程一样,如此可和之前的步骤完全一致),下图帮助理解:
求
n
e
x
t
next
next 数组代码如下:
// 求next数组,即、模式串p中的与前缀相等的最大后缀
for(int i = 2, j = 0; i <= m; i ++ )
{
while(j && p[i] != p[j + 1]) j = ne[j];
if(p[i] == p[j + 1]) j ++;
ne[i] = j;
}
至此,
- 我们的 K M P KMP KMP 字符串匹配过程原理,已解释清楚
- n e x t [ j ] next[j] next[j] 数组的含义,原理,求法,已解释清楚
PS.
如果你此时完全看明白了,那么恭喜你!算法界两大门神之一的
K
M
P
KMP
KMP 算法 ,你已经完全掌握(超越了大部分的初学者呦,恭喜恭喜!!)以后算法的道路会越来越通畅。
2 s u b s t r ( ) substr() substr() 函数
简介:
字符串截取函数
用法:
假设:string s = "0123456789";
- 法一:
string sub1 = s.substr(5); //只有一个数字5表示从下标为5开始一直到结尾:sub1 = "56789"
- 法二:
string sub2 = s.substr(5, 3); //从下标为5开始截取长度为3位:sub2 = "567"
时间复杂度:
- s u b s t r ( p o s , l e n ) substr(pos,len) substr(pos,len) 返回从 p o s pos pos 开始,长度为 l e n len len 的字串,时间复杂度为 O ( l e n ) O(len) O(len)
3 两者时间复杂度对比
若s串为n长度,p串为m长度
则:
调用substr函数时间复杂度:
一次调用为O(m),仅调用 n − m + 1 n-m+1 n−m+1 次,则时间复杂度为 O ( ( n − m + 1 ) ∗ m ) O( (n-m+1) * m ) O((n−m+1)∗m) 貌似比朴素做法的 O ( n ∗ m ) O(n*m) O(n∗m) 好一点,hh,但其实,,还是 O ( n ∗ m ) O(n*m) O(n∗m) 级别的,,,很不幸,大部分情况下题目是不允许这种时间复杂度的,TLE在等着你,,
用 K M P KMP KMP 做法:
一次最多子串从 1 1 1 走到 m m m,所以时间复杂度介于 O ( n ) O(n) O(n) ~ O ( n + m ) O(n+m) O(n+m),比 O ( n ∗ m ) O(n * m) O(n∗m) 快了很多的 ,如此一来,方可 A C AC AC !
至此,本篇博文结束 !
感谢您的阅读,如不耽误你,请您点击一下大拇指呦!帮助更多的初学者理解
K
M
P
KMP
KMP,我辈义不容辞!!!😊