BM算法

BM(Boyer-Moore)算法，非常高效的字符串匹配算法。

       BM算法的核心思想
       我们把模式串和主串的匹配过程，看作模式串在主串中不停地往后滑动。当遇到不匹配的字符时，BF 算法和 RK 算法的做法是，模式串往后滑动一位，然后从模式串的第一个字符开始重新匹配。

       BM算法就是寻找在字符串中出现的规律。有时候就会跳过一些肯定不会匹配的情况。

       BM算法原理：包含两部分,坏字符规则和好后缀规则。
       坏字符规则:我们从模式串的末尾向前倒着匹配，当我们发现某个字符没法匹配的时候，我们就称这个字符为坏字符(主串中的字符).

       我们拿坏字符 c 在模式串中查找，发现模式串中并不存在这个字符。这个时候，我们可以将模式串直接往后滑动三位，将模式串滑动到 c 后面的位置，再从模式串的末尾字符开始比较。
       当发生不匹配的时候，我们把坏字符对应的模式串中的字符下标记作 si。如果坏字符在模式串中存在，我们把这个坏字符在模式串中的下标记作 xi。如果不存在，我们把 xi 记作 -1。那模式串往后移动的位数就等于 si-xi。（注意，我这里说的下标，都是字符在模式串的下标）。

       还需要用到好后缀规则:
       从后往前逐位比较模式串与主串的字符，当出现坏字符时停止。若存在已匹配成功的子串｛u｝，那么在模式串的｛u｝前面找到最近的｛u｝，记作｛u’｝。再将模式串后移，使得模式串的｛u’｝与主串的｛u｝重叠。若不存在｛u’｝，则直接把模式串移到主串的｛u｝后面。为了没有遗漏，需要找到最长的、能够跟模式串的前缀子串匹配的，好后缀的后缀子串（同时也是模式串的后缀子串）。然后把模式串向右移到其左边界，与这个好后缀的后缀子串在主串中的左边界对齐。
       在模式串中，查找跟好后缀匹配的另一个子串；
       在好后缀的后缀子串中，查找最长的、能跟模式串前缀子串匹配的后缀子串；

       因为后缀子串的最后一个字符的位置是固定的，下标为 m-1，我们只需要记录长度就可以了。通过长度，我们可以确定一个唯一的后缀子串。

       BM 算法核心思想是，利用模式串本身的特点，在模式串中某个字符与主串不能匹配的时候，将模式串往后多滑动几位，以此来减少不必要的字符比较，提高匹配的效率。BM 算法构建的规则有两类，坏字符规则和好后缀规则。好后缀规则可以独立于坏字符规则使用。因为坏字符规则的实现比较耗内存，为了节省内存，我们可以只用好后缀规则来实现 BM 算法。

       可以查看BM算法文档中的图挺好的。

    http://www.cs.jhu.edu/~langmea/resources/lecture_notes/boyer_moore.pdf

package LeetCode;

