串和KMP算法

一、串

串是由零个或多个字符串组成的有限序列

（一）、串的定义

定长顺序存储

  1. 特点:每个串变量分配一个固定长度的存储区,即定长数组

  2. 定义:

    #define MAXLEN 255
typedef struct{
    char ch[MAXLEN];
    int length;
}SString;

堆分配存储表示

这里的堆是指c语言中存在一个称之为"堆"的自由存储区，这里的堆是一个链表的结构,和数据结构中的堆是不同的!

  1. 特定:存储空间在程序执行过程中动态分配

  2. 定义

    typedef struct{
    char *ch;
    int length;
}HString;

块链存储表示

  1. 特点:使用链表结构,每个节点可以存储4个字符

（二）、最小操作集

  1. 串赋值
  2. 串比较
  3. 求串长
  4. 串联结
  5. 求子串

二、串的模式匹配

模式匹配:子串的定位操作

（一）、简单的模式匹配算法

  1. 定义:暴力匹配算法

  2. 功能:在主串s1中查找子串s2,如果找得到就返回位置(下标+1),否则返回-1

  3. 思路:以在主串abababc中匹配子串abc为例

    设i为当前匹配主串的位置,j为匹配子串的位置

    • 匹配s1[i]是否等于s2[j],相等到第二步,不相等则到第三步
    • 相等,i++,j++
    • 不相等,使i=i-j+1,j==0,倒退重新匹配
    • 重复以上操作,直到i==strlen(s1)或j==strlen(s2)

  4. code

    #include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

int cmp(string s1,string s2){  //s1主串,s1子串
    int ans,i=0,j=0,len1=s1.length(),len2=s2.length();
    while(i<len1&&j<len2){  //注意len与下标差1
        //cout << "i:" << i << " j:" << j << endl;
        if(s1[i]==s2[j]){
            i++,j++;
        }else{
            i=i-j+1;  //上一个匹配初始位的下一个pos
            j=0;
        }
    }
    ans=j==len2?i-j:-1;
    return ans+1;  //注意pos是下标位置,下标->位置
}

int main(){
    string s1,s2;
    cin >> s1 >> s2;
    int pos = cmp(s1,s2);
    printf("pos:%d
",pos);
}

  5. 时间复杂度:O(m*n)(设strlen(s1)=n,strlen(s2)=m)

  6. 主要存在的问题:

    • 显然s1至少要匹配n-m+1次
    • 我们可以想办法通过空间换时间的方式减少s2的匹配次数(即想办法膜除第三步中回退的过程)

（二）、KMP算法

解决暴力匹配过程中回退的问题

相关概念

  1. 前缀:除最后一个字符,字符串的所有头部子串
  2. 后缀:除第一个字符外,字符串的所有尾部子串
  3. 部分匹配:字符串的前缀和后缀的最长相等前后缀长度

具体操作

  1. 列出最长相等前后缀长度

    以待匹配字符串ababa为例

    序号 子字符串 前缀 后缀 最长相等前后缀长度
    1 a 0
    2 ab b a 0
    3 aba a,ab ba,a 1
    4 abab a,ab,aba bab,ab,b 2
    5 ababa a,ab,aba,abab baba,aba,ba,a 3

  2. 构建部分匹配值表(Partial Match)

    编号 1 2 3 4 5
    s a b a b a
    pm(上表最后一列) 0 0 1 2 3

  3. 使用(为了方便理解算法,我们这里用1作为下标起点)

    操作:

    • 匹配s1[i]是否等于s2[j]

    • 相等,i++,j++

    • 不相等,j=j-(j-1-pm[j-1]),即使子串回退

      回退的距离move=已匹配的字符数-对应的部分匹配值=j-1-pm[j-1]

    • 重复以上操作,直到i>=strlen(s1)或j>=strlen(s2)

    如:

    s1:abacdababa

    s2:ababa

    • 当i=4,j=4,显然s1[i]!=s2[j]
    • j=4-(4-1-pm[4-1])=2,i不需要回退

  4. 优化pm表

    • 存在问题:

      • pm[5]对应第6个字符匹配失败,显然是用不到的

      优化:将pm表整体右移一格构成一张新表称为next,表示子串下一个应该匹配的位置,使next[1]=-1

      编号 1 2 3 4 5
      s a b a b a
      next -1 0 0 1 2

      此时:

      move=j-1-next[j]

      j=j-move=j-(j-1-next[j])=next[j]+1

      注:关于这里使用-1,王道给出的解释是"因为若是第一个元素匹配失败,则需要将子串向右移动一位,而不需要计算子串移动的位数",简单来说就是此时只要将主串左移,不需要move.(我靠,NewBee,写到这里突然悟了!!小黄鸭原理可以的.)

    • 继续改进:显然,我们可以之际在next[j]上加1出

      编号 1 2 3 4 5
      s a b a b a
      next 0 1 1 2 3

      注:(这里再备注一下next下标的意义)

      • next[i]=0,表示没有一个前缀可以匹配,主要作为标识符使用
      • next[i]=j],j表示有i个前缀可以匹配

      此时:

      move=next[j]

      j=next[j]

