Seek the Name, Seek the Fame

 Seek the Name, Seek the Fame

Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u

Description

The little cat is so famous, that many couples tramp over hill and dale to Byteland, and asked the little cat to give names to their newly-born babies. They seek the name, and at the same time seek the fame. In order to escape from such boring job, the innovative little cat works out an easy but fantastic algorithm: 

Step1. Connect the father's name and the mother's name, to a new string S. 
Step2. Find a proper prefix-suffix string of S (which is not only the prefix, but also the suffix of S). 

Example: Father='ala', Mother='la', we have S = 'ala'+'la' = 'alala'. Potential prefix-suffix strings of S are {'a', 'ala', 'alala'}. Given the string S, could you help the little cat to write a program to calculate the length of possible prefix-suffix strings of S? (He might thank you by giving your baby a name:) 

Input

The input contains a number of test cases. Each test case occupies a single line that contains the string S described above. 

Restrictions: Only lowercase letters may appear in the input. 1 <= Length of S <= 400000. 

Output

For each test case, output a single line with integer numbers in increasing order, denoting the possible length of the new baby's name.

Sample Input

ababcababababcabab
aaaaa

Sample Output

2 4 9 18
1 2 3 4 5

下面给出描述: (i>1)[下标从0开始] 
next[i]的意义就是：前面长度为i的字串的【前缀和后缀的最大匹配长度】 

那么这题怎么利用这个性质呢？ 

详细分析一下：【就用上面的第一个例子说明吧】 
求出next值：[非修正]
下标：      0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17
串：          a  b  a  b  c  a  b  a  b  a  b   a   b   c   a   b   a   b
next值：  -1  0  0  1  2  0  1  2  3  4  3   4   3   4   5   6   7   8   9

len2 = 18    next[len2] = 9 
说明对于前面长度为18的字符串，【长度为9的前缀】和【长度为9的后缀】是匹配的, 即上图的蓝色跟红色匹配 
也就是整个串的最大前后缀匹配长度就是9了 
所以接下来根本不需要考虑长度大于9的情况啦 

好了！既然现在只需考虑长度小于9的前后缀匹配情况，那么 
[问题就转化成蓝色串的前缀跟红色串的后缀的匹配问题了！！！ 
又因为蓝串==红串 
所以问题又转化成 
找蓝串自己的前缀跟自己的后缀的最大匹配了！！！ 
那么我们现在就要找next[9]的值了【next[9]的含义：蓝串的最大前后缀匹配】 

回忆第一步：我们找的是next[len2]=9【len2=18】 
怎么使得第二部目标变成9【求next[9]】呢？ 
其实next[len2]=9同时可以表示为：最大匹配前后缀的【前缀长度】 
那么next[9]的意义就是： 
【主串】的最大匹配前后缀的【前缀】的【最大匹配前后缀】了！！ 
也就是上面蓝串的前后缀最大匹配长度了！！ 

那么算法描述就是： 
第一步：求next[len2], 即next[18] = 9; 
第二步：把9代进来，即求next[9] = 4; 
第三步：把4代进来，即求next[4] = 2； 
第四步：next[2] = 0; 也就是下标2之前的串已经没有前后缀可以匹配了 
所以答案就是： 2 4 9 18 【PS: 从小到大输出，18是串长，显然符合题意】 
局部实现代码： 

C++代码  收藏代码
#include <iostream>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <math.h>  
#include <algorithm>  
using namespace std;  
#define L2 400005  
  
int next[L2], len2, ans[L2];  
char p[L2];  
bool hash[L2];  
  
void get_next()  
{  
    int k = -1, j = 0;  
    next[0] = -1;  
    while (j < len2)  
    {  
        if (k == -1 || p[j] == p[k])  
        {  
            j++, k++;  
            next[j] = k;  
        }  
        else k = next[k];  
    }  
}  
  
int main()  
{  
    int k, i, j;  
    while (scanf ("%s", p) != EOF)  
    {  
        k = 0;  
        memset (hash, false, sizeof(hash));  
        len2 = strlen (p);  
        get_next();  
        j = next[len2];  
        while (j > 0)  
            ans[k++] = j, j = next[j];  
        for (i = k - 1; i >= 0; i--)        //倒过来输出，就是从小到大了  
            printf ("%d ", ans[i]);  
        printf ("%d\n", len2);  
    }  
    return 0;  
}  

我的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
char a[400010];
int ne[400010];
int str[400010];
void fun(char *p,int L)
{
	int i,j;
	i=0;j=-1;
	ne[0]=-1;
	while (i<L)
	{
		if (j==-1||p[i]==p[j])
		{
			i++;j++;
			ne[i]=j;
		}
		else
		{
			j=ne[j];
		}
	}
}
int main()
{
	int i,lena,len;
	while (~scanf("%s",&a))
	{
		lena=strlen(a);
		fun(a,lena);
		/*for (i=0;i<=lena;++i)
		{
			printf("%d ",ne[i]);
		}
		printf("\n");*/
		len=-1;
		while (lena)
		{
			/*printf("%d\n",ne[lena]);
			printf("%d ",lena);*/
			str[++len]=lena;
			lena=ne[lena];
		}
		for (i=len;i>0;--i)
		{
			printf("%d ",str[i]);
		}
	     printf("%d\n",str[0]);
	}
	return 0;
}