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 = ;
 int nxt[maxn];
 char s[maxn];
 int ret[maxn];
 int casee = ;
 void getnxt (char s[])
 {
     int j,k;
     int len = strlen(s);
     j = ,k = -;
     nxt[] = -;
     while (j<len){
         if (k==-||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,,sizeof ret);
         int len = strlen(s);
         ret[] = len;
         for (int i=;i<len;++i){
             memset(nxt,,sizeof nxt);
             int tmplen = strlen(s+i);
             getnxt(s+i);
             for (int j=;j<=tmplen;++j){
                 int tmp = j;
                 while (tmp){//对于每个循环串我们寻找循环节
                     tmp = nxt[tmp];//每次沿着nxt跳是不会错过循环节的
                     if (j%(j-tmp)==){
                         int x = j/(j-tmp);
                         ret[x] = max(ret[x],j);
                     }
                 }
             }
         }
         printf("Case #%d:",++casee);
         for (int i=;i<=len;++i)
             printf(" %d",ret[i]);
         printf("\n");
     }
     return ;
 }