推理next数组的一般公式

  1. next函数的一般公式(设首位下标为1):

    • next[j]=0,j=1(即第一位不匹配时需要移动)
    • next[j]=max{k|1<k<j且(`P_1...P_{k-1}`=`P_{j-k+1}...P_{j-1}`)}
    • 1,其它

  2. 尝试通过已知next[j]推导next[j+1]:

    令k=next[j],s2为子串

    • k=0,则next[j+1]=next[j]+1
    • s2[j]=s2[k],则next[j+1]=next[j]+1
    • s2[j]!=s2[k],则k=next[k],继续循环匹配

编写代码

#include <bits/stdc++.h>

using namespace std;

const int N=1e5+10;

string s1,s2;
int nextValue[N];

void getNext(string s,int *nextValue){
    int now=1,k=0,len=s.length();
    nextValue[0]=-1;  //设定nextValue[0]=-1,作为一个特殊的标识符表示第一个值没有匹配到
    while(now<len){
        if(k==-1){  //递归出口
            nextValue[++now]=++k;
            continue;
        }
        if(s[now]==s[k]){  //递归体
            nextValue[++now]=++k;
        }else{
            k=nextValue[k];
        }
    }
}

//找得到返回第一次出现的pos,否则返回-1
int kmpCmp(string s1,string s2){
    int i=0,j=0,ans=-1;
    int len1=s1.length(),len2=s2.length();
    while(i<len1&&j<len2){
        if(j==-1||s1[i]==s2[j]){
            i++;
            j++;
        }else{
            j=nextValue[j];
        }
    }
    if(j==len2){
        ans=i-len2+1;
    }
    return ans;
}

int main()
{
    cin >> s1;
    cin >> s2;
    getNext(s2,nextValue);
    cout << kmpCmp(s1,s2);
    return 0;
}

注:感觉在局部有点问题,没有找到好的测试样例

优化

  1. 问题产生:显然当s1[i]!=s2[j]时,我们会置换j=next[j].而当s1[i]!=s2[j],j=next[j]时,显然s1[i]!=s2[next[j]],这是一次失效的匹配

  2. 解决:当我们在创建next数组时,我们可以先判断,再通过next[j]=[next[j]]来消除这一情况(记住,这一过程是近似递归的!)

  3. 代码

    #include <bits/stdc++.h>

using namespace std;

const int N=1e5+10;

string s1,s2;
int nextValue[N];

void getNext(string s,int *nextValue){
    int now=1,k=0,len=s.length();
    nextValue[0]=-1;  //设定nextValue[0]=-1,作为一个特殊的标识符表示第一个值没有匹配到
    while(now<len){
        if(k==-1){  //递归出口
            nextValue[++now]=++k;
            continue;
        }
        if(s[now]==s[k]){  //递归体
            nextValue[++now]=++k;
        }else{
            k=nextValue[k];
        }
    }
}

//找得到返回第一次出现的pos,否则返回-1
int kmpCmp(string s1,string s2){
    int i=0,j=0,ans=-1;
    int len1=s1.length(),len2=s2.length();
    while(j<len2){
        if(j==-1||s1[i]==s2[j]){
            i++;
            j++;
        }else{
            if(s1[j]!=s1[nextValue[j]]){
                j=nextValue[j];
            }else{
                j=nextValue[nextValue[j]];
            }
        }
    }
    if(j==len2){
        ans=i-len2+1;
    }
    return ans;
}

int main()
{
    cin >> s1;
    cin >> s2;
    getNext(s2,nextValue);
    cout << kmpCmp(s1,s2);
    return 0;
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Arno-vc/p/15005292.html