KMP算法学习

目标

• 理解kmp算法思路
• 如何实现kmp算法

kmp算法

问题描述

给定一个 source 字符串和一个 target 字符串，在 source 字符串中找出 target 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

逐位搜索：

指针p、q分别指向source和target字符串，逐位对比，如果发现不匹配，则退回开始位置，然后从下一位开始对比。时间复杂度，最坏的情况：O(n*m)。
考虑下面几种情况，

1. source = "aaaabaaaabaaaaabcde" target="aaaaa"，使用逐位搜索的方法，会有很多次回溯，并且每次回溯都会比较到最后才能够发现不匹配。
2. source = "aaaaabaaaabaaaa" target="aaaab"，使用逐位搜索的方法，回溯一次过后能够发现正确结果。
3. source = “abcdabcdabcde” target = "abcde"，使用逐位搜索法会多次回溯，但是因为重复字母不多，每次回溯过后能够继续比较快的往下面进行

优化思路：

如果要优化算法，最关键的是如何更加有效地利用信息。如果两个字符串对比到i位都相同，但是i+1不同，说明至少前面i位target和source是匹配的，同时我们拥有的也只有这个信息。要把这个信息充分利用起来，需要从target字符串入手。

• 对于情况1，到target的第5位发现不匹配，但是前面4位是匹配的。另外我们可以显而易见target字符串中1～3位与2～4位是匹配的，也就是说，如果source字符串开始搜索的位置增加1位，我们马上可以得出至少前面3位的位置是匹配的，可以直接跳过，也就是p从4开始q回退到3，然后再做比较。然后再次不匹配，q又回退到2......

• 对于情况2，过程类似，p从4开始，然后q回退到3，之后能够准确的找到结果。

• 对于情况3，p=4，q=4的时候发现不匹配，同时因为我们知道target中不存在自己的一部分和自己的一部分匹配的情况，也就是说source中回溯并前进一位过后，一定不能匹配上。所以可以直接p=4，q=0重新开始匹配。

结论：

更一般的，如果我们对字符串source和target做匹配，在比较到target的第j位的时候发现不匹配(假定source搜索到了i)，那么：如果target的前j位中，存在一个最大位置k，使得target[0~(k-1)] == target[(j-k)~(j-1)] （也就是前面k位等于最后k位），那么就可以直接将j回溯到k的位置继续进行比较。

证明：

• 充分性：

1. 已知source[i‘]==target[j'](j'=0，且i-i' == j-j')，所以有 source[(i-k)~(i-1)] == target[(j-k)~(j-1)] (k<=j)
2. 如果target[0~(k-1)] == target[(j-k)~(j-1)]，那么一定有 target[0~(k-1)] == source[(i-k)~(i-1)]，所以可以继续比较source[i]和target[k]，也就是说可以把q回溯到k的位置继续进行比较。效果与逐位搜索等同。

• 必要性：

1. 如果回溯到某个位置k，但是不满足target[0~(k-1)] == target[(j-k)~(j-1)] ，那么一定存在位置k'，有target[k']!=target[j-k'](k'>=0 && k'<=k)
2. 有source[i-(j-k')] == target[k'] != target[j-k']，所以一定不能匹配成功

如何实现

问题描述

基于上面分析，问题退化为：对于一个给定字符串target，判断在前面t位中，是否存在子串a和b，满足a==b 且 a.start==0 && b.start>0 && b.end == t;

1. 对于target：abcabcde，如果t=4，
   "a"(0)=="a"(3)，如果t=5，存在"ab"(0)=="ab"(3)，如果t=7，不存在
   类似的有：
2. target：aaaaabc，如果t=3，有"aa"(0)=="aa"(1)，如果t=5，有"aaaa"(0)=="aaaa"(1)

等价于：对于字符串target，求一个数组in[] next，使得，next[j] == k，满足target[0~(k-1)] == target[(j-k)~(j-1)]

最简单的方法：

对于j，我们从0位和末尾开始逐位比较，时间复杂度最坏为O(m^2)。

优化思路：

1. 如果next[j]==k，且target[k] == target[j]，则一定有next[j+1]==k+1;
   也就是说 if (target[next[j]] == target[j]) then next[j+1]==next[j]+1;
2. 如果某个位置两个字符不相等了，那么可能前面会存在某个k'（k' target[0~(k-1)] == target[(j-k)~(j-1)] 且 target[0~(k'-1)] == target[(j-k')~(j-1)]，其中（k'0）

分析：

下面分析如何找这个k':

• 由target[0~(k-1)] == target[(j-k)~(j-1)]，可以得知 target[(j-k')~(j-1)] == target[(k-k')~(k-1)]
• 再由target[0~(k'-1)] == target[(j-k')~(j-1)]，可以得知 target[(j-k')~(j-1)] == target[0~(k'-1)]，
• 所以有：target[0~(k'-1)] == target[(k-k')~(k-1)] ，也就是 k' == next[k]，

结论：

综上我们可以得到递推的方法：
if (target[k]==target[j]) then next[j++] == k++(next[j]+1);
else k = next[k];
因为k‘可能不存在，所以还要处理边界条件。完整算法如下：

public static int[] getNext(String ps) {

char[] p = ps.toCharArray();

int[] next = new int[p.length];

next[0] = -1;

int j = 0;

int k = -1;

while (j < p.length - 1) {

   if (k == -1 || p[j] == p[k]) {

       if (p[++j] == p[++k]) { // 当两个字符相等时要跳过

          next[j] = next[k];

       } else {

          next[j] = k;

       }

   } else {

       k = next[k];

   }

}

return next;
} 

结合这个next数组，可以很简单的实现kmp算法（具体实现略）