UVA 12012 Detection of Extraterrestrial(KMP求循环节)

题目描述

E.T. Inc. employs Maryanna as alien signal researcher. To identify possible alien signals and background noise, she develops a method to evaluate the signals she has already received. The signal sent by E.T is more likely regularly alternative. 
Received signals can be presented by a string of small latin letters 'a' to 'z' whose length is N. For each X between 1 and N inclusive, she wants you to find out the maximum length of the substring which can be written as a concatenation of X same strings. For clarification, a substring is a consecutive part of the original string.

输入

The first line contains T, the number of test cases (T <= 200). Most of the test cases are relatively small. T lines follow, each contains a string of only small latin letters 'a' - 'z', whose length N is less than 1000, without any leading or trailing whitespaces.

输出

For each test case, output a single line, which should begin with the case number counting from 1, followed by N integers. The X-th (1-based) of them should be the maximum length of the substring which can be written as a concatenation of X same strings. If that substring doesn't exist, output 0 instead. See the sample for more format details.

样例输入

2
arisetocrat
noonnoonnoon

样例输出

Case #1: 11 0 0 0 0 0 0 0 0 0 0
Case #2: 12 8 12 0 0 0 0 0 0 0 0 0

提示

For the second sample, the longest substring which can be written as a concatenation of 2 same strings is "noonnoon", "oonnoonn", "onnoonno", "nnoonnoo", any of those has length 8; the longest substring which can be written as a concatenation of 3 same strings is the string itself. As a result, the second integer in the answer is 8 and the third integer in the answer is 12.

给你一个长度为n的串,让你求其中的字串是1~n循环串的最长长度

KMP的性质能让我们求出最小循环节的长度跟循环次数

如果一个长度为len的字符串,如果 len%(len-nxt[len])==0&&nxt[len]!=0就说明字符串循环 (如果nxt[len0]==0那么说明这个串不循环啊)

循环节长度为len-nxt[len]  循环次数为len/(len-nxt[len])

这个题循环串不一定出现在串首,我们要枚举这个串的所有字串,先枚举起点,再枚举长度

对于每个字串我们求KMP,但是我们求的是最小循环节,对于aaaaaa这个样例我们求出循环节长度为1,然而我们还要更新循环节为aa,aaa的答案

所以对于一个循环串我们就沿着nxt的路走步步更新,因为循环节的位置肯定是沿着nxt数组的位置跳的

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int nxt[maxn];
char s[maxn];
int ret[maxn];
int casee = 0;
void getnxt (char s[])
{
    int j,k;
    int len = strlen(s);
    j = 0,k = -1;
    nxt[0] = -1;
    while (j<len){
        if (k==-1||s[j]==s[k])
            nxt[++j] = ++k;
        else
            k = nxt[k];
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while (T--){
        scanf("%s",s);
        memset(ret,0,sizeof ret);
        int len = strlen(s);
        ret[1] = len;
        for (int i=0;i<len;++i){
            memset(nxt,0,sizeof nxt);
            int tmplen = strlen(s+i);
            getnxt(s+i);
            for (int j=2;j<=tmplen;++j){
                int tmp = j;
                while (tmp){//对于每个循环串我们寻找循环节
                    tmp = nxt[tmp];//每次沿着nxt跳是不会错过循环节的
                    if (j%(j-tmp)==0){
                        int x = j/(j-tmp);
                        ret[x] = max(ret[x],j);
                    }
                }
            }
        }
        printf("Case #%d:",++casee);
        for (int i=1;i<=len;++i)
            printf(" %d",ret[i]);
        printf("
");
    }
    return 0;
}