字符串匹配之BM算法
一、前言
在用于查找子字符串的算法当中，BM（Boyer-Moore）算法是目前被认为最高效的字符串搜索算法，它由Bob Boyer和J Strother Moore设计于1977年。 一般情况下，比KMP算法快3-5倍。该算法常用于文本编辑器中的搜索匹配功能，比如大家所熟知的GNU grep命令使用的就是该算法，这也是GNU grep比BSD grep快的一个重要原因，具体推荐看下我最近的一篇译文“为什么GNU grep如此之快？”作者是GNU grep的编写者Mike Haertel。
二、BM算法原理
1.
假定字符串为"HERE IS A SIMPLE EXAMPLE"，搜索词为"EXAMPLE"。
2.
首先，"字符串"与"搜索词"头部对齐，从尾部开始比较。
这是一个很聪明的想法，因为如果尾部字符不匹配，那么只要一次比较，就可以知道前7个字符（整体上）肯定不是要找的结果。
我们看到，"S"与"E"不匹配。这时，"S"就被称为"坏字符"（bad character），即不匹配的字符。我们还发现，"S"不包含在搜索词"EXAMPLE"之中，这意味着可以把搜索词直接移到"S"的后一位。
3.
依然从尾部开始比较，发现"P"与"E"不匹配，所以"P"是"坏字符"。但是，"P"包含在搜索词"EXAMPLE"之中。所以，将搜索词后移两位，两个"P"对齐。
4.
我们由此总结出"坏字符规则"：
后移位数 = 坏字符的位置 - 搜索词中的上一次出现位置
如果"坏字符"不包含在搜索词之中，则上一次出现位置为 -1。
以"P"为例，它作为"坏字符"，出现在搜索词的第6位（从0开始编号），在搜索词中的上一次出现位置为4，所以后移 6 - 4 = 2位。再以前面第二步的"S"为例，它出现在第6位，上一次出现位置是 -1（即未出现），则整个搜索词后移 6 - (-1) = 7位。
5.
依然从尾部开始比较，"E"与"E"匹配。
6.
比较前面一位，"LE"与"LE"匹配。
7.
比较前面一位，"PLE"与"PLE"匹配。
8.
比较前面一位，"MPLE"与"MPLE"匹配。我们把这种情况称为"好后缀"（good suffix），即所有尾部匹配的字符串。注意，"MPLE"、"PLE"、"LE"、"E"都是好后缀。
9.
比较前一位，发现"I"与"A"不匹配。所以，"I"是"坏字符"。
10.
根据"坏字符规则"，此时搜索词应该后移 2 - （-1）= 3 位。问题是，此时有没有更好的移法？
11.
我们知道，此时存在"好后缀"。所以，可以采用"好后缀规则"：
后移位数 = 好后缀的位置 - 搜索词中的上一次出现位置
举例来说，如果字符串"ABCDAB"的后一个"AB"是"好后缀"。那么它的位置是5（从0开始计算，取最后的"B"的值），在"搜索词中的上一次出现位置"是1（第一个"B"的位置），所以后移 5 - 1 = 4位，前一个"AB"移到后一个"AB"的位置。
再举一个例子，如果字符串"ABCDEF"的"EF"是好后缀，则"EF"的位置是5 ，上一次出现的位置是 -1（即未出现），所以后移 5 - (-1) = 6位，即整个字符串移到"F"的后一位。
这个规则有三个注意点：
（1）"好后缀"的位置以最后一个字符为准。假定"ABCDEF"的"EF"是好后缀，则它的位置以"F"为准，即5（从0开始计算）。
（2）如果"好后缀"在搜索词中只出现一次，则它的上一次出现位置为 -1。比如，"EF"在"ABCDEF"之中只出现一次，则它的上一次出现位置为-1（即未出现）。
（3）如果"好后缀"有多个，则除了最长的那个"好后缀"，其他"好后缀"的上一次出现位置必须在头部。比如，假定"BABCDAB"的"好后缀"是"DAB"、"AB"、"B"，请问这时"好后缀"的上一次出现位置是什么？回答是，此时采用的好后缀是"B"，它的上一次出现位置是头部，即第0位。这个规则也可以这样表达：如果最长的那个"好后缀"只出现一次，则可以把搜索词改写成如下形式进行位置计算"(DA)BABCDAB"，即虚拟加入最前面的"DA"。
回到上文的这个例子。此时，所有的"好后缀"（MPLE、PLE、LE、E）之中，只有"E"在"EXAMPLE"还出现在头部，所以后移 6 - 0 = 6位。
12.
可以看到，"坏字符规则"只能移3位，"好后缀规则"可以移6位。所以，Boyer-Moore算法的基本思想是，每次后移这两个规则之中的较大值。
更巧妙的是，这两个规则的移动位数，只与搜索词有关，与原字符串无关。因此，可以预先计算生成《坏字符规则表》和《好后缀规则表》。使用时，只要查表比较一下就可以了。
13.
继续从尾部开始比较，"P"与"E"不匹配，因此"P"是"坏字符"。根据"坏字符规则"，后移 6 - 4 = 2位。
14.
从尾部开始逐位比较，发现全部匹配，于是搜索结束。如果还要继续查找（即找出全部匹配），则根据"好后缀规则"，后移 6 - 0 = 6位，即头部的"E"移到尾部的"E"的位置。
三、BM算法原理探讨
该算法的难点在于如何生成坏字符规则表和好后缀规则表。下面我们对这两个数组分别进行探讨。
1、坏字符算法
（1）坏字符算法原理
当出现一个坏字符时, BM算法向右移动模式串, 让模式串中最靠右的对应字符与坏字符相对，然后继续匹配。坏字符算法有两种情况。
Case1：模式串中有对应的坏字符时，让模式串中最靠右的对应字符与坏字符相对（PS：BM不可能走回头路，因为若是回头路，则移动距离就是负数了，肯定不是最大移动步数了），如下图。
Case2：模式串中不存在坏字符，很好，直接右移整个模式串长度这么大步数，如下图。
（2）坏字符算法具体实现
这个计算应该很容易，似乎只需要bmBc[i] = m – 1 – i就行了，但这样是不对的，因为i位置处的字符可能在pattern中多处出现（如下图所示），而我们需要的是最右边的位置，这样就需要每次循环判断了，非常麻烦，性能差。
这里有个小技巧，就是使用字符作为下标而不是位置数字作为下标。这样只需要遍历一遍即可，这貌似是空间换时间的做法，但如果是纯8位字符也只需要256个空间大小，而且对于大模式，可能本身长度就超过了256，所以这样做是值得的 （这也是为什么数据越大，BM算法越高效的原因之一）。
如前所述，bmBc[]的计算分两种情况，与前一一对应。
Case1：字符在模式串中有出现，bmBc[‘v’]表示字符v在模式串中最后一次出现的位置，距离模式串串尾的长度，如上图所示。
Case2：字符在模式串中没有出现，如模式串中没有字符v，则BmBc[‘v’] = strlen(pattern)。
写成代码也非常简单：
1 //生成坏子串数组 2 vector<int> badVect(256,needle.size()); 3 //数组最后一个值不考虑 4 for(int i = 0;i<needle.size()-1;i++){ 5 badVect[needle[i]] = needle.size()-i-1; 6 }
2、好后缀算法
（1）好后缀算法原理
如果程序匹配了一个好后缀, 并且在模式中还有另外一个相同的后缀或后缀的部分, 那把下一个后缀或部分移动到当前后缀位置。假如说，pattern的后u个字符和text都已经匹配了，但是接下来的一个字符不匹配，我需要移动才能匹配。
如果说后u个字符在pattern其他位置也出现过或部分出现，我们将pattern右移到前面的u个字符或部分和最后的u个字符或部分相同，如果说后u个字符在pattern其他位置完全没有出现，很好，直接右移整个pattern。
这样，好后缀算法有三种情况，如下图所示：
Case1：模式串中有子串和好后缀完全匹配，则将最靠右的那个子串移动到好后缀的位置继续进行匹配。
Case2：如果不存在和好后缀完全匹配的子串，则在好后缀中找到具有如下特征的最长子串,使得P[m-s…m]=P[0…s]。
注：最长子串一定是模式串的前缀串。
Case3：如果完全不存在和好后缀匹配的子串，则右移整个模式串。
（2）好后缀算法实现
这里bmGs[]的下标是数字而不是字符了，表示字符在pattern中位置。
如前所述，bmGs数组的计算分三种情况，与前一一对应。假设图中好后缀长度用数组suff[]表示。
Case1：对应好后缀算法case1，如下图，j是好后缀之前的那个位置。
Case2：对应好后缀算法case2：如下图所示：
Case3：对应与好后缀算法case3，bmGs[i] = strlen（pattern）= m
确定好好后缀子串分为以上三种情况后，需要解决以上两个问题：
a、找到suff[i]与i的定量关系。
b、确定不同情况下i与j的关系。
a、找到suff[i]与i的定量关系
suff数组的定义：m是pattern的长度
看上去有些晦涩难懂，实际上suff[i]就是求pattern中以i位置字符为后缀和以最后一个字符为后缀的公共后缀串的长度。不知道这样说清楚了没有，还是举个例子吧：
i : 0 1 2 3 4 5 6 7
pattern: b c a b a b a b
当i=7时，按定义suff[7] = strlen(pattern) = 8
当i=6时，以pattern[6]为后缀的后缀串为bcababa，以最后一个字符b为后缀的后缀串为bcababab，两者没有公共后缀串，所以suff[6] = 0
当i=5时，以pattern[5]为后缀的后缀串为bcabab，以最后一个字符b为后缀的后缀串为bcababab，两者的公共后缀串为abab，所以suff[5] = 4
以此类推……
当i=0时，以pattern[0]为后缀的后缀串为b，以最后一个字符b为后缀的后缀串为bcababab，两者的公共后缀串为b，所以suff[0] = 1
这样看来代码也很好写：
1 //生成suff 2 for(int i = 0;i<needle.size()-1;i++){ 3 // int count = 0; 4 int j = 0; 5 while(((i-j)>=0)&&(needle[i-j]==needle[needle.size()-j-1])){ 6 j++; 7 } 8 suff[i] = j; 9 }
b、确定不同情况下i与j的关系。
1 //好子串下标j 2 int j = 0; 3 for(int i = 0;i<needle.size();i++){ 4 if(suff[i] == i+1){ 5 for(;j<needle.size()-i;j++){ 6 goodVect[j] = needle.size()-suff[i]; 7 } 8 } 9 else{ 10 j = needle.size()-suff[i]-1; 11 goodVect[j] = needle.size()-i-1; 12 } 13 }
整体代码如下：
1 class Solution { 2 public: 3 int strStr(string haystack, string needle) { 4 5 //S2 BM算法 6 if(needle.empty()) return 0; 7 if(haystack.empty()) return -1; 8 //生成坏子串数组 9 vector<int> badVect(256,needle.size()); 10 //数组最后一个值不考虑 11 for(int i = 0;i<needle.size()-1;i++){ 12 badVect[needle[i]] = needle.size()-i-1; 13 } 14 //生成好子串数组 15 vector<int> goodVect(needle.size(),needle.size()); 16 vector<int> suff(needle.size(),needle.size()); 17 //生成suff 18 for(int i = 0;i<needle.size()-1;i++){ 19 // int count = 0; 20 int j = 0; 21 while(((i-j)>=0)&&(needle[i-j]==needle[needle.size()-j-1])){ 22 j++; 23 } 24 suff[i] = j; 25 } 26 //好子串 27 //好子串下标j 28 int j = 0; 29 for(int i = 0;i<needle.size();i++){ 30 if(suff[i] == i+1){ 31 for(;j<needle.size()-i;j++){ 32 goodVect[j] = needle.size()-suff[i]; 33 } 34 } 35 else{ 36 j = needle.size()-suff[i]-1; 37 goodVect[j] = needle.size()-i-1; 38 } 39 } 40 //匹配 41 j = 0; 42 int i; 43 int n = haystack.size(); 44 int m = needle.size(); 45 while(j <= n - m) 46 { 47 for( i = m - 1; i >= 0 && needle[i] == haystack[i + j]; i--); 48 if(i < 0) 49 { 50 return j; 51 j += goodVect[0]; 52 } 53 else 54 { 55 j += max(badVect[haystack[i + j]] - m + 1 + i, goodVect[i]); 56 } 57 } 58 return -1; 59 60 } 61 };
