KMP算法，（字符串匹配问题）

疯疯癫癫才自由

已于 2023-04-18 15:21:39 修改

阅读量156

点赞数

分类专栏：算法算法笔记 # KMP算法文章标签：算法 c++

于 2022-06-29 18:09:17 首次发布

本文链接：https://blog.csdn.net/qq_51825761/article/details/125526951

版权

算法笔记同时被 3 个专栏收录

39 篇文章 0 订阅

订阅专栏

算法

25 篇文章 1 订阅

订阅专栏

KMP算法

2 篇文章 0 订阅

订阅专栏

实现字符串的匹配问题：
mat[i]是使子串str[0...i]的前缀str[0...k]等于后缀str[i-k...i] (i!=k)的最大的k;
前缀和后缀可以部分重叠，但不能是str[0...i]本身；

    a b a b a a
          a b a b a a;
    mat[4]=2;(ababa的最大前缀是aba);
    s[5]!=s[mat[4]+1],所以 aba(mat[5-1]) 不能成为s[5]的前缀的一部分，所以要找能匹配
    ababaa的最长前缀，那么就向aba往前寻找，显然是寻找aba的最长前缀 a (mat[2]=0)，看
    是否能匹配成功，直到匹配成功或者没有最长前缀为止；

因此得出求解mat数组的函数：

void getNext(string &str,int len) //前缀和后缀可以部分重叠，但不能是str[0...i]本身；
{
    int j=-1;
    mat[0]=-1;
    for(int i=1;i<len;++i)
    {
        while(j!=-1 && str[i]!=str[j+1])
            j=mat[j];
        if(str[i]==str[j+1])
            ++j;
        mat[i]=j;
    }
}

    对于判断pattern 字符串是否为 text 文本的子串，例如对于：
    pattern="abcabcd";
       text="abcdabcabcabcdcs"
    已经匹配到了第一个"abcabc",结果匹配最后一位的时候发现pattern中是'd',而text
    中是'a',不匹配，那怎么办，直接退回到pattern的第一位吗，明显不用，退回到
    pattern已经匹配的子串的最长前缀就可以；根据mat的定义可以明显知道，text后几位
    和pattern的前几位是匹配的，当然，这儿的前几位和后几位都是pattern已经匹配的子串的
    最长前缀长。

    那么我们可以得出判断 pattern 字符串是否为 text 文本的子串的算法：
        1)定义pattern 的下标j=-1，
        2)枚举text的下标从 0 到 n-1；
        3)判断j是否不等于-1并且是否text[i]不等于pattern[j+1]，如果答案是肯定，就令j=mat[j]
        ，如此循环下去；
        4)只要text[i]==pattern[j+1],就++j；
        5)只要j==m-1,说明已经匹配完成，匹配成功。
        6)到text 枚举完都没有匹配成功，说明text中不存在子串与pattern相等。

bool KMP_is_substr(string &text,string &pattern,int n,int m)
{
    getNext(pattern,m);
    int j=-1;
    for(int i=0;i<n;++i)
    {
        while(j!=-1 && text[i]!=pattern[j+1])
            j=mat[j];
        if(text[i]==pattern[j+1])
            ++j;
        if(j==m-1)  //j达到pattern最后一位，匹配成功
            return true;
    }
    return false;
}

考虑text文本中有多少个 pattern 子串；
    和判断 pattern 字符串是否为 text 文本的子串的算法差不多的思想；
    只是在得到pattern是text的子串的时候，要把j回退到整个pattern字符串的
    最长前缀的位置；

int KMP_sum_substr(string &text,string &pattern,int n,int m)
{
    getNext(pattern,m);
    int j=-1,ans=0;
    for(int i=0;i<n;++i)
    {
        while(j!=-1 && text[i]!=pattern[j+1])
            j=mat[j];   //不断回退，直到j==-1或者text[i]==pattern[j+1]
        if(text[i]==pattern[j+1])
            ++j;
        if(j==m-1)  //pattern是text的子串
        {
            ++ans;
            j=mat[j];
        }
    }
    return ans;
}

