最近由于某些原因，又回顾了一次KMP算法。上一次回顾KMP算法还是在刷题的时候遇到的：

http://blog.csdn.net/dacc123/article/details/50994611

在我的记忆力，每次回顾KMP算法都会有新的理解，以为自己理解的很透彻了，等过一段时间再去回顾，又要花一些时间去弄门清。这次也一样。

刚接触Next数组的时候我很反感字符串前缀和后缀的最长公共子串的长度来解释next数组，我认为next数组就是一个字符串的对称程度。在这样的理解之下，计算next数组的理解就是：

在求解next数组的时候，若前面一个next数,为0，那么说明前面没有对称的，新加的字符如果要对称只可能和第一个字符开始比较。如果next数不为0，说明前面一个字符是有和它对称的，那么去找和他对称的字符的下一个字符，如果相等那么next值就++，如果不相等只能等于0了。

从今天看来，这个对称理解显然是错误的，很容把误导到回文串里面的前后对称。KMP算法其实很简单，就从前缀和后缀去理解他，这也是他算法的核心思想。

下面举个例子：

第一次匹配：从第0位开始，匹配到第7位都是相同的，最后一位发现不一样了就是第8位

0   1    2   3   4   5    6   7   8

a   b   c    x   y    a   b   c   x   y   a -------------目标字符串

a   b   c    x   y    a   b   c   1     -----------------模式字符串

接下来：

如果是暴力的话，应该是模式字符串向前移动一位，进行比较，发现第一位有不匹配的继续移动。

0   1    2   3   4   5    6   7   8

a   b   c    x   y    a   b   c   x   y  a -------------目标字符串

     a   b   c    x    y   a   b   c   1     -----------------模式字符串

假设暴力移动了x位，终于有可能匹配了，这里是有可能。那么情况一定是这样：

0   1    2   3   4   5    6   7   8

a   b   c    x   y    a   b   c   x   y   a -------------目标字符串

                         a   b   c   x   y   a   b   c   1     -----------------模式字符串

模式字符串的a , b ,c和目标的5，6，7位是相同的，（我们不看第8位以及后面的只看0~7）。这样才有可能匹配（前面移动的都是从第一位就pass掉了）。

那么回到第一步：

0   1    2   3   4   5    6   7   8

a   b   c    x   y    a   b   c   x   y   a -------------目标字符串

a   b   c    x   y    a   b   c   1     -----------------模式字符串

在发现第8位不匹配的时候，我们之前暴力推算过，向前移动5位，才有可能匹配。（只看0~7位）前7位都是相同的，我们可以找到规律，为什么移动5位才有可能匹配:

a   b   c   x   y   a   b  c

a   b  c   x    y   a   b  c

可以看这就是一个字符串的前缀=后缀的情况，不是吗？也就是说，只有当前缀等于后缀存在的情况下，你往后移才有可能匹配（在0~7之内有匹配的）。在发现第8位不匹配的情况下，我们利用next数组，直接找到前缀=后缀的那部分，直接移动过去，这样省了很多步暴力。如果发现前缀=后缀的情况不存在，那么好办，直接跳过0~7位，因为前缀=后缀不存在，你在0~7位之间怎么移动都不可能匹配。

接下来就是利用前缀与后缀求next数组的方法，很容易理解。

比如 s: a   b    a   b

next[i]  表示的是从第0~i位的字符串，前缀和后缀的最大公共子串的长度。求解next[i] 其实只有两种情况，一种是next[i-1]也就是0~i-1的子串存在前后缀最大公共子串，例如a  b  a  b 现在求解最后一位b也就是next[3],可以看next[2]=1 因为a b a的公共前后缀是a长度是1，s[0]=s[2]="a" 。 那么如果s[1]=s[3]的话，公共前后缀岂不是要加1，于是b就去找s[2]匹配的前缀就是s[1],找他的下一位s[1],果然和自己相等，于是在next[2]的基础上加1.。还要一种就是前面的next[i-1]没有前后缀公共子串，那么看来只有从自己开始开辟了，忽视果断和第一位比较，如果相等，那么从i开始就有了前后缀公共子串，长度为1.

这里还要提一点，next[i] 还表示和s[i]相等的前缀s[j]的下标j,s[j]是前缀的最后一个字符，s[i]是后缀的最后一个字符。s[i]=s[j] ，j的值既是下标（从0开始的要加 1）也是长度。

next[0]   a   只有一个字符串，最大公共子串长度为0

next[1]   a b   由于next[0]=0，说明前面的子串没有前后缀相等的情况，只能从自己开辟，发现s[0]和自己不一样，于是只能next[1]=0

next[2]  a b a   next[1]=0,同样的从自己开辟，发现s[0]和自己一样，终于有戏，于是next[2]=1

next[3]  a b a b    next[2]=1 ,前面有匹配的，于是找到next[2]匹配的那个字符串下表也就是next[2]的值，是1（我这里是下标从0开始）于是找s[0]的下一位s[1]发现和自己一样，很完美，在next[2]的基础上加1。如果不一样呢，那么很认命，自己破坏了前后缀公共子串，只能是0.

至于代码什么的就不贴了，明白了原理，写代码是信手拈来的事情，对吧！