9.5 KiB
kmp conclusion
知识脉络
这里主要讨论串匹配的多个有效算法。各个算法的历史与逻辑在对应的md文件里面已经说得非常清楚了，这里主要针对考题来给出总结，即给定一个模式串P，要求写出它的next数组，改进的next数组，bc表，ss表和gs表。
对于next数组，一种方案是把makeNext函数手动运行一遍，不过我觉得太慢了，不太喜欢。比较好的办法是，对于当前字符P[j]，next[j]即是它的前缀中最长的自匹配长度。不过需要注意的是，这里自匹配的前缀和后缀一定要是P[0, j)的真前缀和真后缀，否则next[j] = j也没有意义啊。此外还有一种验证的方法，即next[j+1]至多比next[j]大1。
构造改进的next数组，则应该建立在next数组的基础上进行。即对于当前字符P[j]，首先比较是否满足P[j] == P[next[j]]，如果不满足的话直接更新P[j] = next[next[j]]。
bc表的构造过于简单了，这里就不再赘述，按照定义来写就好。
ss表的构造也可以直接通过定义得到，为了得到gs表，我觉得跑一次buildGS几乎没有可能，所以还是用gs表的定义做吧。需要注意的是，对于gs[m-1]，此时好后缀的长度为零，gs[m-1]应该等于移动到第一个不等于P[m-1]的字符所需要移动的距离。
串匹配问题
字符串匹配问题是算法中的常见问题，即对于一个较长的文本串T，以及一个较短的模式串P，返回模式串P在文本串T中是否出现，或者首先出现的位置，或者所有出现的位置。实际上，在实际生活中，具有大量的字符匹配问题的应用场景，例如一般的编辑器软件，都具有的查找替换功能，还有像是google这种软件，本质上就是从整个因特网的文本数据中，去查找用户搜索的字符串。
以下主要讨论如何实现串匹配问题。
一种简明的策略
为了查找模式串P在文本串T中出现的位置，最简单的思路就是对于每一个可能的对齐位置，依次去比对两个串中的字符是否相等，如果完全匹配，则返回匹配成功；否则就在下一个对其位置开始新的匹配。该策略执行的流程如下图所示：
容易看出，这种策略在最坏情况下，在每个对齐位置都需要进行m次比对，其中m为模式串的长度，设文本串的长度为n，则最坏情况下的时间复杂度为O(mn)。一种最坏情况的实例如下图所示：
kmp
对上面的蛮力策略进行分析，可以发现其时间性能较差是因为在该策略中做了大量无意义的比对。比如上图中的这种情况，在每一个对齐位置都首先进行m - 1次成功的比对，其中每个字符都是'0'，然后失败于最后的一次比对。每次移动到新的对齐位置后，此前比对过的字符，将再次参与比对。如下图所示：
正是这些重复的比对，拉低了该策略的时间性能。因此，就应该从避免这些重复工作的角度，来对该算法进行改进。
具体的做法是，如果在一次比对中，失败于模式串P中第k各字符，则此前已经进行了k - 1次成功的比对，因此此时我们已经获悉了文本串T中对之对齐的k - 1个字符的全部信息，因此就可以将模式串快速移动，直到移动到下一个“值得”对齐的位置。这里的“值得”对齐的位置，其实就是移动后模式串的前缀，要与文本串中这k - 1个字符的后缀相匹配。这就是kmp算法的基本思路。
应该注意到，采用kmp策略时，每次移动的距离只与模式串P有关，而与文本串T无关。这是因为在第k个位置失配后，文本串中的这k - 1个字符和模式串长度为k - 1的前缀完全相同。因此所谓“值得”对齐的位置，其实就是这k - 1字符构成的串，前缀和后缀自相匹配的位置。
需要指出的是，这样的位置可能有多个，所有的这些位置都是“值得”的对齐位置，因此，为了不错过其中的任意一个对齐位置，移动距离应该取所有这些自匹配位置移动距离中最小的，也就是自匹配长度最长的。为了在kmp算法运行过程中，迅速更新串的对齐位置，可以对模式串P做预处理，将在第k个字符处匹配失败的最长自匹配长度，保存在next[k]中，以便于查询。这样，就可以实现kmp算法了：
int match(char* text, char* pattern){
int* next = makeNext(pattern);
int i = 0, j = 0, m = strlen(text), n = strlen(pattern);
while(i < m && j < n){
if(j < 0 || text[i] == pattern[j]){
++i;
++j;
}
else j = next[j];
}
return i - j;
}
可以看到，如果匹配成功，则同时移动文本串和模式串的指针；一旦匹配失败，就将模式串的指针移动到next[j]，即实现上面所说的快速移动。需要注意的是对j < 0情况的处理，此时相当于在模式串的左边具有一通配符，即pattern[-1] = *;，它可以匹配任何的字符，这样就可以将该情况与匹配成功做相同的处理。
这样，现在的主要问题就是如何构造这样一个next数组，即实现上面的makeNext函数。
next的构造
在前面已经指出了next数组的语意，即对于其中的第i项，next[i]表示模式串在第i个位置失配时，模式串的下一个对齐位置。设子串K = P[0, i-1]，该位置应该满足：
K[0, next[i] - 1] = K[i - next[i] ,i - 1]
所以next[i]的值也等于字符串K的最长自匹配长度。因此，构造任意一个next[i]，其实就是找到P的一个子串P[0, i-1]的最长自匹配长度
为了高效地构造出next[i]，不难注意到next[i]的值其实在一定程度上依赖于next[i-1]的，这是因为如果P[i-1] = P[next[i-1]]，即在子串P[0, i-2]的最长自匹配，可以直接延伸到子串P[0, i-1]，所以有
next[i] = next[i - 1] + 1;
可是如果不满足P[i-1] = P[next[i-1]]，则上一个位置的最长自匹配长度将在新的位置断裂，此时必有next[i] <= next[i-1]，所以只能到子串P[0, next[i-1])中去寻找新的最长自匹配长度。由于P[0, next[i-1]) = P[i-1-next[i-1] ,i-1)，因此next[next[i-1]] + 1是next[i]的下一个候选值，如果有
P[i-1] == P[next[next[i-1]]];
则有
next[i] = next[next[i - 1]] + 1;
否则应该重复上述过程，直到条件的确满足，或者不存在这样的一个自匹配。此时应该令next[i] = -1，表示与模式串左边假想的通配符P[-1] = *是自匹配的。因此，构造next表的代码如下：
int* makeNext(char* str){
int* next;
int len, i = 0, j = -1;
for (len = 0; str[len] != '\0'; ++len);
next = new int[len];
next[0] = -1;
while(i < len - 1){
if(j < 0 || str[i] == str[j]) next[++i] = ++j;
else j = next[j];
}
return next;
}
应该看到，next表的构造的代码非常类似于kmp算法，这是因为next的构造本质上就是模式串的自我匹配，这个过程就是利用kmp的思想实现的。
可以证明，kmp算法的时间复杂度是O(m + n)。证明如下：令k = 2i - j，在每一次迭代中，要么执行i++, j++，要么执行j = next[j]，其中必然满足next[j] < j，因此每次迭代中k都至少增加1，而k的最大值不过为2n，即循环至多进行O(n)次，每一次的时间复杂度都是O(1)，故总的时间复杂度为O(n)。
kmp的改进
上面的kmp算法还存在一些缺陷，例如下面的这种情况：
可以注意到，在文本串的1这个位置，统共需要进行四次比对，然而后面的三次比对都是无意义的，因为模式串的四个字符都是0，而在第一次失败的比对中我们就可以知道，文本串的该字符并不是0，因此聪明的做法应该是直接跳过这三个不可能会成功的比对。
对上述的问题进行总结，目前的kmp算法的确充分利用了先前成功比对的经验，来快速移动到下一个值得的对齐位置；而它的问题在于忽略了比对失败的教训，而这就是它在这里低效的原因。
为了对kmp进行改进，可以在构造next数组时，就将这种失败的负面信息纳入考虑。一般地，对于此前的next[i]，必然有
P[0, next[i] - 1] == P[i-next[i] ,i-1]
但是如果
P[next[i]] == P[i]
那么这里的next[i]就是没有意义的，因为将模式串的对齐位置到next[i]后，下一次比对一定是失败的。因此，为了解决这个问题，只需在构造next数组时，对这种情况加以判断，具体的代码如下：
int* makeNext(char* str){
int* next;
int len, i = 0, j = -1;
for (len = 0; str[len] != '\0'; ++len);
next = new int[len];
next[0] = -1;
while(i < len - 1){
if(j < 0 || str[i] == str[j]){
++i, ++j;
next[i] = (str[i] == str[j]? next[j]: j);
}
else
j = next[j];
}
return next;
}
需要注意的是，之所以在P[next[i]] == P[i]时，可以直接将next[i]更新为next[next[i]]，而不需要做额外的比对以确定是否满足
P[i] == P[next[next[i]]
是因为在此前的循环中，已经判断过P[next[i]] != P[next[next[i]]]了。