KMP算法模板

模板一

int kmp(const string &T, const string &P)
{
    if (P.empty()) return 0;

    vector<int> pi(P.size(), 0);
    for (int i = 1, k = 0; i < P.size(); ++i)
    {
        while (k && P[k] != P[i]) k = pi[k - 1];
        if (P[k] == P[i]) ++k;
        pi[i] = k;
    }

    for (int i = 0, k = 0; i < T.size(); ++i)
    {
        while (k && P[k] != T[i]) k = pi[k - 1];
        if (P[k] == T[i]) ++k;
        if (k == P.size()) return i - k + 1;
    }

    return -1;
}

模板二

#include <bits/stdc++.h>
using namespace std;

void prefix_table(char pattern[],int prefix[])
{
    prefix[0]=0;
    int len = 0;
    int i = 1;
    int n = strlen(pattern);
    while(i < n)
    {
        if(pattern[i] == pattern[len])
        {
            len++;
            prefix[i] = len;
            i++;
        }
        else
        {
            if(len > 0)
                len = prefix[len - 1];
            else
            {
                prefix[i] = len; /// pattern[i] = 0;
                i++;
            }
        }
    }
}

void Move_prefix_table(int prefix[],int m)
{
    for(int i = m - 1; i >= 1; i--)
        prefix[i] = prefix[i - 1];
    prefix[0] = -1;
}

void KMP_Search(char text[],char pattern[])
{
    int i=0,j=0;
    int n = strlen(text);
    int m = strlen(pattern);
    int* prefix = (int *) malloc(sizeof(int) * m);
    prefix_table(pattern,prefix);
    Move_prefix_table(prefix,m);
    while(i < n)
    {
        if(j == m-1 && pattern[j] == text[i])
        {
            printf("Found pattern at %d\n",i - j + 1);
            j = prefix[j];
        }
        if(j == -1 || pattern[j] == text[i])
        {
            j++;
            i++;
        }
        else
        {
            j = prefix[j];
        }
    }
}

int main()
{
    char text[] = "abcabcaaaabcaaaabc";
    char pattern[] = "abcaaaa";
    KMP_Search(text,pattern);
    return 0;
}

模板三

#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;

vector<int> Get_next(string &P)
{
    int k = -1, j = 0;
    vector<int> next(P.length(),0);
    next[0] = -1;
    while(j < P.length() - 1)
    {
        if(k == -1 || P[j] == P[k])
            next[++j] = ++k;
        else
            k = next[k];
    }
    return next;
}

vector<int> KMP(string &T,string &P)
{
    int k = 0, i = 0;
    vector<int> EveryFirstIndex;
    vector<int> next = Get_next(P);

    while(i < T.length() && k < P.length())
    {
        if(k == P.length() - 1 && T[i] == P[k])
        {
            EveryFirstIndex.push_back(i - k);
            k = next[k];
            continue;
        }
        if(k == -1 || T[i] == P[k])
        {
            i++;
            k++;
        }
        else
            k = next[k];
    }
    return EveryFirstIndex;
}

int main()
{
    string T = "aaaaaaaas";
    string P = "aaaaas";
    vector<int> EveryFirstIndex = KMP(T, P);
    cout<<EveryFirstIndex.size()<<endl;
    for(int i = 0; i < EveryFirstIndex.size(); i++)
        cout<<EveryFirstIndex[i]<<" ";
}