HDU 6096 String(2017 Multi-University Training Contest - Team 6 1001)后缀自动机-优快云博客

本文链接：https://blog.youkuaiyun.com/li7879/article/details/77103699

HDU 6096 String(2017 Multi-University Training Contest - Team 6 1001)

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=6096

题意：

给定N个单词组成一个字典，然后有Q个询问，每个询问给出一个前缀P，一个后缀S，然后求出字典中有多少个前缀为P，后缀为S的单词的个数，并且要求前缀和后缀不能在单词中重叠覆盖

思路：

我们队在比赛过程中想了一个后缀自动机的解法，但是最终由于本人学艺不精，还没有学会后缀自动机，所以最后还是没有写出来，然后今天再学了学后缀自动机，才想明白最后怎么写

我们首先看怎么利用后缀自动机的每个节点的right集合的大小是其对应的这样的子串的个数，所以我们可以把前缀P和后缀S合并起来，形成一个新的字符串S+’#”+P（记为S#P)，然后再对单词W处理，形成一个新的字符串W+’#’+W（W#W），然后在该字符串W#W中如果能够找到S#P那么就代表匹配了一个字符串，所以我们可以把所有的单词这样处理之后，然后在每个单词后面添加上一个’‘（其实仔细想想是不需要添加’‘的，因为查找的字符串一定要含有#），然后将所有的单词都加入到后缀自动机中，然后查询的时候只需要从根节点沿着自动机中的边走到一个状态，然后这个状态节点就是我们所需要的状态节点，求出这个节点对应的right集合大小就可以。但是这样有一个问题就是可能会出现字符串前后缀重叠的情况，所以我们考虑离线的做法，将单词字符串按长度从大到小排序，将询问前后缀按长度从大到小排序，我们每次询问的时候只要保证后缀自动机中的单词都比查询的前后缀长度长就可以了，但是比赛的时候发现了一个问题，我们这样查询的话right集合的大小就必须每次询问Q次，如果是按照模板来的话，每次询问就需要跑一个dfs序，显然不可以，所以我们需要把在添加一个单词的时候动态维护他的right集合大小，注意到我们每次添加一个字符，只会多一个right=L+1的节点，然后我们每次更新这个节点的right集合的cnt就好了，由于每个节点要么是叶子节点，要么有至少两个孩子，所以更新一次是log(n)的n的后缀中单词的大小

代码:

#define debug printf
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<map>
#include<string>
using namespace std;
const int maxn=100000+10;
const int maxlen=500000+5;
const int CHAR=28;
const int MAXN=1160000+5;
int idx[256];
void init()
{
    for(int i=0;i<26;i++){
        idx['a'+i]=i;
    }
    idx['#']=26;
    idx['*']=27;
}
struct SAM_Node{
    SAM_Node * fa,* next[CHAR];
    int len;
    int id,pos;
    int cnt;
    SAM_Node(){cnt=0;}
    SAM_Node(int _len)
    {
        fa=0;
        len=_len;
        cnt=0;
        memset(next,0,sizeof(next));
    }
};

SAM_Node SAM_node[1600000],*SAM_root,*SAM_last;
int SAM_size;
SAM_Node * newSAM_Node(int len)
{
    SAM_node[SAM_size]=SAM_Node(len);
    SAM_node[SAM_size].id=SAM_size;
    return &SAM_node[SAM_size++];
}
SAM_Node * newSAM_Node(SAM_Node * p)
{
    SAM_node[SAM_size]=*p;
    SAM_node[SAM_size].id=SAM_size;
    return &SAM_node[SAM_size++];
}

void SAM_init()
{
    SAM_size=0;
    SAM_root=SAM_last=newSAM_Node(0);
    SAM_node[0].pos=0;
}

void SAM_add(int x,int len)
{
    SAM_Node * p=SAM_last,*np=newSAM_Node(p->len+1);
    np->cnt=1;
    np->pos=len;
    SAM_last=np;
    for(;p&&!p->next[x];p=p->fa){
        p->next[x]=np;
    }
    if(!p){
        np->fa=SAM_root;
        SAM_root->cnt++;
        return;
    }
    SAM_Node * q=p->next[x];
    if(q->len==p->len+1){
        np->fa=q;
         np=np->fa;
         while(np){
            np->cnt++;
//          debug("%d\n",np->cnt);
            np=np->fa;
         }
         return;
    }
    SAM_Node * nq=newSAM_Node(q);
    nq->len=p->len+1;
    q->fa=nq;
    np->fa=nq;
    for(;p&&p->next[x]==q;p=p->fa){
        p->next[x]=nq;
    }
     np=np->fa;
     while(np){
        np->cnt++;
        np=np->fa;
     }
}

