poj2752

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

题意：给出一个字符串，询问满足前N个字符与后N个字符对应相等的n有哪些。

题解：此题考查的是KMP算法中next数组的含义，也就是求出第a个字符匹配应将指针跳转至第b个字符继续匹配，b必然是a的前后b个字符全等的最大的b，所以一个指针p从N开始每次的next[p]就是一个合法答案，然后p跳转到next[p]继续查找，直到p无next为止，将答案倒着输出即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <map>
#include <cmath>
#include<stack>
#include <set>
#include <queue>
#include <sstream>
#include <algorithm>
typedef long long ll; 
using namespace std;
int Next[400001]; 
char s[400001];
int ans[400001];
void GetNext(char* p,int Next[])
{
    int pLen = strlen(p);
    Next[0] = -1;
    int k = -1;
    int j = 0;
    while (j < pLen - 1)
    {
        //p[k]表示前缀，p[j]表示后缀
        if (k == -1 || p[j] == p[k]) 
        {
            ++k;
            ++j;
            Next[j] = k;
        }
        else 
        {
            k = Next[k]; //此时t[j] != t[k] ，所以就有 next[j+1] < k，那么求 next[j+1] 就等同于求 t[j] 往前小于 k 个的字符与 t[k] 前面的字符的最长重合串，即 t[j-k+1] ~ t[j] 与 t[0] ~ t[k-1] 的最长重合串，那么就相当于求 next[k]
        }
    }
}
int main()
 {
     while(scanf("%s", s)!=EOF)
     {
         int n = strlen(s);
         GetNext(s,Next);
         for(int i = 0; i < n; i++)
               cout<<Next[i]<<" ";
         cout<<endl;
         int tot = 0;
         int p = Next[n-1];
         while(p!=-1)
         {
             if(s[p] == s[n-1])
               ans[tot++] = p+1;
             p = Next[p];
        }
         for(int i = tot-1; i >= 0; i--)
               printf("%d ", ans[i]);
         printf("%d\n", n);
     }
 
     return 0;
 }