sicily 1282 ——由此引出的KMP算法

今天在做有关数据结构字符串处理类的题目，遇到一个蛮有意思的问题，就是sicily 1282 的问题。看了很大串英文，其实就是讲述这样的一个问题：

// 题意: A是主串,B是子串,都由数字组成, 查询B串在A串第一次出现的位置,若找不到则输出no solution
// 注意子串的最大长度是60000,但主串的长度未知,所以要开大些
其实这里蕴含了一个蛮重要的算法，就是KMP算法。这里对不起，我也是百度了一下才知道这个是一个怎么样的算法，先向博客园的用户海子和链接为http://www.cppblog.com/suiaiguo/archive/2009/07/16/90237.html的博客致敬，感谢他们对kmp算法的一个比较详细的讲解，下面由我来转载有关的内容：

KMP算法

        在介绍KMP算法之前，先介绍一下BF算法。

 

一.BF算法

 

    BF算法是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配，若相等，则继续比较S的第二个字符和P的第二个字符；若不相等，则比较S的第二个字符和P的第一个字符，依次比较下去，直到得出最后的匹配结果。

 

    举例说明：

 

    S:  ababcababa

 

    P:  ababa

 

 BF算法匹配的步骤如下

 

            i=0                                   i=1                                 i=2                               i=3                              i=4

 

  第一趟:ababcababa         第二趟:ababcababa      第三趟:ababcababa    第四趟:ababcababa    第五趟:ababcababa

 

            ababa                             ababa                          ababa                        ababa                       ababa

 

            j=0                                    j=1                                 j=2                              j=3                              j=4(i和j回溯)

 

 

 

              i=1                                   i=2                                  i=3                                i=4                         i=3

 

 第六趟:ababcababa         第七趟:ababcababa       第八趟:ababcababa     第九趟:ababcababa   第十趟:ababcababa

 

             ababa                               ababa                           ababa                        ababa                         ababa

 

             j=0                                    j=0                                  j=1                               j=2(i和j回溯)            j=0

 

 

 

                      i=4                                    i=5                                 i=6                                 i=7                                 i=8

 

第十一趟:ababcababa       第十二趟:ababcababa    第十三趟:ababcababa   第十四趟:ababcababa   第十五趟:ababcababa

 

                     ababa                               ababa                           ababa                          ababa                          ababa

 

                     j=0                                    j=0                                  j=1                                 j=2                                j=3

 

 

 

                               i=9

 

第十六趟:ababcababa

 

                      ababa

 

                               j=4(匹配成功)

 

代码实现:

#include <iostream>

#include <vector>

#include <string>

using namespace std;



int BFmatch(string S,string P)