void SAM_build(char * s)
{
    SAM_init();
    int len=strlen(s);
    for(int i=0;i<len;i++){
        SAM_add(s[i]-'a',i+1);
    }
}
//int topocnt[MAXN];
//SAM_Node * topsam[MAXN*2];
//void SAM_topo(int n)
//{
//  // int n=strlen(str);
//  // SAM_build(str);
//  memset(topocnt,0,sizeof(topocnt));
//  for(int i=0;i<SAM_size;i++){
//      topocnt[SAM_node[i].len]++;
//  }
//  for(int i=1;i<=n;i++){
//      topocnt[i]+=topocnt[i-1];
//  }
//  for(int i=0;i<SAM_size;i++){
//      topsam[--topocnt[SAM_node[i].len]]=&SAM_node[i];
//  }
//}
struct Node{
    string str;
    int len;
    int idx;
    bool operator < (const Node & thr) const
    {
        return len>thr.len;
    }
    Node(){}
    Node(string str,int idx=0):str(str),idx(idx)
    {
        len=str.length();
    }
};
Node text[maxn];
Node qry[maxn];
char str[maxlen];
int T;
int N,Q;
int ans[maxn];
void solve()
{
    scanf("%d %d",&N,&Q);
    for(int i=1;i<=N;i++){
        scanf("%s",str);
        text[i]=Node(string(str)+string("#")+string(str)+string("*"));
    }
    for(int i=1;i<=Q;i++){
        scanf("%s",str);
        string tmp=string("#")+string(str);
        scanf("%s",str);
        tmp=string(str)+tmp;
        qry[i]=Node(tmp,i);
    }
    sort(text+1,text+1+N);
    sort(qry+1,qry+1+Q);
//  for(int i=1;i<=N;i++){
//      cout<<text[i].str<<" "<<text[i].len<<endl;
//  }
//  for(int i=1;i<=Q;i++){
//      cout<<qry[i].str<<" "<<qry[i].len<<" "<<qry[i].idx<<endl;
//  }
    SAM_init();
    init();
    int cur=1;
    bool chan=false;
    for(int i=1;i<=Q;i++){
        while(cur<=N&&(text[cur].len-2)/2>=(qry[i].len-1)){
//            debug("%d\n",cur);
//            cout<<"text"<<text[cur].str<<endl;
            for(int j=0;j<text[cur].len;j++){
                SAM_add(idx[text[cur].str[j]],j+1);
            }
//            for(int j=0;j<SAM_size;j++){
//              debug("%d %d %d %d %d %d\n",j,SAM_node[j].cnt,SAM_node[j].id,SAM_node[j].len,SAM_node[j].pos,SAM_node[j].fa-SAM_node);
//              for(int k=0;k<CHAR;k++){
//                    debug("%d ",SAM_node[j].next[k]-SAM_node);
//              }
//              debug("\n");
//            }
//            debug("\n");
            cur++;
//            debug("sam_size%d\n",SAM_size);
        }

        SAM_Node * hh=SAM_root;
        chan=true;
        int len=qry[i].len;
//        cout<<"qry"<<qry[i].str<<endl;
        for(int j=0;j<len;j++){
//            debug("%d %d %d %d\n",hh->cnt,hh->id,hh->len,hh->pos);
            if(hh&&hh->next[idx[qry[i].str[j]]]){
                hh=hh->next[idx[qry[i].str[j]]];
            }
            else{
                chan=false;
                break;
            }
        }
        int res=0;
        if(chan){
            res=hh->cnt;
        }
        ans[qry[i].idx]=res;
    }
    for(int i=1;i<=Q;i++){
        cout<<ans[i]<<endl;
    }
}

int main()
{
//    freopen("1001.in","r",stdin);
//    freopen("1001out.out","w",stdout);
    scanf("%d",&T);
    while(T--){
        solve();
    }
    return 0;
}