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;
    }
}

应该差不多了。嗯。