Codeforces 235C Cyclical Quest - 后缀自动机

Some days ago, WJMZBMR learned how to answer the query "how many times does a string x occur in a string s" quickly by preprocessing the string s. But now he wants to make it harder.

So he wants to ask "how many consecutive substrings of s are cyclical isomorphic to a given string x". You are given string s and n strings x_i, for each string x_i find, how many consecutive substrings of s are cyclical isomorphic to x_i.

Two strings are called cyclical isomorphic if one can rotate one string to get the other one. 'Rotate' here means 'to take some consecutive chars (maybe none) from the beginning of a string and put them back at the end of the string in the same order'. For example, string "abcde" can be rotated to string "deabc". We can take characters "abc" from the beginning and put them at the end of "de".

Input

The first line contains a non-empty string s. The length of string s is not greater than 10⁶ characters.

The second line contains an integer n (1 ≤ n ≤ 10⁵) — the number of queries. Then n lines follow: the i-th line contains the string x_i — the string for the i-th query. The total length of x_i is less than or equal to 10⁶ characters.

In this problem, strings only consist of lowercase English letters.

Output

For each query x_i print a single integer that shows how many consecutive substrings of s are cyclical isomorphic to x_i. Print the answers to the queries in the order they are given in the input.

Examples

Input

baabaabaaa 5 a ba baa aabaa aaba

Output

7 5 7 3 5

Input

aabbaa 3 aa aabb abba

Output

2 3 3

---

　　题目大意 给定一个字符串s，和一堆字符串x，问每个字符串x和多少个s的子串循环同构。字符串s和字符串t循环同构是指，将s的某个前缀(可以是空串)挪到s的尾部使得和字符串t相等。

　　显然后缀自动机

　　先对s建立后缀自动机。然后对于每个不是为了解决分割状态的状态的cnt设为1，接着从parent树的叶节点开始向上累加cnt。

　　对于每个询问的x，我们将x的除去最后一个字符的串复制一份，塞进x的末尾。然后扔进s的后缀自动机匹配LCS，当发现当前匹配的长度大于等于串x原本的长度，然后就开始跳par指针(但是我比较喜欢写fail)，直到当前匹配的长度为串x原本长度的子串的长度存在当前状态的长度区间内，然后累计答案。

　　由于这么做会重复一些东西，比如输入的串像什么"aaaaaaaa"，显然就会重复计数。所以你需要给每个节点记录一个时间戳来判断是否被当前询问统计过。

我最开始的想法是，对于两个循环同构的串，显然可以保留其中某一个的后缀然后把剩下的部分挪到后面去使得两个串相等。

后缀自动机中跳par指针，实质上是正在访问某个子串的后缀。

所以考虑如果len - 1不在当前的长度区间内，就往回跳一步去匹配下一个字符（指前面的字符转上来），假设直接到达下一个字符，然后累加答案，更新时间戳。

如果过程不是很顺利，发生了失配，那么又变成了一个当前串的后缀，于是，需要把舍弃的部分加上来，然后继续去for。

简单地说就是设法线性地实现循环同构的匹配。

　　（后来我想了想，发现这两种做法本质是相同的。）

Code

 /**
  * Codeforces
  * Problem#235C
  * Accepted
  * Time:514ms
  * Memory:278100k
  */
 #include <bits/stdc++.h>
 using namespace std;

 #define charset 26
 //这是一个膜拜大佬的宏定义
 #define ModYJQ 2333333

 inline int cti(char x) {    return x - 'a';    }

 typedef class TrieNode {
     public:
         TrieNode* next[charset];
         TrieNode* fail;
         vector<TrieNode*> son;
         int cnt;
         int len;
         int t;
         TrieNode():fail(NULL), cnt(), len(), t(ModYJQ) {
             memset(next, , sizeof(next));
         }
 }TrieNode;

 typedef class SuffixAutomachine {
     public:
         TrieNode *pool;
         TrieNode *top;

         TrieNode* root;
         TrieNode* last;

         TrieNode* newnode() {
             return top++;
         }

         TrieNode* newnode(int len) {
             top->len = len;
             return top++;
         }

         SuffixAutomachine():pool(NULL), top(NULL), root(NULL), last(NULL) {        }
         SuffixAutomachine(int len) {
             pool = new TrieNode[len *  + ];
             top = pool;
             root = newnode();
             last = root;
         }

         inline void extend(char x) {
             int c = cti(x);
             TrieNode* node = newnode(last->len + ), *f = last;
             node->cnt = ;
             while(f && f->next[c] == NULL)
                 f->next[c] = node, f = f->fail;
             if(f == NULL)    node->fail = root;
             else {
                 TrieNode *p = f->next[c];
                 if(p->len == f->len + )    node->fail = p;
                 else {
                     TrieNode *clone = newnode(f->len + );
                     memcpy(clone->next, p->next, sizeof(clone->next));
                     clone->fail = p->fail;
                     p->fail = clone;
                     node->fail = clone;
                     while(f && f->next[c] == p)
                         f->next[c] = clone, f = f->fail;
                 }
             }
             last = last->next[c];
         }
 }SuffixAutomachine;

 int lens;
 int n;
 char str[];
 SuffixAutomachine sam;

 inline void init() {
     gets(str);
     lens = strlen(str);
 }

 int dfs(TrieNode* p) {
     for(int i = ; i < (signed)p->son.size(); i++)
         p->cnt += dfs(p->son[i]);
     return p->cnt;
 }

 inline void init_sam() {
     sam = SuffixAutomachine(lens);
     for(int i = ; i < lens; i++)
         sam.extend(str[i]);
     for(TrieNode* p = sam.pool; p != sam.top; p++) {
         if(p->fail)
             p->fail->son.push_back(p);
     }
     dfs(sam.root);
 }

 inline void solve() {
     scanf("%d", &n);
     gets(str);
     while(n--) {
         gets(str);
         lens = strlen(str);
         memcpy(str + lens, str, sizeof(char) * (lens - ));
         TrieNode* p = sam.root, *q;
         int res = ;
         for(int i = , nlen = , c; i <  * lens -  && p; i++) {
             c = cti(str[i]);
             if(!p->next[c]) {
                 while(p && !p->next[c]) p = p->fail, nlen = (p) ? (p->len) : ();
                 if(!p)    break;
             }
             p = p->next[c], nlen++;
 //            printf("%d %d\n", lens, nlen);
             if(nlen >= lens) {
                 q = p;
                 while(q->fail->len >= lens)
                     q = q->fail;
                 if(q->t != n) {
                     res += q->cnt;
                     q->t = n;
                 }
             }
         }
         printf("%d\n", res);
     }
 }

 int main() {
     init();
     init_sam();
     solve();
     return ;
 }