完整代码：

/**
    实现字符串的匹配问题：
        mat[i]是使子串str[0...i]的前缀str[0...k]等于后缀str[i-k...i] (i!=k)的最大的k;
        前缀和后缀可以部分重叠，但不能是str[0...i]本身；
    再编码：
*/
#include <iostream>
#include <string>
using namespace std;
const int maxn=1001;

/**
    a b a b a a
        a b a b a a;
    mat[4]=2;(ababa的最大前缀是aba);
    s[5]!=s[mat[4]+1],所以 aba(mat[5-1]) 不能成为s[5]的前缀的一部分，所以要找能匹配
    ababaa的最长前缀，那么就向aba往前寻找，显然是寻找aba的最长前缀 a (mat[2]=1)，看
    是否能匹配成功，直到匹配成功或者没有最长前缀为止；
*/

int mat[maxn]={0}; //mat[i]是使子串str[0...i]的前缀str[0...k]等于后缀str[i-k...i]的最大的k
void getNext(string &str,int len) //前缀和后缀可以部分重叠，但不能是str[0...i]本身；
{
    int j=-1;
    mat[0]=-1;
    for(int i=1;i<len;++i)
    {
        while(j!=-1 && str[i]!=str[j+1])
            j=mat[j];
        if(str[i]==str[j+1])
            ++j;
        mat[i]=j;
    }
}

/**
    对于判断pattern 字符串是否为 text 文本的子串，例如对于：
    pattern="abcabcd";
       text="abcdabcabcabcdcs"
    已经匹配到了第一个"abcabc",结果匹配最后一位的时候发现pattern中是'd',而text
    中是'a',不匹配，那怎么办，直接退回到pattern的第一位吗，明显不用，退回到
    pattern已经匹配的子串的最长前缀就可以；根据mat的定义可以明显知道，text后几位
    和pattern的前几位是匹配的，当然，这儿的前几位和后几位都是pattern已经匹配的子串的
    最长前缀长。

    那么我们可以得出判断 pattern 字符串是否为 text 文本的子串的算法：
        1)定义pattern 的下标j=-1，
        2)枚举text的下标从到n-1；
        3)判断j是否不等于-1并且是否text[i]不等于pattern[j+1]，如果答案是肯定，就令j=mat[j]
        ，如此循环下去；
        4)只要text[i]==pattern[j+1],就++j；
        5)只要j==m-1,说明已经匹配完成，匹配成功。
        6)到text 枚举完都没有匹配成功，说明text中不存在子串与pattern相等。

*/
bool KMP_is_substr(string &text,string &pattern,int n,int m)
{
    getNext(pattern,m);
    int j=-1;
    for(int i=0;i<n;++i)
    {
        while(j!=-1 && text[i]!=pattern[j+1])
            j=mat[j];
        if(text[i]==pattern[j+1])
            ++j;
        if(j==m-1)  //j达到pattern最后一位，匹配成功
            return true;
    }
    return false;
}

/**
    考虑text文本中有多少个 pattern 子串；
    和判断 pattern 字符串是否为 text 文本的子串的算法差不多的思想；
    只是在得到pattern是text的子串的时候，要把j回退到整个pattern字符串的
    最长前缀的位置；
*/

int KMP_sum_substr(string &text,string &pattern,int n,int m)
{
    getNext(pattern,m);
    int j=-1,ans=0;
    for(int i=0;i<n;++i)
    {
        while(j!=-1 && text[i]!=pattern[j+1])
            j=mat[j];   //不断回退，直到j==-1或者text[i]==pattern[j+1]
        if(text[i]==pattern[j+1])
            ++j;
        if(j==m-1)  //pattern是text的子串
        {
            ++ans;
            j=mat[j];
        }
    }
    return ans;
}

