KMP算法之病毒检测

什么是KMP算法？

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。
（通俗的说就是：用来找目的串中是否包含模式串的。。。。）

那么为什么会有KMP算法呢？！还不是因为三位dalao认为BF算法太慢太暴力了。。。。。。。。
这里我也只给出KMP算法的代码，不深究和不解释了，毕竟能用就好。。。。

KMP

int KMP(char *sh, char *ch, int pos, int *next)//sh为目的串，ch为模式串
{
    int les = strlen(sh);
    int lec = strlen(ch);
    int i=pos, j=0;     //从pos处开始匹配，
    
    while(i<les && j<lec)
    {
        if(j == -1 || sh[i] == ch[j])
        {
            ++i;
            ++j;
        }
        else
            j = next[j];
    }
    
    if(j >= lec)       //匹配成功返回下标 ，否则返回-1
        return i-lec;
    else
        return -1;
}

这就是KMP算法，详细解释我也不写了，毕竟太多了。。。

next [ j ]数组的求法。。。。(只与模式串有关)

这里呢，，，我们也就和网上多数next [ j ] 的求法一样，初始为-1，0代表有一个前后缀相同，1 代表有两个，，，以此类推。

（1）next[0]= -1 意义：任何串的第一个字符的模式值规定为-1。
（2）next[j]= -1 意义：模式串T中下标为j的字符，如果与首字符相同，且j的前面的1—k个字符与开头的1—k个字符不等
（或者 相等但T[k]==T[j]）（1≤k<j），如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6].
（3）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （1≤k<j）即T[0] T[1] T[2]…T[k-1] == T[j-k] T[j-k+1] T[j-k+2]…T[j-1] 且 T[j] != T[k].（1≤k<j）;
(4) next[j]=0 意义：除（1）（2）（3）的其他情况。

先给出普通的next数组的求法：

void NEXT(char *ch, int *next)
{
    int lec = strlen(ch);
    int i=0, j=-1;
    next[0] = -1;		//初始化为-1；
    while(i < lec)
    {
        if(j == -1 || ch[i] == ch[j])
                next[++i] = ++j;
        else
            j = next[j];
    }
}

下面我也就直接给出优化版后的next [ j ] 算法：

void NEXT(char *ch, int *next)
{
    int lec = strlen(ch);
    int i=0, j=-1;
    next[0] = -1;		//初始化为-1；
    while(i < lec)
    {
        if(j == -1 || ch[i] == ch[j])
        {
            if(ch[++i] == ch[++j]) //优化。。。
                next[i] = next[j];
            else
                next[i] = j;
        }
        else
            j = next[j];
    }
}

好了， 下面给出病毒检测的完整代码：

题意：给出检测样例T，表示有T组样例，然后给出病毒的DNA序列（难道没有RNA病毒嘛？！），再给出人的DNA序列，但是，众所周知，大部分的病毒DNA都是环状的，，，，所以，你要敲个代码用来检测该人体的DNA中是否含有病毒的DNA序列，，

思路：好吧，很明显是字符串匹配吧，，，，但是这里要注意病毒的DNA是环状的就可以了。。。。。（我们用BF暴力吧？！不可以，不可能，大牛们这么可以忍受在数十亿的基因序列上这么暴力，，所以，我用了KMP。。。。）

//#include<bits/stdc++.h>
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string.h>
#include<string>
#include<math.h>
using namespace std ;
typedef long long ll;
#define MAXN 1005
#define INF 0x3f3f3f3f

typedef struct Chunk
{
    char goal[MAXN];    //存放单链DNA
    char type[MAXN*2];  //存放病毒
    char mo[MAXN];      //模式串存放更新
    int next[MAXN];     //KMP中模式串的next[j];
    int leg;            //单链DNA的长度；
    int let;            //病毒基因的长度
    int flag;           //判断是否匹配成功
} SString;

int KMP(SString &T)     //KMP算法
{
    int i=0, j=0;
    while(i<T.leg && j<T.let)
    {
        if(j == -1 || T.goal[i] == T.mo[j])
        {
            ++i;
            ++j;
        }
        else
            j = T.next[j];
    }
    if(j > T.let-1)
        return i-T.let;
    else
        return -1;
}

void NNext(SString &T)  //next[j];
{
    memset(T.next, 0, sizeof(T.next));
    int i=0, j=-1;
    T.next[0] = -1;
    while(i<T.let)
    {
        if(j == -1 || T.mo[i] == T.mo[j])
        {
            if(T.mo[++i] == T.mo[++j])
                T.next[i] = T.next[j];
            else
                T.next[i] = j;
        }
        else
            j = T.next[j];
    }
}

void init(SString &T) //输入
{
    T.flag = -1;
    scanf("%s%s", T.type, T.goal);
    T.leg = strlen(T.goal);
    T.let = strlen(T.type);
    int i, j;
    for(i=T.let, j=0; j<T.let; ++j)
        T.type[i++] = T.type[j];
}

void print(SString T)   //输出
{
    for(int i=0; i<T.let; ++i)
        cout << T.type[i];
    cout << ' ' << T.goal << ' ';
    if(T.flag != -1)
        cout << "Yes" << '\n';
    else
        cout << "No" << '\n';
}

int main()
{
    int n;
    cin >> n;
    SString ss[n];
    for(int i=0; i<n; ++i)
        init(ss[i]);
    for(int i=0; i<n; ++i)
    {
        for(int j=0; j<ss[i].let; ++j)
        {
            for(int k=0; k<ss[i].let; ++k)      //模式串更新
                ss[i].mo[k] = ss[i].type[k+j];
            ss[i].mo[ss[i].let] = '\0';         //防止访问越界
            NNext(ss[i]);                       //更新next[j]；
            ss[i].flag = KMP(ss[i]);            //KMP查询
            if(ss[i].flag != -1)
                break;
        }
    }
    for(int i=0; i<n; ++i)
        print(ss[i]);
    return 0;
}