KMP算法

KMP算法

1.KMP算法简介

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算>> 法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配>> 信息。时间复杂度O(m+n)。

2.KMP算法与确定性有限状态自动机DFA

2.1 DFA与KMP算法

子串查找问题通常会存在两个字符串，一个是原串s, 另一个是模式串p，设m = len(s), n = len(p)并且通常m >> n。

对于子串查找问题，很朴素、直接的一个解法就是暴力求解法，即从s中的第0个字符开始，将原串s中的每一个字符和模式串p的每一个字符进行比较，若全部匹配成功，则返回；否则，则从s中的第1个字符开始，重复之前的比较操作直到到达s的最后一个字符；

从上述的描述中易得出 暴力解法 的时间复杂度是O(nm),暴力解法的缺点：
- 时间复杂度高；
- 不适用于字符流的情况；当原串s是字符流（例如网络字符）的时候，该解法存在回溯，若不加额外的缓存，是不能用于此类问题的；

但是,大多数情况下，原串和模式串都比较小，也都不是字符流的情况，而采用高级算法通常都用一些预处理的过程，对于小规模问题这都是不划算的，因此暴力解法还是很常用的，比如jdk的indexOf()就是采用暴力解法实现的。

从暴力解法的描述可以看出，当从s的字符i开始，与模式串p逐字符比较时，若在i+k处发生失配时，指向s的指针是需要回溯到i+1继续逐字符比较，而没有利用好已经匹配好的k个字符。

KMP算法解决的问题是：当发生字符失配的时候，不回溯指针i。这样就能克服 暴力解法 的两个缺点。

KMP算法核心的思想是：当发生字符失配的时候，充分利用已经匹配成功的k个字符的信息，避免指针i的回溯

KMP算法可以用确定性有限状态机DFA来直观的阐述。
DFA
- 包含有限的状态（包括开始和停止）
- 每一个字符只发生一次状态的转移
- 如果一系列的状态转移到了停止状态，则匹配成功

关键在于如何根据模式串p构建DFA，略。

2.2 DFA子串查找

public class DFASubStringSearchDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub        char[] radixChar = new char[] {'A', 'B', 'C', 'D',                'E', 'F', 'G', 'H',                'I', 'J', 'K', 'L',                'M', 'N', 'O', 'P',                'Q', 'R', 'S', 'T',                'U', 'V', 'W', 'X',                'Y', 'Z'};        String txt = "ABCBDBCBABCBCBABBWEHJHHOISCBIIOSAOPOPIOHUCUIBSYGTWBNIOAUSABCBDBCBABCBCBABBCBABCCCAASASADSWFEFSDBCBABCCCAASASADSWFEFSDB";        System.out.println(txt.length());        String pattern = "ABC";        DFASubStringSearchDemo demo  = new DFASubStringSearchDemo();        int[][] dfa = demo.buildDfa(pattern, radixChar);        int startIndex = demo.search(txt, pattern, dfa);        System.out.println(startIndex);        String target = startIndex+pattern.length() <= txt.length() ? txt.substring(startIndex, startIndex+pattern.length()) : "NO MATCH";        System.out.println(target);    }    public int[][] buildDfa(String pattern, char[] radixChar) {        int[][] dfa = new int[radixChar.length][pattern.length()];        dfa[pattern.charAt(0)-'A'][0] = 1;        for (int X = 0, j = 1; j < pattern.length(); j++) {            for (int c = 0; c < radixChar.length; c++)                dfa[c][j] = dfa[c][X];            dfa[pattern.charAt(j)-'A'][j] = j+1;            X = dfa[pattern.charAt(j)-'A'][X];        }        return dfa;    }    public int search(String txt, String pattern, int[][] dfa) {        int n = txt.length(), m = pattern.length(), i = 0, j = 0;        for (; i < n && j < m; i++)            j = dfa[txt.charAt(i)-'A'][j];//状态转移        if (j == m)            return i - m;        else            return n;    }}

3. KMP算法的主流实现

3.1 next数组

next[j]数组表示模式串p的位置j发生失配时，应该从next[j]处继续匹配，而不用回溯原串s的i指针。
同时，next[j]的值也是表示模式p[0~j-1]的最长公共前后缀的长度。

3.2 具体实现

kmp算法

    public int kmp(String txt, String pattern, int[] next) {        int i = 0, j = 0;        for (; i < txt.length() && j < pattern.length();) {            if (j == -1 || txt.charAt(i) == pattern.charAt(j)) {                i++;                j++;            } else {//mismatch 利用next数组得到j回退的位置                j = next[j];            }        }        if (j == pattern.length())            return i - j;        else            return -1;//not found    }

关键在于构建next数组

public int[] getNext(String pattern) {        int[] next = new int[pattern.length()];        next[0] = -1;        int k = -1;        int j = 0;        while (j < pattern.length() - 1) {            if (k == -1 || pattern.charAt(j) == pattern.charAt(k)) {                j++;k++;                if (pattern.charAt(j) == pattern.charAt(k))                    next[j] = next[k];//j和k字符相同，因此j发生失配时，若跳转到k，则k也会发生失配，继而跳转到next[k]，所以不如直接一步到位，将k的next值而不是k赋值给next[j]；                else                    next[j] = k;            } else {                k = next[k];//k backup until pattern[k] == pattern[j]            }        }        return next;    }