POJ 3376 Finding Palindromes（Trie+EKMP）

题目链接：点击打开链接

题目大意：给定n个字符串，可重复地取两个字符串，一共n*n种可能的组合，问有多少种组合能构成回文串。

首先给定两个字符串，若连接在一起能组成回文串，那么让短的字符串反转后和长的字符串从两端开始做匹配，如果能完全匹配，且长字符剩余的字符恰好构成一个回文串，那么这两个字符串就能组成一个回文串。

例如：abcc ba (从串首开始匹配) ， ccba ab(从串尾开始匹配)。

根据给定的n个字符串建立Trie树，然后让所有子串反转后做匹配。

这个时候会遇到两种情况：

（1）.子串反转后能在Trie树上完全匹配，（例如：ab 匹配 bacc）此时如果该节点匹配到的串的后缀为回文，那么匹配数+1（可以在插入结点之前预处理出来）。

（2）.子串走到了叶子结点，（例如：bacc 匹配 ab）此时只要反转后的子串未匹配的前缀为回文，那么匹配数+1（Trie树上匹配时候特判一下）。

现在问题就变成了求每个子串的回文前后缀，这个可以利用EKMP在o(n)时间求出：正串匹配反串求回文后缀 反串匹配正串求回文前缀~~~

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<int,int> str;
const int MAXN=2200100;
char ss[MAXN],rev[MAXN];
int nexts[MAXN],extend[MAXN];
bool pre[MAXN],suf[MAXN];
struct node_t
{
    node_t *son[26];
    int leaf;
    int flag;
}node[MAXN];
int toUsed;
inline void init_trie()
{
    toUsed=1;
    memset(node,0,sizeof(node_t));
}
inline node_t* _NewNode()
{
    memset(node+toUsed,0,sizeof(node_t));
    return node+toUsed++;
}
inline void insert(str s)
{
    node_t *loc=node;
    int start=s.first,Ls=s.second;
    for(int i=0;i<Ls;i++)
    {
        int sn=ss[start+i]-'a';
        if(!loc->son[sn]) loc->son[sn]=_NewNode();
        loc=loc->son[sn];
        if(suf[start+i+1]||i==Ls-1) loc->flag++;
    }
    loc->leaf++;
}
void pre_EKMP(char x[],int m,int nexts[])
{
    nexts[0]=m;
    int j=0;
    while(j+1<m&&x[j]==x[j+1]) j++;
    nexts[1]=j;
    int k=1;
    for(int i=2;i<m;i++)
    {
        int p=nexts[k]+k-1;
        int L=nexts[i-k];
        if(i+L<p+1) nexts[i]=L;
        else
        {
            j=max(0,p-i+1);
            while(i+j<m&&x[i+j]==x[j]) j++;
            nexts[i]=j;
            k=i;
        }
    }
}
void EKMP(char x[],int m,char y[],int n,int nexts[],int extend[])
{
    pre_EKMP(x,m,nexts);
    int j=0;
    while(j<n&&j<m&&x[j]==y[j]) j++;
    extend[0]=j;
    int k=0;
    for(int i=1;i<n;i++)
    {
        int p=extend[k]+k-1;
        int L=nexts[i-k];
        if(i+L<p+1) extend[i]=L;
        else
        {
            j=max(0,p-i+1);
            while(i+j<n&&j<m&&y[i+j]==x[j]) j++;
            extend[i]=j;
            k=i;
        }
    }
}
void Reverse_str(char *Des,char *Src,int Len)
{
    for(int i=0;i<Len;i++)
        Des[i]=Src[Len-i-1];
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init_trie();
        memset(pre,0,sizeof(pre));
        memset(suf,0,sizeof(suf));
        int L,tot=0;
        LL ans=0;
        vector<str> v;
        v.clear();
        for(int i=0;i<n;i++)
        {
            scanf("%d%s",&L,ss+tot);
            v.push_back(str(tot,L));
            tot+=L;
        }
        for(int i=0;i<n;i++)
        {
            int start=v[i].first,Ls=v[i].second;
            Reverse_str(rev,ss+start,Ls);
            //正串匹配反串求回文后缀 suf[i]表示以这个开始的字符串为回文
            EKMP(rev,Ls,ss+start,Ls,nexts,extend);
            for(int i=0;i<Ls;i++)
                if(extend[i]+i==Ls) suf[start+i]=true;
            //反串匹配正串求回文前缀 pre[i]表示以这个结尾的字符串为回文
            EKMP(ss+start,Ls,rev,Ls,nexts,extend);
            for(int i=0;i<Ls;i++)
                if(extend[i]+i==Ls) pre[start+extend[i]-1]=true;
        }
        for(int i=0;i<n;i++) insert(v[i]);
        //然后拿反串来匹配~~~~~~
        for(int i=0;i<n;i++)
        {
            int ends=v[i].first+v[i].second-1,Ls=v[i].second;
            node_t *loc=node;
            for(int j=0;j<Ls;j++)
            {
                int sn=ss[ends-j]-'a';
                if(loc->leaf) if(pre[ends-j]) ans+=loc->leaf;
                if(!loc->son[sn]) goto L;
                loc=loc->son[sn];
            }
            ans+=loc->flag;
            L:;
        }
        printf("%lld\n",ans);
    }
    return 0;
}