int main()
{
    cout << "您是否想比较模式串是否为文本串的子串的问题?\n";
    string flag;
    while(cin >> flag ,flag == "y" || flag =="Y" || flag =="YES" || flag=="yes" || flag=="Yes")
    {
        cout << "还请您输入一个文本串及一个模式串：\n";
        string text,pattern;
        cin >> text >> pattern;
        int len1=text.size(),len2=pattern.size();
        if(KMP_is_substr(text,pattern,len1,len2))
            cout << "pattern is sub_string of text\n";
        else
            cout << "pattern is not sub_string of text\n";
        int ans=KMP_sum_substr(text,pattern,len1,len2);
        cout << "pattern has appeared in text " << ans << " times\n";
        cout << "您是否还想继续调式模式串是否为文本串的子串的问题?\n";
    }

    cout << "你是否还想调试一下你写的getNext函数:\n";
    while(cin >> flag ,flag == "y" || flag =="Y" || flag =="YES" || flag=="yes" || flag=="Yes")
    {
        cout << "那还请您输入一个字符:串:\n";
        string str;
        cin >> str;
        int len =str.size();
        getNext(str,len);
        for(int i=0;i<len;++i)
            cout << mat[i] << endl;
        cout << "您是否还想继续调式：\n";
    }
    cout << "Good bye next time!\n";
    return 0;
}

当然算法笔记上还给出里一种更为快速的求解字符串匹配的问题：

2)改变nextval数组的含义，nextval[j]的含义就是j+1位匹配失败时，j应该退回的最佳位置

求解mat数组的语句：

if(j==-1||str[i+1]!=str[j+1])
            nextval[i]=j;
        else
            nextval[i]=nextval[j]; //如果两个位置的值相等，直接继承上一个前一个的nextval值

/**
    2)改变nextval数组的含义，nextval[j]的含义就是j+1位匹配失败时，j应该退回的最佳位置
*/

/**
#include <iostream>
#include <string>
using namespace std;
const int maxn=1001;
int nextval[maxn]={0}; //nextval[j]的含义就是j+1位匹配失败时，j应该退回的最佳位置
void getNext(string &str,int len);
//bool KMP(string &text,string &pattern,int n,int m);
int KMP(string &text,string &pattern,int n,int m);
int main()
{
    string text,pattern;
    cin >> text >> pattern;
    int len1=text.size(),len2=pattern.size();
//    if(KMP(text,pattern,len1,len2))
//        cout << "pattern is sub_string of text\n";
    int ans=KMP(text,pattern,len1,len2);
    cout << "pattern has appeared in text " << ans << " times\n";
    return 0;
}

void getNext(string &str,int len)
{
    int j=-1;
    nextval[0]=-1;
    for(int i=1;i<len;++i)
    {
        while(j!=-1&&str[i]!=str[j+1])
            j=nextval[j];   //nextval[j]的含义就是j+1位匹配失败时，j应该退回的最佳位置
        if(str[i]==str[j+1])
            ++j;

        if(j==-1||str[i+1]!=str[j+1])
            nextval[i]=j;
        else
            nextval[i]=nextval[j];  //如果两个位置的值相等，直接继承上一个前一个的nextval值
    }
}

//bool KMP(string &text,string &pattern,int n,int m)
//{
//    int j=-1;
//    getNext(pattern,m);
//    for(int i=0;i<n;++i)
//    {
//        while(j!=-1&&text[i]!=pattern[j+1])
//            j=mat[j];   //mat数组的含义就是j+1位匹配失败时，j应该退回的位置
//
//        if(text[i]==pattern[j+1])
//            ++j;
//        if(j==m-1)
//            return true;
//    }
//    return false;
//}


int KMP(string &text,string &pattern,int n,int m)
{
    int j=-1,ans=0;
    getNext(pattern,m);
    for(int i=0;i<n;++i)
    {
        while(j!=-1&&text[i]!=pattern[j+1])
            j=nextval[j];   //mat[j]的含义就是j+1位匹配失败时，j应该退回的位置

        if(text[i]==pattern[j+1])
            ++j;
        if(j==m-1)
        {
            ++ans;
            j=nextval[j];
        }
    }
    return ans;
}
*/