poj3376 Finding Palindromes【exKMP】【Trie】

Finding Palindromes

Time Limit: 10000MS		Memory Limit: 262144K
Total Submissions:4710		Accepted: 879
Case Time Limit: 2000MS

Description

A word is called a palindrome if we read from right to left is as same as we read from left to right. For example, "dad", "eye" and "racecar" are all palindromes, but "odd", "see" and "orange" are not palindromes.

Given n strings, you can generate n × n pairs of them and concatenate the pairs into single words. The task is to count how many of the so generated words are palindromes.

Input

The first line of input file contains the number of strings n. The following n lines describe each string:

The i+1-th line contains the length of the i-th string l_i, then a single space and a string of l_i small letters of English alphabet.

You can assume that the total length of all strings will not exceed 2,000,000. Two strings in different line may be the same.

Output

Print out only one integer, the number of palindromes.

Sample Input

3
1 a
2 ab
2 ba

Sample Output

5

Hint

The 5 palindromes are: 
aa aba aba abba baab 

Source

POJ Monthly--2007.09.09, Zhou Gelin, modified from POI06

 

题意：

给定n个字符串。问把他们两两组合起来，能有多少个回文串。

思路：

两个字符串$s,t$进行组合有三种情况。

1、$lens=lent$，若$s$和$t$对称，那么可以$st$是一个回文串。

2、$lens>lent$，若$t$和$s$的前缀对称，$s$剩余的部分是一个回文，那么$st$是一个回文串。

3、$lens<lent$，若$s$和$t$的前缀对称，$t$剩余的部分是一个回文，那么$ts$是一个回文串。

现在我们对所有字符串建立一个字典树，然后用每一个反向串在树上进行匹配。

对于第一种可能，很简单，反向串匹配完的那个节点，是$cnt$个字符串的结尾，$ans+=cnt$

对于第二种可能，反向串不能继续匹配了之后，如果剩余的串是是回文，那么也是$ans += cnt$

对于第三种可能，反向串匹配到结尾之后，如果树上这个节点之后有$val$个回文，那么$ans+=val$

因此我们现在需要在Trie树上维护两个值，$cnt$和$val$

 

exKMP我们可以求出某个点之后是不是回文串。

将$s$作为模式串，与反向串$s'$进行exkmp。若$ex[i] = len - i + 1$，那么$s'[i...len]$是一个回文串。

同理将$s'$作为模式串，与$s$进行exkmp。

由此可以在建立Trie树时确定$cnt$和$val$

 

