KMP算法

KMP算法简介

kmp算法是模式匹配的一种算法，假设我们有两个字符串，主串T和模式串P，我们需要设计一个方法，使得如果P在T中出现，就返回P出现的位置，否则返回-1。

一般的想法是：

// i是在主串T移动的index，j是在模式串P移动的index
while (i < T.length && j < P.length){
	if (T[i] == P[j]){// 当两个字符相同，就比较下一个
		i++;
		j++;
	}
	else{
		i = i-j+1;// 一旦不匹配，i后退
		j = 0 // j归0
	}
}
if (j == P.length){//j走到了P的最后一位，说明匹配上了
	return i-j
}
else{
	return -1
}

这种算是暴力破解，其实走了很多不需要的步骤。kmp的想法是，如果模式串P中出现如下情况：

T：ABACDABAEF
P：ABACDABABC

此时 i=8,j=8, 注意到模式串P在位置j之前有重复部分“ABA”，那么下一次匹配应该是：i不动，j跳到下图k的位置

这样的话，我们对比的就是：

T：ABACDABAEF
P： \quad\qquad ABACDABABC

其中这个k满足：P[0 : k-1] = P[j-k : j-1]
证明：当T[i] != P[j]时，
已有：T[0 : i-1] == P[0: j-1]
又有：P[0 : k-1] == P[j-k : j-1]
所以：T[i-k : i-1] == P[j-k : j-1] == P[0 : k-1]

我们称这样的“ABA”是最大前缀（后缀）字串。

---

KMP算法实现

要实现kmp算法，我们首先需要一个getNext()函数，它返回一个next数组，其中next[j] = k，表示当T[i] != P[j]时，j指针跳到位置k。

getNext()函数实现

首先我们注意到：当P[j] = P[k]时，由于 P[0 : k-1] = P[j-k : j-1]， 所以 P[0 : k] = P[j-k : j]，也就是说 P[0 : k] = P[(j+1)-(k+1) : j]，因此next[j+1] = k+1。

通俗的解释是：已知位置k之前的k个字符串（前缀子串）与位置j之前的k个字符串（后缀子串）相同，而位置k上的字符又与位置j上的字符相同，因此最大前缀（后缀）子串长度由k变成了k+1。

#############
也就是如下这种情况：

T：ABACDABCEF
P：ABACDABABE
此时 j = 7, k = 2，且 P[j] = P[k] = A，那么当T[i] != P[j+1]时，就应该是下面的情况：
T：…ABACDABAEF
P： \quad ABACDABABE
此时 j+1 = 8，而 next[j+1] = 3，也即是next[j+1] = next[k]+1 = k+1

#############
而当P[j] != P[k]时：
T：ABADABACEF
P：ABADABADBE
此时 j=8, next[7]=k=3 。但由于 P[j] != P[k]，也就是说最长前缀（后缀）子串的长度无法再增加了，那么这个时候就应该回退k，往前找一找有没有短一些的最长前缀（后缀）子串。下面的问题是：k应该回退到什么位置？

答案是k应该回退到next[k]，在上面的例子里，k就应该回退到 next[3]=1，然后再去比较P[j]和新的P[k]。因为回退到next[k]，可以保证P[0 : next[k]-1]与P[j-next[k] : j-1]是相同的，这样的话我们可以找个一个新的前缀（后缀）子串，然后再判断P[j]是否等于P[k]，也就回到了之前的循环。

所以我们可以有如下getNext()函数:

    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]) {//这里 k == -1 表示，上一步 k回退到 next[k] = -1，也就是最长前缀（后缀）子串又归零了，又要从头开始匹配
                next[++j] = ++k;//当P[j] = P[k]，next[j+1] = k+1
            } 
            else {
                k = next[k];//否则，k回退到next[k]，找到一个短一点的新的前缀（后缀）子串，再重新比较p[j]和新的p[k]
            }
        }
        return next;
    }

测一个例子：

        String a = "ABCABFGABCG";
        int[] b = getNext(a);
        for (int i=0; i < b.length; i++){
            System.out.println(b[i]);

得到getNext(a)为[-1,0,0,0,1,2,0,0,1,2,3]

KMP实现

有了getNext()函数之后，我们就可以实现KMP算法：

public static int KMP(String ts, String ps) {
    char[] t = ts.toCharArray();
    char[] p = ps.toCharArray();
    int i = 0; // 主串的位置
    int j = 0; // 模式串的位置
    int[] next = getNext(ps);
    while (i < t.length && j < p.length) {
       if (j == -1 || t[i] == p[j]) { // 当j为-1时，要移动的是i，当然j也要归0
           i++;
           j++;
       } 
       else {
           // i不需要回溯了
           j = next[j]; // j回到指定位置
       }
    }

    if (j == p.length) {
       return i - j;
    } else {
       return -1;
    }
}

Reference:

1. KMP算法详解