KMP算法

题目：

        给定两个字符串 str 和 match，长度分别为 N 和 M ，实现一个算法，如果字符串str中含有子串match，则返回match在str中的开始位置，不含有返回-1

举例：

       str = "acbc",  match =  "bc",  则返回2。

       str = "acbc",  match =  "bcc", 则返回-1.

KMP算法思路：

1.首先生成match字符串的next数组， 数组的长度与match字符串的长度一样，next[i] 表示在 match[i] 之前的字符串 match[0...i-1]中，必须以match[i-1] 结尾的

  后缀子串（不含match[0]）与必须以match[0]开头的前缀子串（不含match[i-1]）最大匹配长度是多少。这个长度就是next[i]的值。

2.假设从str[i] 字符出发时，匹配到 j 位置的字符发现与match中的字符不一致。也就是说，str[i] 与 match[0] 一样，并且从这个位置开始一直可以匹配，即str[i...j-1]

   与match[0...j-i-1] 一样，直到发现str[j] != match[j - i] , 匹配停止。

3. 下一次匹配检查不再像普通解法那样退回到str[i+1] 重新开始与 match[0] 的匹配过程，而是直接让str[j] 与 match[k] 进行匹配检查，然后进行后序的匹配检查。

int getIndexOf(string s, string m)
{
	if(m.length() < 1 || s.length() < m.length())
		return -1;
	int i=0, j=0;
	vector<int> next(m.length());
	getNext(m, next);
	while(i < s.length() && j < m.length())
    {
		if(s[i] == m[j])
	    {
			i++;
			j++;
		}
		else if(next[j] == -1)
			i++;
		else
			j = next[j];
	}
	return j == m.length() ? i - j : -1;
}

next数组的求解：

对于match[0]来说，在它之前没有字符，规定next[0] = -1,   对match[1] 来说，在它之前有match[0], 但next数组的定义要求任何子串的后缀不能包括第一个字符（match[0]）,

所以match[1] 之前的字符串只有长度为0的后缀字符串，所以next[1] = 0.  对于 i > 1 的match[i]  的next数组求解如下：

1.  因为从左往右求解next，所以在求解next[i] 时， next[0....i-1] 的值都已经求出。通过next[i-1]的值可以知道B字符前的最长前缀与最长后缀匹配区域，然后看字符c 与字符B是

     否相等。

     

2. 如果字符C与字符B相等，那么A字符之前的字符串的最长前缀与最长后缀匹配区域就可以确定，前缀子串为 L区域 + C字符， 后缀子串为 K区域 + B字符，

    即next[i] = next[i-1] + 1

3. 如果字符C与字符B不相等，就看字符C之前的前缀和后缀匹配情况，假设字符C是第cn个字符（match[cn]）,那么next[cn] 就是其最长前缀和后缀匹配长度

     m区域和n区域分别是字符C之前的字符串的最长匹配的后缀与前缀区域，这是通过next[cn]确定的。当然这两个区域是相等的，m' 区域为 k 区域最右的

    区域且长度与m区域一样，因为 k 区域与 L 区域是相等的，所以 m 区域和 m' 区域也相等，字符 D 为 n 区域之后的一个字符，接下来比较字符 D 是否与字符 B 相等。

               1）如果相等，A 字符之前的字符串的最长前缀与后缀陪陪区域就可以确定，前缀子串为 n 区域 + D 字符， 后缀子串为 m' 区域 + B 字符， 则next[i] = next[cn] + 1

               2）如果不等，继续前往跳到字符 D ， 之后的过程与调到字符 C 类似，一直进行这样的跳过程， 跳的每一步都会有一个新的字符和B比较（就像C字符和C字符

                    一 样），只要有相等的情况， next[i] 的值就能确定。

4. 如果向前跳到最左位置（即match[0] 的位置）， 此时 next[0] == -1 , 说明字符 A 之前的字符串不存在前缀和后缀匹配的情况，则令 next[i] = 0,   用这种不断向前跳的方式

   可以算出正确的next[i] 值的原因还是因为每跳一个位置 cn， next[cn] 的意义就表示它之前字符串的最大匹配长度。

void getNext(string& m, vector<int>& next)
{
	next[0] = -1;
	if(m.length() == 1)
		return ;
	next[1] = 0;
	int pos = 2;
	int cn = 0;
	while(pos < next.size())
	{
		if(cn == -1 || m[pos-1] == m[cn])
			next[pos++] = ++cn;
		else //if(cn > 0)
			cn = next[cn];
		//else
			//next[pos++] = 0;
	}
}