由于题目没有说$n$的范围，只给定了字符串的总长。所以我们只能把所有字符串都存在同一个字符串中，用数组记录开始和结束下标。

 

 #include<iostream>
 //#include<bits/stdc++.h>
 #include<cstdio>
 #include<cmath>
 //#include<cstdlib>
 #include<cstring>
 #include<algorithm>
 //#include<queue>
 #include<vector>
 //#include<set>
 //#include<climits>
 //#include<map>
 using namespace std;
 typedef long long LL;
 typedef unsigned long long ull;
 #define N 100010
 #define pi 3.1415926535
 #define inf 0x3f3f3f3f

 const int maxn = 2e6 + ;
 int n, sum_len;
 char s[maxn], s_rev[maxn];
 int st[maxn], ed[maxn];

 int nxt[maxn], ex[maxn];
 bool flag[][maxn];
 void GETNEXT(char *str, int l, int r)
 {
     int i=l,j,po;
     nxt[i]=r - l + ;//初始化next[0]
     while(str[i]==str[i+]&&i<=r)//计算next[1]
     i++;
     nxt[l + ]=i - l;
     po= + l;//初始化po的位置
     for(i=+l;i<=r;i++)
     {
         if(nxt[i-po + l]+i - l<nxt[po]+po - l)//第一种情况，可以直接得到next[i]的值
         nxt[i]=nxt[i-po + l];
         else//第二种情况，要继续匹配才能得到next[i]的值
         {
             j=nxt[po]+po-i;
             if(j<)j=;//如果i>po+next[po],则要从头开始匹配
             while(i+j<=r&&str[l+j]==str[j+i])//计算next[i]
             j++;
             nxt[i]=j;
             po=i;//更新po的位置
         }
     }
 }
 //计算extend数组
 void EXKMP(char *s1,char *s2, int l, int r, int sign)
 {
     int i=l,j,po;
     GETNEXT(s2, l, r);//计算子串的next数组
     //for(j = l; j <= r; j++)cout<<nxt[j]<<endl;
     while(s1[i]==s2[i]&&i<=r)//计算ex[0]
     i++;
     ex[l]=i - l;
     po=l;//初始化po的位置
     for(i=l + ;i<=r;i++)
     {
         if(nxt[i-po + l]+i - l<ex[po]+po -l)//第一种情况，直接可以得到ex[i]的值
         ex[i]=nxt[i-po+l];
         else//第二种情况，要继续匹配才能得到ex[i]的值
         {
             j=ex[po]+po-i;
             if(j<)j=;//如果i>ex[po]+po则要从头开始匹配
             while(i+j<=r&&s1[j+i]==s2[l+j])//计算ex[i]
             j++;
             ex[i]=j;
             po=i;//更新po的位置
         }
     }
     for(int i = l; i <= r; i++){
         //cout<<ex[i]<<endl;
         if(ex[i] == r - i + ){
             flag[sign][i] = true;
         }
     }
 }

 struct Trie{
     int trie[maxn][];
     int cnt[maxn];
     int val[maxn];
     int tot;
 }tr;

 void init()
 {
     memset(flag, , sizeof(flag));
     memset(nxt, , sizeof(nxt));
     memset(ex, , sizeof(ex));
     for(int i = ; i <= tr.tot; i++){
         memset(tr.trie[i], , sizeof(tr.trie[i]));
         tr.cnt[i] = ;
         tr.val[i] = ;
     }
     tr.tot = ;
 }

 void insertt(char *str, int l, int r)
 {
     int p = ;
     for(int k = l; k <= r; k++){
         int ch = str[k] - 'a';
         tr.val[p] += flag[][k];
         if(tr.trie[p][ch] == ){
             tr.trie[p][ch] = ++tr.tot;
         }
         p = tr.trie[p][ch];

     }
     tr.cnt[p]++;
 }

 LL searchh(char *str, int l, int r)
 {
     LL ans = ;
     int p = ;
     for(int k = l; k <= r; k++){
         //cout<<flag[k]<<endl;
         int ch = str[k] - 'a';
         p = tr.trie[p][ch];
         if(p == )break;
         if(k < r && flag[][k + ] || k == r)ans += tr.cnt[p];
     }
     if(p)ans += tr.val[p];
     //ans += tr.cnt[p];
     return ans;
 }

 int main()
 {
     while(scanf("%d", &n) != EOF){
         sum_len = ;
         init();
         for(int i = ; i < n; i++){
             int l;
             scanf("%d %s", &l, s + sum_len);
             for(int j = ; j < l; j++){
                 s_rev[sum_len + j] = s[sum_len + l -  - j];
             }
             st[i] = sum_len;
             sum_len += l;
             ed[i] = sum_len - ;

             EXKMP(s, s_rev, st[i], ed[i], );
             EXKMP(s_rev, s, st[i], ed[i], );
             insertt(s, st[i], ed[i]);
         }

         LL ans = ;
         /*for(int i = 0; i < sum_len; i++){
             cout<<s[i]<<" "<<flag[0][i]<<" "<<flag[1][i]<<endl;
         }*/
         //cout<<s<<endl;
         for(int i = ; i < n; i++){
             ans += searchh(s_rev, st[i], ed[i]);
         }
         printf("%lld\n", ans);
     }
     return ;
 }