【KMP算法】这次终于学会了！

对应leetcode 28题~

动机

朴素的串匹配方法复杂度为$O(mn)$。

而其中包含一些不必要的匹配检查，能否通过已经匹配了的部分抽取一些信息，减少不必要的匹配呢？

Next数组的值

$Next[k]$表示模式串$P[1\dots k]$的最长相同前后缀长度。

当发现主串$T[i]$和$P[k]$出现不匹配时，KMP算法将模式串P向后滑动，下一步让主串$T[i]$和$P[next[k-1]]$进行匹配。

即实际上是从模式串$P[1\dots k-1]$相同前后缀的下一个字符开始，与$T[i]$继续进行匹配。

以next为2和4的情况进行示例，next越大，P往后滑动的距离其实越少：

为什么是相同前后缀？假设出现匹配失败：

设主串为T，模式串为P，$T[0\dots i-1]$与$P[0\dots j-1]$匹配，在$T[i]$与$P[j]$匹配失败。

假设我们下一步要将$P[k]$与$T[i]$进行匹配，若希望$P[0,\dots ，k-1]$与$T[i-k,\dots ,i-1]$能匹配上。应满足：
$$P[0\dots k-1]=P[j-k,\dots ,j-1]$$
下面这张图是理解的关键：

假设已经得到了next数组：

	public int strStr(String haystack, String needle) {
        if ("".equals(haystack) || "".equals(needle)) {
            return -1;
        }

        char[] T = haystack.toCharArray();
        char[] P = needle.toCharArray();
        int[] next = getNextArray(P);

        int i = 0;
        int j = 0;
        
        // 模式串P还没有走完，还没有匹配成功
        // 主串T还没有走完，还有希望
        while (i != haystack.length() && j != needle.length()) {
            if (T[i] == P[j]) {
                i++;
                j++;
            }
            else {
                // 模式串的第一个字符就莫得匹配上哦，糟糕，把i后移一位试试看吧
                if (j == 0) {
                    i++;
                }
                else {
                    // 不是从头开始让j=0,i++
                    // 而是可以从i和next[j-1]的位置继续匹配
                    j = next[j - 1];
                }
            }
        }
		
        // P走完惹
        if (j == needle.length()) {
            return i - j;
        }

        return -1;
    }

怎么得到Next数组？

设$next[i]$表示串$P[0\dots i]$的最长相同前后缀。

若$next[0\dots i-1]$已知，可递推得到$next[i]$：

1. $k=next[i-1]$
2. 如果$P[k]=P[i]$，$next[i]=k+1$，计算结束
3. 否则：
   • 如果$k>0$，令$k=next[k-1]$，转向步骤2
   • 如果$k=0$，$next[i]\leftarrow P[0]=P[i]?1:0$；

解释如下：

理解的关键在于$P[0\dots k-1]$的最长相等前缀一定为$P[0\dots i-1]$的相等前缀。

下图中蓝色圆圈内的数字表示进行比较。

	public int[] getNextArray(char[] pattern) {
        int[] next = new int[pattern.length];
        // 初始化
        next[0] = 0;

        // 递增设置next[i]
        for (int i = 1; i < next.length; i++) {
            int k = i;
            while (true) {
                // 找到 P[0,...,k-1]的最长公共前后缀位置
                k = next[k - 1];
                // 判断该公共前后缀能否再加入pattern[i]
                if (pattern[k] == pattern[i]) {
                    next[i] = k + 1;
                    break;
                }
                // 判断k是否为0，若为0可直接退出，上面已检查过pattern[0]与pattern[i]是否相等
                if (k == 0) {
                    next[i] = 0;
                    break;
                }
            }
        }
        return next;
    }