{

    int i,j;

    i = 0;

    while(i < S.size())

    {

        j = 0;

        while(j < P.size() && S[i] == P[j])

        {

            i++;

            j++;

        }

        if(j == P.size())

            return i - P.size();

        else

            i = i - j + 1;  //回溯

    }

    return -1;

}

 

 

   KMP 匹配算法是由 "Knuth  Morris  Pratt"  提出的一种快速的模式匹配算法。  
   hint：不为自身的最大首尾重复子串长度

   1.待解决的问题：假设P为给定的子串，T是待查找的字符串，要求从T中找出与P相同的所有子串，这称为模式匹配问题。 (可以给出子串在T中的位置) (下文中提到的P和T分别为子串和目标串)

   让我们先来看个例题：

   T:   t0      t1     t2      t3 .... tm-1 ... tn-1

   P:   p0      p1     p2      p3 .....pm-1         

                                               

   从T的最左边开始比较，使得 TK = PK，则匹配成功。

   2.解决模式匹配问题的方案：

   A：朴素的模式匹配算法(思路简单,但不够简便，时间长，有回溯)：最简单和最直接的做法，用P中的字符依次与T中的字符进行比较，遇到不相等的字符，则可将P右移一个字符，重新进行比较，直到某次匹配成功或者到达P的最右字符移出T为止。

   如：若P="aaaba", T="aaabbaaaba", 则匹配过程如下图

    T:     a   a   a   b   b   a   a   a   b  a

    P:     a   a   a   b   a                                                                

               a   a   a   b   a                

                                   .....

                               a   a   a   b  a           

   从上不难分析，最坏的情况是“每次比较都在最后一个字符出现不等，每趟最多比较M次，最多比较N-M+1趟，总的比较次数最多为M*(N-M+1)” ，时间复杂性为0(M*N)。 在P右移一位时，不管上一趟比较的中间结果是什么，因此回溯是不可避免的(如：前3个aaa 不需要一位一位的移 ) 。下面我来介绍无回溯的KMP算法。

   3.KMP算法解决匹配中哪些主要问题：

   A.当字符串比较出现不等时，确定下一趟比较前，应该将P右移多少个字符； 

   B. P右移后，应该从哪个字符开始和T中刚才比较时不等的那个字符继续开始比较。

    我们通过朴素模式匹配的例子来引出问题。在第一次比较过程中失败的是P的第4个字符b，这表明P的前4个字符是成功的。模式P的第3个字符b在它的前3个字符(aaa)中并未出现。因此，在下一次比较时候，至少要将P向后移4个字符；再看P的第一个字符与最后一个字符是相同的，因此将P右移4个字符后，再从第一个字符比较，肯定也是不等的。综上所诉：应该将P右移5个字符，再从P的第0个字符和T的第5个字符开始比较！

   KMP算法核心：KMP算法借助于一个辅助数组next来确定当匹配过程中出现不等时，模式P右移的位置和开始比较的位置。next[i]的取值只与模式P本身的前i+1项有关，而与目标T无关。匹配过程中遇到Pi不等于Tj时，若next[i]>=0，则应将P右移i-next[i]位个字符，用P中的第next[i]个字符与Tj 进行比较；若：next[i]= -1，P中的任何字符都不必再与Tj比较，而应将P右移i+1个字符，从P0和Tj+1从新开始下一轮比较(可能不太好理解，自己找个例子，对着话一句一句试试看)

 

   因此只要计算出与模式P相关的next数组，按上面的含义，就可以很容易地给出串的匹配算法。(问题就这样转化了)

    C.next的计算：以P = " 01001010100001"为例。

     i   :            0   1   2   3   4   5   6    ..... 

     P   :            0   1   0   0   1   0   1    .....

    j(next[i]) :     -1   0   0   1   1   2   3    .....

   如1：我们要算next[2]的值,有关的为P本身的前2个字符0,1。在字符串01中，寻找出“左右相同的最大字符串，此字符串所含字符的个数就为next[i]的值”而0不等于1，相同字符串不存在，所以next[i] = 0；

   如2：我们要算next[6]的值，有关的为P本身前6个字符010010 。此字符串中010 = 010左右相同的最大字符串为010，个数为3。所以next[i]=3；

   如3：我们要算next[5]的值，有关的为P本身前5个字符01001。此字符串中 01=01 左右相同的最大字符串为01，个数为2。所以next[i]=2；

     我们可以在前面的比较的趟数可以发现：当子串存在左右相同的子子串时，其实我们根本不用每次子串的j移到第一位来，因为我们可以在前面的比较可以知道，前面的各字母都匹配，因此，我们只需把j的坐标前移到那个左右相同的子串的右子串的首位置当中，这样我们就省下了比较的次数。

代码实现方法：

#include <iostream>

#include <vector>

#include <string>

using namespace std;



int BFmatch(string S,string P)

{

    int i,j;

    i = 0;

    while(i < S.size())

    {

        j = 0;

        while(j < P.size() && S[i] == P[j])

        {

            i++;

            j++;

        }

        if(j == P.size())

            return i - P.size();

        else

            i = i - j + 1;  //回溯

    }

    return -1;

}

//这里求出next数组有两种方法,第一种并不是很好理解，第二种则是直接解决方法

