HDU 6138 Fleet of the Eternal Throne （2017多校8 - AC自动机）

题意：

给你n 个串， q个查询， 每个查询 输出串x 和 串y 的最大公共子串 且这个串 是其他某些串的前缀。 输出长度。

思路：

因为场上读错题， 以为是个极水的后缀数组。= =

其实是ac自动机

我们给n 个串建立ac自动机。

字典树中每个节点维护一个 到根的距离（即是前缀的长度）

然后给串x 跑一遍自动机， 把经过的点的标记出来， 表示 这个点即是 x 的子串， 又是某个串的前缀。

然后在给y 跑一遍自动机， 当经过标记点时 更新一下答案即可， 因为这时候 这个串 即是x 的子串又是y 的子串 又是前缀。 

/*************************************************************************
> File Name: test.cpp
> Author: Akira 
> Mail: qaq.febr2.qaq@gmail.com 
************************************************************************/


#include<bits/stdc++.h>
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))
#define ALL(a) a.begin(), a.end()
#define mp make_pair
#define pb push_back
using namespace std;


#define MaxN 100005
#define MaxM MaxN*10
#define INF 0x3f3f3f3f
#define PI 3.1415926535897932384626
const int mod = 1E9+7;
const double eps = 1e-6;
#define bug cout<<88888888<<endl;
#define debug(x) cout << #x" = " << x << endl;
template<typename T> T abs(T val){return val>0?val:-val;}
inline int max2(int a, int b) {return ((a > b)? a : b);}
inline int min2(int a, int b) {return ((a < b)? a : b);}
inline int max3(int a, int b, int c) {return max2(a, max2(b, c));}
inline int min3(int a, int b, int c) {return min2(a, min2(b, c));}
template <class T> inline void read(T &ret) {char c; ret=0;while((c=getchar())<'0'||c>'9');while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();}
template <class T> inline void out(T x) {if(x>9) out(x/10);putchar(x%10+'0');}


int T,N,Q;
const int nsize = 26;
int tot;
int shushu[100005], changdu[100005];
struct Node
{
    int cnt;//是否为单词最后一个节点
    Node *next[nsize],*fail;//Trie每个节点的26个子节点and失败指针
    Node()
    {
        cnt=0;
        fail=NULL;
        for(int i=0; i<nsize; i++)
            next[i]=0;
    }
}*root;
Node *q[MaxN];//构造失败指针的bfs队列
int head,tail;//队列头尾指针
void insert(string s,Node *p)//插入字符串函数
{
    int len = s.length();
    for(int i=0;i<len;i++)
    {
        // debug(s[i])
        int k=s[i]-'a';
        if(p->next[k]==NULL)
            p->next[k]=new Node();
        p=p->next[k];//指针移动至下一层
        if(p->cnt==0) 
        {
            p->cnt = ++tot;
            changdu[tot] = i+1;
        }
    }
    // p->cnt = v;//单词结尾节点count + 1做标记
}
void build_AC(Node *root)//构造失败指针
{
    head=0;
    tail=1;
    q[head]=root;
    Node *temp,*p;
    while(head<tail)//bfs构造Trie树的失败指针
    {
        temp=q[head++];
        for(int i=0; i<nsize; i++)
        {
            if(temp->next[i])//判断实际存在的节点
            {
                // root下的第一层节点的失败指针都指向root
                if(temp==root)
                temp->next[i]->fail=root;
                else
                {
                    //依次回溯该节点的父节点的失败指针
                    //直到某节点的next[i]与该节点相同，则
                    //把该节点的失败指针指向该next[i]节点
                    //若回溯到 root 都没有找到,则该节点的失败指针 指向 root
                    p=temp->fail;//temp 为节点的父指针
                    while(p)
                    {
                        if(p->next[i])
                        {
                            temp->next[i]->fail=p->next[i];
                            break;
                        }
                        p=p->fail;
                    }
                    if(!p)temp->next[i]->fail=root;
                }
                //每处理一个点,就把它的所有儿子加入队列
                //直到队列为空
                q[tail++]=temp->next[i];
            }
        }
    }
}
int query(string str,Node *root, int val)
{
    int len=str.length();
    Node *p=root;
    //i为主串指针，p为匹配串指针
    for(int i=0; i<len; i++)
    {
        //   debug(str[i])
        int k=str[i]-'a';
        //由失败指针回溯寻找,判断str[i]是否存在于Trie树中
        while(!p->next[k]&&p!=root)
            p=p->fail;
        p=p->next[k];//找到后p指向该节点
        if(!p) p=root;//指针仍为空，则没有找到与之匹配的字符,指针重新回到根节点root,下次从root开始搜索Trie树
        Node *temp=p;//匹配该节点后,沿其失败指针回溯,判断其他节点是否匹配
        while(temp!=root)//匹配结束控制and未被访问控制
        {
            int now = temp->cnt;
            if(now) 
            {
                if(val==1) shushu[now] = val;
                else{
                    if(shushu[now]==1) shushu[now] = val;
                }
            }
            temp=temp->fail;//回溯失败指针继续寻找下一个满足条件的节点
        }
    }
}
void del(Node *root)
{
    if(root==NULL)return ;
    for(int i=0;i<nsize;i++)del(root->next[i]);
    delete(root);
}


string input[100005];
int main()
{
    std::ios::sync_with_stdio(false);
    cin >> T;
    while(T--)
    {
        root = new Node();
        tot = 0;
        cin >> N ;
        memset(changdu, 0, (N+5)*sizeof(int));
        for(int i=1;i<=N;i++)
        {
            cin >> input[i];
            insert(input[i], root);
        }
        build_AC(root);
        cin >> Q;
        int a, b;
        while(Q--)
        {
            cin >> a >> b;
            memset(shushu, 0, (tot+5)*sizeof(int));            
            query(input[a], root,1);
            query(input[b], root,2);
            int ans = 0;
            for(int i=1;i<=tot;i++)
            {
                // cout << shushu[i] << endl;
                if(shushu[i]>=2) ans = max(ans, changdu[i]);
            }
            cout << ans << endl;
        }
        del(root);
    }


    //system("pause");
    //printf("%lld\n", ((x)%mod+mod)%mod );
    //printf("\n%.2lf sec \n", (double)clock() / CLOCKS_PER_SEC);
}