kmp

 

附有KMP詳細講解。

題意就是，求一個字符串最多可以平均分割成幾個相等的字串。

根據KMP算法求出next數組，考查字符串最高位i的next[i]的值是否滿足：

1. 字符串長度可以被（i-next[i]）整除
2. 第i個字符與第next[i]個字符相等

如果滿足以上條件，則答案爲（字符串長度÷（i-nexi[i]））；否則，答案爲1。

代碼：

#include <iostream>
#include <cstring>

#define N 1000003

char s[N];
int next[N],nextval[N];

void getNext(char chb[],int next[],int lb)
{
    int i,k;
    i=0;
    k=-1;
    next[0]=-1;
    while(i<lb)
    {
        if(k==-1 || chb[i]==chb[k])
        {
            i++;
            k++;
            next[i]=k;
        }
        else
        {
            k=next[k];
        }
    }
}

int main()
{

    int i,j,k,l,res;

    while(scanf("%s",s)!=EOF && strcmp(s,".")!=0)
    {
        l=strlen(s);
        getNext(s,next,l);
        i=l-1;
        j=next[i];
        k=i-j;
        if(s[i]!=s[j] || l%k!=0)
        {
            printf("1/n");
            continue;
        }
        printf("%d/n",l/k);
    }

    return 0;
}

要知道本題的原理，首先要了解KMP算法中的next[]和nextval[]。

我的理解是，假設a是源字符串，b是要進行匹配的字串，next[i]及nextval[]通過b串生成。i指向a串當前進行匹配的字符，j指向b串當前進行匹配的字符。

規定，next[]與nextval[]第一個元素的值爲字符串起始元素序號減1。

next[j]是當b[j]失配（即a[i]!=b[j]）時，j往前跳的位置。能保證：b[0]到b[j-1]均與a[i]前j-1個字符（不包括a[i]本身）一一匹配；且此時next[j]能保證b[0]到b[next[j]-1]均與a[i]前next[j]-1個字符（不包括a[i]本身）一一匹配的，小於j的最大值。

nextval[i]與next[i]一樣，只不過，b[j]有可能等於b[next[j]]，所以失配後，用next[]可能要跳幾次才能找到a[i]與b[j]不同的值繼續匹配；而b[j]不會等於b[nextval[j]]，所以失配後只需跳一次即可。

比如：

	a	a	a	a	b	b
j	0	1	2	3	4	5
next[]	-1	0	1	2	3	0
nextval[]	-1	-1	-1	-1	3	0

 

	a	b	c	a	b	d	a	b	c	a	b	d
j	0	1	2	3	4	5	6	7	8	9	10	11
next[]	-1	0	0	0	1	2	0	1	2	3	4	5
nextval[]	-1	0	0	-1	0	2	-1	0	0	-1	0	2

應該講得差不多了吧。下面是KMP算法的模板：

生成next[]的模板：（s爲傳入的字符串，l爲s的長度，next[]爲要生成的next數組；如果是string類型，則將“char s[]”改爲“string s”即可）

void getNext(char s[],int l,int next[])
{
    int i,k;
    i=0;
    k=-1;
    while(i<l)
    {
        if(k==-1 || s[i]==s[k])
        {
            k++;
            i++;
            next[i]=k;
        }
        else
        {
            k=next[k];
        }
    }
}

生成nextval[]的模板：（s爲傳入的字符串，l爲s的長度，nextval[]爲要生成的nextval數組；如果是string類型，則將“char s[]”改爲“string s”即可）

void getNextVal(char s[],int l,int nextval[])
{
    int i,k;
    i=0;
    k=-1;
    while(i<l)
    {
        if(k==-1 || s[i]==s[k])
        {
            k++;
            i++;
            if(s[i]!=s[k])
            {
                nextval[i]=k;
            }
            else
            {
                nextval[i]=nextval[k];
            }
        }
        else
        {
            k=nextval[k];
        }
    }
}

KMP算法：（a爲a串，la爲a串長度，b爲b串，lb爲b串長度，（b串生成next[]或nextval[]），pos是a串開始匹配的位置）

int KMP(char a[],int la,char b[],int lb,int pos)//a中尋找字串b的位置 
{
    int i,j;
    i=pos;
    j=0;
    while(i<la && j<lb)
    {
        if(j==-1 || a[i]==b[j])
        {
            i++;
            j++;
        }
        else
        {
            j=nextval[j];//用next[]或nextval[] 
        }
    }
    if(j==lb)//匹配成功 
    {
        return i-lb;
    }
    else//匹配失敗 
    {
        return -1;
    }
}

應該差不多了。嗯。