/*第一种方法：

  按照递推的思想：

  根据定义next[0]=-1，假设next[j]=k, 即P[0...k-1]==P[j-k,j-1]

  1)若P[j]==P[k]，则有P[0..k]==P[j-k,j]，很显然，next[j+1]=next[j]+1=k+1;

  2)若P[j]!=P[k]，则可以把其看做模式匹配的问题，即匹配失败的时候，k值如何移动，显然k=next[k]。

  因此可以这样去实现：

*/



vector<int> get_next(string P)

{

    int i = P.size();

    vector<int> result(i);

    int j,k;

    j = 0;

    k = -1;

    result[0] = -1;

    while(j<P.size()-1)

    {

        if(k==-1||P[j] == P[k])    //匹配的情况下,p[j]==p[k] 

        { 

            j++; 

            k++; 

            result[j]=k; 

        } 

        else                   //p[j]!=p[k] 

            k = result[k]; 

    } 

    return result;

} 





/*第二种方法：直接解决法*/

bool Equals(string P,int i,int j)     //判断p[0...j-1]与p[i-j...i-1]是否相等   

{ 

    int k = 0; 

    int s = i - j; 

    for(;k <= j - 1 && s <= i - 1;k++,s++) 

    { 

        if(P[k] != P[s]) 

            return false; 

    } 

    return true; 

} 



vector<int> get_next_2(string P)

{

    int i,j,k,temp;

    k = P.size();

    vector<int> result(k);

    for(i = 0;i < k;i++) 

    { 

        if(i == 0) 

        { 

            result[i]=-1;     //next[0]=-1 

        } 

        else if(i==1)  

        { 

            result[i]=0;      //next[1]=0 

        } 

        else

        { 

            temp=i-1; 

            for(j=temp;j>0;j--) 

            { 

                if(Equals(P,i,j)) 

                { 

                    result[i]=j;   //找到最大的k值 

                    break; 

                } 

            } 

            if(j==0) 

                result[i]=0; 

        } 

    } 

} 



int KMPmatch(string S,string P)

{

    int i,j;

    vector<int> next;

    next = get_next(P);

    while(i < S.size())

    {

        if(j == -1 || S[i] == P[j])   //前一个条件是被迫才返回子串的首位的极端情况

        {

            i++;

            j++;

        }

        else 

        {

            j = next[j];   //更高级的回溯

        }

        if(j == P.size())

            return i-P.size();

    }

    return -1;

}

好啦，差不多讲完了，以下是sicily 1282 的答案:
代码实现方法：

 

#include <iostream>

#include <string>

#include <vector>

using namespace std;



vector<int> get_next(const vector<int>& P)

{

    int i = P.size();

    vector<int> result(i);

    int j,k;

    j = 0;

    k = -1;

    result[0] = -1;

    while(j<P.size()-1)

    {

        if(k==-1||P[j] == P[k])    //匹配的情况下,P[j]==P[k] 

        { 

            j++; 

            k++; 

            result[j]=k; 

        } 

        else                   //p[j]!=p[k] 

            k = result[k]; 

    } 

    return result;

} 



int KMPmatch(const vector<int>& S,const vector<int>& P)

{

    int i,j;

    vector<int> next;

    next = get_next(P);  //也可以"next = get_next_2(P);"

    j = 0;

    i = 0;

    while(i < S.size())

    {

        if(j == -1 || S[i] == P[j])   //前一个条件是被迫才返回子串的首位的极端情况

        {

            i++;

            j++;

        }

        else 

        {

            j = next[j];   //更高级的回溯

        }

        if(j == P.size())

            return i-P.size();

    }

    return -1;

}



int main()

{

    int m,n;

    while(cin >> m)

    {

        int i,j;

        vector<int> A,B;

        for(i = 0 ; i < m;i++)

        {

            cin >> j;

            A.push_back(j);

        }

        cin >> n;

        for(i = 0; i < n;i++)

        {

            cin >> j;

            B.push_back(j);

        }

        if(KMPmatch(B,A) == -1)   //注意分清楚谁是主串，谁是子串！

            cout << "no solution" <<endl;

        else

            cout << KMPmatch(B,A) << endl;

    }

    return 0;

}