对KMP算法的理解

背景

KMP算法看了很多回，但是每次回忆起来都有一些关键点感觉理解的很模糊，这次仔细研究了一下KMP，给出一个自己的理解。

构造next数组

1 构造数组，使得该数组满足i>0时，$[P_0,P_{{\text{next}}_i})=[P_{i-{\text{next}}_i},P_i)$，我们称其为一个不完全next数组，构造方法如下：

因为对任意nexti(i>0)有，故一个全零数组为不完全next数组。

1. i=0的情况另行讨论
2. [$P_0$,$P_{{\text{next}}_i}$)表示P的子串，前闭后开区间

现在我们来优化next数组，使数组内元素尽可能大。

若 $P_{{\text{next}}_i+1}=P_{i+1}$, 对于$P_{{\text{next}}_i}$有$[P_0,P_{{\text{next}}_i})=[P_{i-{\text{next}}_i},P_i)$，

则 $[P_0,P_{{\text{next}}_i+1})=[P_{i-{\text{next}}_i},P_{i+1})$

设$j=i+1$, k=${\text{next}}_i+1$，代入得 $[P_0,P_k)=[P_{j-k},P_j)$ 即${\text{next}}_j=k$， 元素代回后有 ${\text{next}}_{i+1}={\text{next}}_i+1$

所以next数组的求法为，初始化一个全零数组，从1开始遍历，若$P_{{\text{next}}_i+1}=P_{i+1}$，则 ${\text{next}}_{i+1}={\text{next}}_i+1$;

 private static int[] getNext(String pattern){
    int[] next = new int[pattern.length()];

    for (int i = 2; i < pattern.length(); i++) {
        if(pattern.charAt(next[i-1]) == pattern.charAt(i-1)){
            next[i] = next[i-1]+1;
        }
    }

    next[0]=-1;

    return next;
}

可以用反证法证明这样求出的数组是最大的不完全next数组，因为这个数组是最大的，所以对于任意 ${\text{next}}_i<k<i$, 有 $[P_0,P_k)\ne [P_{i-k},P_i)$ ，我们称这个最大的不完全next数组为next数组

证明KMP

设指针j、i分别指向主串和模式串中正在匹配的字符，则 $S_{j-i}=P_0$ 是第一个匹配的字符，匹配过程中需要一直满足 $[S_{j-i},S_j)=[P_0,P_i)$ , 若

1. 若 $S_j=P_i$ ，易得 $[S_{j-i},S_{j+1})=[P_0,P_{i+1})$ 。
2. $S_j\ne P_i$， 则令 $j=j-i+1,i=0$ ; 有$[S_{j-i+1},S_{j-i+1=0})=[P_0,P_0)$ ，遍历 $S_{j-i+1}=P_0$ 是第1个匹配的字符的情况

此时为暴力匹配算法

 public static int bfFind(String S, String P) {
    char[] arr1 = S.toCharArray();
    char[] arr2 = P.toCharArray();
    int i = 0;
    int j = 0;
    while(j < arr1.length && i < arr2.length) {
        // kmp这里要补上arr1[j] != arr2[0]的情况
        // if(i==0 && arr1[j] == arr2[i]){j=j+1;continue;}
        if(arr1[j] == arr2[i]) {
            j++;
            i++;
        }
        else {
            j = j - i + 1;
            i = 0;
            // kmp, 这里替换成 j=j; i=next[i];
        }
    }
    if(i == arr2.length) return j - i;
    else return -1;
}

如果$S_{j+i}\ne P_i$， 因为$[S_{j-i},S_j)=[P_0,P_i)$，所以$[S_{j-{\text{next}}_i},S_j)=[P_{i-{\text{next}}_i},P_i)$，又根据next数组的定义有 $[P_{i-{\text{next}}_i},P_i)=[P_0,P_{{\text{next}}_i})$，所以$[S_{j-{\text{next}}_i},S_j)=[P_0,P_{{\text{next}}_i})$

又因为 对于任意$\text{next}_i<k<i, 有 $[P_0,P_k)\ne [P_{i-k},P_i)$，即 $[S_{j-k},S_j)\ne [P_0,P_k)$ ，所以可以跳过第一个匹配字符在 $[S_{j-i},S_{j-{\text{next}}_i})$ 中的情况

next[0] = -1 的情况

$S_j\ne P_0$时，有j=j+1, i=i+1=0，遍历下一种情况，这样就不用单独处理$S_j\ne P_0$的情况了，贴一下优化后的代码。

 private static int[] getNext(String pattern) {
    //获取两串的字符数组，以便遍历
    char patternOfChars[] = pattern.toCharArray();
    //创建next数组
    int[] next = new int[pattern.length()];
    int nextValue = -1, loopOfPattern = 0;//初始化next值及模式串下标
    next[0] = -1;//这里采用-1做标识
    while(loopOfPattern < pattern.length() -1)
    {
        //获取next数组
        if(nextValue == -1 || patternOfChars[loopOfPattern] == patternOfChars[nextValue])
        {
            nextValue++;
            loopOfPattern++;
            next[loopOfPattern] = nextValue;
        } else {
            nextValue = next[nextValue];
        }
    }
    return next;
}

public static int kmp(String str, String pattern) {
    //如果主串长度不小于模式串，则进入模式匹配
    if (str.length() >= pattern.length()) {
        //获取next数组
        int next[] = getNext(pattern);

        //获取两串的字符数组，以便遍历
        char strOfChars[] = str.toCharArray();
        char patternOfChars[] = pattern.toCharArray();

        //两个循环控制变量
        int loopOfStr, loopOfPattern;
        //遍历主串，任意一串遍历结束，则匹配结束
        for (loopOfStr = 0, loopOfPattern = 0 ; loopOfStr < str.length() && loopOfPattern < pattern.length() ;) {
            //如果两元素相同，或模式串全部匹配失败，比较下一个元素
            if (loopOfPattern == -1 || strOfChars[loopOfStr] == patternOfChars[loopOfPattern]) {
                loopOfStr++;
                loopOfPattern++;
            } else {
                loopOfPattern = next[loopOfPattern];//模式串下标置为next值
            }
        }

        //模式串匹配结束，表示匹配成功
        if (loopOfPattern == pattern.length()) {
            return loopOfStr - loopOfPattern;//主串中模式串第一次出现的位置
        }
    }

    //模式匹配失败
    return -1;
}