public class BM {
    private static final int SIZE = 256;
    private static  void generateBC(char[] b,int m,int[] bc){
        for(int i=0;i= 0; --j) {  //模式串从后向前匹配
                if (a[i + j] != b[j]) break; //坏字符对应模式串中的下标是j
            }
            if (j < 0) {
                return i; //匹配成功，返回模式串与主串第一个匹配的字符的位置
            }
            //这里等同于将模式串往后滑动 j -bc[(int)a[i+j]]位
            i = i + (j - bc[(int) a[i + j]]);
        }
        return -1;
    }
    // b 表示模式串，m 表示长度，suffix，prefix 数组事先申请好了
    private static void generateGS(char[] b, int m, int[] suffix, boolean[] prefix) {
        for (int i = 0; i < m; ++i) { // 初始化
            suffix[i] = -1;
            prefix[i] = false;
        }
        for (int i = 0; i < m - 1; ++i) { // b[0, i]
            int j = i;
            int k = 0; // 公共后缀子串长度
            while (j >= 0 && b[j] == b[m-1-k]) { // 与 b[0, m-1] 求公共后缀子串
                --j;
                ++k;
                suffix[k] = j+1; //j+1 表示公共后缀子串在 b[0, i] 中的起始下标
            }

            if (j == -1) prefix[k] = true; // 如果公共后缀子串也是模式串的前缀子串
        }
    }
    // a,b 表示主串和模式串；n，m 表示主串和模式串的长度。
    public static int bmEnd(char[] a, int n, char[] b, int m) {
        int[] bc = new int[SIZE]; // 记录模式串中每个字符最后出现的位置
        generateBC(b, m, bc); // 构建坏字符哈希表
        int[] suffix = new int[m];
        boolean[] prefix = new boolean[m];
        generateGS(b, m, suffix, prefix);
        int i = 0; // j 表示主串与模式串匹配的第一个字符
        while (i <= n - m) {
            int j;
            for (j = m - 1; j >= 0; --j) { // 模式串从后往前匹配
                if (a[i+j] != b[j]) break; // 坏字符对应模式串中的下标是 j
            }
            if (j < 0) {
                return i; // 匹配成功，返回主串与模式串第一个匹配的字符的位置
            }
            int x = j - bc[(int)a[i+j]];
            int y = 0;
            if (j < m-1) { // 如果有好后缀的话
                y = moveByGS(j, m, suffix, prefix);
            }
            i = i + Math.max(x, y);
        }
        return -1;
    }

    // j 表示坏字符对应的模式串中的字符下标 ; m 表示模式串长度
    private static int moveByGS(int j, int m, int[] suffix, boolean[] prefix) {
        int k = m - 1 - j; // 好后缀长度
        if (suffix[k] != -1) return j - suffix[k] +1;
        for (int r = j+2; r <= m-1; ++r) {
            if (prefix[m-r] == true) {
                return r;
            }
        }
        return m;
    }

    public static void main(String[] args) {
        String a = "qwertyuiop";
        String b = "tqw";
        char[] A = a.toCharArray();
        char[] B = b.toCharArray();
        System.out.println(bmEnd(A,A.length,B,B.length));
    }


}

       KMP算法
       KMP 算法的核心思想，跟上一节讲的 BM 算法非常相近。我们假设主串是 a，模式串是 b。在模式串与主串匹配的过程中，当遇到不可匹配的字符的时候，我们希望找到一些规律，可以将模式串往后多滑动几位，跳过那些肯定不会匹配的情况。
       我们只需要拿好前缀本身，在它的后缀子串中，查找最长的那个可以跟好前缀的前缀子串匹配的。假设最长的可匹配的那部分前缀子串是{v}，长度是 k。我们把模式串一次性往后滑动 j-k 位，相当于，每次遇到坏字符的时候，我们就把 j 更新为 k，i 不变，然后继续比较。
       好前缀的所有后缀子串中，最长的可匹配前缀子串的那个后缀子串，叫做最长可匹配后缀子串，对应的前缀子串，叫做最长可匹配前缀子串。

       next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。
       最长前缀：是说以第一个字符开始，但是不包含最后一个字符。
       对于目标字符串ababaca，长度是7，所以next[0]，next[1]，next[2]，next[3]，next[4]，next[5]，next[6]分别计算的是 a，ab，aba，abab，ababa，ab abac，aba baca 的相同的最长前缀和最长后缀的长度。由于a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀是“”，“”，“a”，“ab”，“aba”，“”，“a”,所以next数组的值是[-1,-1,0,1,2,-1,0]，这里-1表示不存在，0表示存在长度为1，2表示存在长度为3。这是为了和代码相对应。

       可以阅读这篇博文
https://blog.csdn.net/starstar1992/article/details/54913261

package LeetCode;

public class KMP {
    //a,b分别是主串和模式串，n,m分别是主串和模式串的长度
    public static int kmp(char[] a,int n,char[] b,int m){
        int[] next = getNexts(b,m);
        int j=0;
        for(int i=0;i 0 && a[i] != b[j]){// 一直找到a[i]和b[j]]]
                j = next[j-1] + 1;
            }
            if(a[i] == b[j]){
                ++j;
            }
            if(j == m){//找到模式匹配串了
                return i - m +1;
            }
        }
        return -1;
    }

    private static int[] getNexts(char[] b, int m) {
        //next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。
        int[] next = new int[m];
        next[0] = -1;
        int k = -1;
        for (int i=1;i