AC自动机及KMP练习

好久都没敲过KMP和AC自动机了。以前只会敲个kuangbin牌板子套题。现在重新写了自己的板子加深了印象。并且刷了一些题来增加自己的理解。

KMP网上教程很多，但我的建议还是先看AC自动机（Trie图）的构造后再去理解。板子的话大家大同小异。

而AC自动机的构造则是推荐王贇的《Trie图的构建、活用与改进》。

前面的备用知识则是字典树。推荐董华星的《浅析字母树在信息学竞赛中的应用》。董聚聚不仅仅是介绍了字典树，包括一些常见的应用也有论述，介绍的挺详细的。

接下来就是刷题的部分了。

hdu 5880

Family View

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2660    Accepted Submission(s): 577

Problem Description

Steam is a digital distribution platform developed by Valve Corporation offering digital rights management (DRM), multiplayer gaming and social networking services. A family view can help you to prevent your children access to some content which are not suitable for them.

Take an MMORPG game as an example, given a sentence T, and a list of forbidden words {P}, your job is to use '*' to subsititute all the characters, which is a part of the substring matched with at least one forbidden word in the list (case-insensitive).

For example, T is: "I love Beijing's Tiananmen, the sun rises over Tiananmen. Our great leader Chairman Mao, he leades us marching on."

And {P} is: {"tiananmen", "eat"}

The result should be: "I love Beijing's *********, the sun rises over *********. Our gr*** leader Chairman Mao, he leades us marching on."

 

Input

The first line contains the number of test cases. For each test case:
The first line contains an integer n

, represneting the size of the forbidden words list P

. Each line of the next n

lines contains a forbidden words Pi (1≤|Pi|≤1000000,∑|Pi|≤1000000)

where Pi

only contains lowercase letters.

The last line contains a string T (|T|≤1000000)

.

 

Output

For each case output the sentence in a line.

 

Sample Input

1
3
trump
ri
o
Donald John Trump (born June 14, 1946) is an American businessman, television personality, author, politician, and the Republican Party nominee for President of the United States in the 2016 election. He is chairman of The Trump Organization, which is the principal holding company for his real estate ventures and other business interests.

 

Sample Output

D*nald J*hn ***** (b*rn June 14, 1946) is an Ame**can businessman, televisi*n pers*nality, auth*r, p*litician, and the Republican Party n*minee f*r President *f the United States in the 2016 electi*n. He is chairman *f The ***** *rganizati*n, which is the p**ncipal h*lding c*mpany f*r his real estate ventures and *ther business interests.

 

Source

2016 ACM/ICPC Asia Regional Qingdao Online

 

---

 

裸题，把模式串构成Trie图然后在主串中匹配。Trie图中设置标记tag，若本身就是词尾节点则tag指向自己，否则指向该节点离他最近的词尾后缀节点。没有则指向根节点。接下来就转化为线段覆盖问题了。扫主串的时候扫到模式串对应的词头位置pos++，词尾pos--。接着求字符串pos前缀和，前缀和>0的部分赋’*’，然后输出字符串。

有两个版本，一个是刚开始按KMP的想法写的，稍微改改就能改成孩子兄弟链法：

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<queue>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define INF 0x3f3f3f3f
 #define mod 1000000007
 #define LL long long
 #define next nexted
 using namespace std;
 const int N=1e6+;
 const int type=;
 struct node
 {
     int pre;
     int dep;
     int tag;
     int next[type];
 }trie[N];
 int tot;
 int pos[N];
 int newnode()
 {
    trie[++tot]=(node){};
     return tot;
 }
 void add(int root,char *s)
 {
     int len=strlen(s);
     int now=root;
     int p;
     for(int i=;i<len;i++)
     {
         p=s[i]-'a';
         if(!trie[now].next[p])
         {
             trie[now].next[p]=newnode();
         }
         now=trie[now].next[p];
         trie[now].dep=i+;
     }
     trie[now].tag=now;
 }
 void init()
 {
     tot=;
     trie[]=(node){};
     clr(pos);
     return ;
 }
 void getfail()
 {
     queue<int> que;
     int now,nowto,j;
     for(int i=;i<type;i++)
         if(trie[].next[i])
             que.push(trie[].next[i]);
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(nowto)
             {
                 que.push(nowto);
                 j=trie[now].pre;
                 while(j && !trie[j].next[i])
                     j=trie[j].pre;
                 trie[nowto].pre=trie[j].next[i];
                 if(trie[trie[j].next[i]].tag && !trie[nowto].tag)
                     trie[nowto].tag=trie[trie[j].next[i]].tag;
             }
         }
     }
     return ;
 }
 void acm(char *s)
 {
     int j=,p,tmp;
     int len=strlen(s);
     for(int i=;i<len;i++)
     if((s[i]>='a' && s[i]<='z')||(s[i]>='A' && s[i]<='Z'))
     {
         p=(s[i]>='a' && s[i]<='z')?s[i]-'a':s[i]-'A';
         while(j && !trie[j].next[p])
         {
             j=trie[j].pre;
         }
         j=trie[j].next[p];
         if(trie[j].tag)
         {
             pos[i+]--;
             pos[i-trie[trie[j].tag].dep+]++;
         }
     }
     else
     {
         j=;
         continue;
     }
     j=;
     for(int i=;i<len;i++)
     {
         j+=pos[i];
         if(j>)
             s[i]='*';
     }
     return ;
 }
 int T,n,m;
 char s[N];
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         init();
         scanf("%d",&n);
         gets(s);
         for(int i=;i<=n;i++)
         {
             gets(s);
             add(,s);
         }
         getfail();
         gets(s);
         acm(s);
         printf("%s\n",s);
     }
     return ;
 }

然后是按照论文里面bfs的构造法写的：

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<queue>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define INF 0x3f3f3f3f
 #define mod 1000000007
 #define LL long long
 #define next nexted
 using namespace std;
 const int N=1e6+;
 const int type=;
 struct node
 {
     int pre;
     int dep;
     int tag;
     int next[type];
 }trie[N];
 int tot;
 int pos[N];
 int newnode()
 {
    trie[++tot]=(node){};
     return tot;
 }
 void add(int root,char *s)
 {
     int len=strlen(s);
     int now=root;
     int p;
     for(int i=;i<len;i++)
     {
         p=s[i]-'a';
         if(!trie[now].next[p])
             trie[now].next[p]=newnode();
         now=trie[now].next[p];
         trie[now].dep=i+;
     }
     trie[now].tag=now;
 }
 void init()
 {
     tot=;
     trie[]=(node){};
     clr(pos);
     return ;
 }
 void build()
 {
     queue<int> que;
     int now,nowto;
     for(int i=;i<type;i++)
         if(trie[].next[i])
             que.push(trie[].next[i]);
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(nowto)
             {
                 que.push(nowto);
                 trie[nowto].pre=trie[trie[now].pre].next[i];
                 if(trie[trie[nowto].pre].tag && !trie[nowto].tag)
                     trie[nowto].tag=trie[trie[nowto].pre].tag;
             }
             else
                 trie[now].next[i]=trie[trie[now].pre].next[i];
         }
     }
     return ;
 }
 void acm(char *s)
 {
     int now=,p,tmp;
     int len=strlen(s);
     for(int i=;i<len;i++)
     if((s[i]>='a' && s[i]<='z')||(s[i]>='A' && s[i]<='Z'))
     {
         p=(s[i]>='a' && s[i]<='z')?s[i]-'a':s[i]-'A';
         now=trie[now].next[p];
         if(trie[now].tag)
         {
             pos[i+]--;
             pos[i-trie[trie[now].tag].dep+]++;
         }
     }
     else
     {
         now=;
         continue;
     }
     now=;
     for(int i=;i<len;i++)
     {
         now+=pos[i];
         if(now>)
             s[i]='*';
     }
     return ;
 }
 int T,n,m;
 char s[N];
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         init();
         scanf("%d",&n);
         gets(s);
         for(int i=;i<=n;i++)
         {
             gets(s);
             add(,s);
         }
         build();
         gets(s);
         acm(s);
         printf("%s\n",s);
     }
     return ;
 }

tips: 虽然题目给的模式串总长不超过10⁶然而实际不超过5*10⁵,trie数组可以不开那么大，或者你改成孩子兄弟链法也是可行的。因为你一旦开那么大就会MLE。

然而你们看我代码为什么就不超呢。。我也是弄了好久才明白。。原来杭电他测内存占用的映射机制，只有当你使用过这个变量才会计算他是占用内存的。。所以你不写memset()或者对trie数组写指针引用的话，就不会超内存。

bzoj 2938

2938: [Poi2000]病毒

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 1300  Solved: 647
[Submit][Status][Discuss]

Description

二进制病毒审查委员会最近发现了如下的规律：某些确定的二进制串是病毒的代码。如果某段代码中不存在任何一段病毒代码，那么我们就称这段代码是安全的。现在委员会已经找出了所有的病毒代码段，试问，是否存在一个无限长的安全的二进制代码。

示例：

例如如果{011, 11, 00000}为病毒代码段，那么一个可能的无限长安全代码就是010101…。如果{01, 11, 000000}为病毒代码段，那么就不存在一个无限长的安全代码。

任务：

请写一个程序：

l         读入病毒代码；

l         判断是否存在一个无限长的安全代码；

l         将结果输出

Input

 

第一行包括一个整数n，表示病毒代码段的数目。以下的n行每一行都包括一个非空的01字符串——就是一个病毒代码段。所有病毒代码段的总长度不超过30000。

Output

你应在在文本文件WIN.OUT的第一行输出一个单词：

l         TAK——假如存在这样的代码；

l         NIE——如果不存在。

Sample Input

3
01
11
00000

Sample Output

NIE

 

---

论文题。把Trie图构造出来以后dfs跑他的安全图看有没有环就行。有环说明能在这个环里一直跑，构造的字符串能无限长，无环则必定在某个位置到达词尾节点结束。

 #include<bits/stdc++.h>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define INF 0x3f3f3f3f
 #define mod 1000000007
 #define LL long long
 #define next nexted
 using namespace std;
 const int N=3e4+;
 const int type=;
 char s[N];
 int n,m,T,tot;
 int vis[N];
 struct node
 {
     int pre,tag,dep,next[];
 }trie[N];
 void init()
 {
     tot=;
     clr(trie);
     clr(vis);
     return ;
 }
 int makenode()
 {
     return ++tot;
 }
 void add(int root,char *s)
 {
     int now=root,len=strlen(s),p;
     for(int i=;i<len;i++)
     {
         p=s[i]-'';
         if(!trie[now].next[p]) trie[now].next[p]=makenode();
         now=trie[now].next[p];
         trie[now].dep=i+;
     }
     trie[now].tag=now;
     return ;
 }
 void build()
 {
     queue<int> que;
     for(int i=;i<type;i++)
         if(trie[].next[i]) que.push(trie[].next[i]);
     int now,nowto;
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(nowto)
             {
                 trie[nowto].pre=trie[trie[now].pre].next[i];
                 que.push(nowto);
                 if(trie[trie[nowto].pre].tag && !trie[nowto].tag)
                     trie[nowto].tag=trie[trie[nowto].pre].tag;
             }
             else
                 trie[now].next[i]=trie[trie[now].pre].next[i];
         }
     }
     return ;
 }
 bool dfs(int now)
 {
     if(trie[now].tag || vis[now]==) return ;
     if(vis[now]==) return ;
     vis[now]=;
     bool inf=;
     for(int i=;i<type;i++)
         inf=(inf || dfs(trie[now].next[i]));
     vis[now]=;
     return inf;
 }
 int main()
 {
     scanf("%d",&n);
     init();
     for(int i=;i<=n;i++)
     {
         scanf("%s",s);
         add(,s);
     }
     build();
     if(dfs())
         printf("TAK\n");
     else
         printf("NIE\n");
     return ;
 }

bzoj 3670

3670: [Noi2014]动物园

Time Limit: 10 Sec  Memory Limit: 512 MB
Submit: 3403  Solved: 1849
[Submit][Status][Discuss]

Description

近日，园长发现动物园中好吃懒做的动物越来越多了。例如企鹅，只会卖萌向游客要吃的。为了整治动物园的不良风气，让动物们凭自己的真才实学向游客要吃的，园长决定开设算法班，让动物们学习算法。

某天，园长给动物们讲解KMP算法。

园长：“对于一个字符串S，它的长度为L。我们可以在O(L)的时间内，求出一个名为next的数组。有谁预习了next数组的含义吗？”

熊猫：“对于字符串S的前i个字符构成的子串，既是它的后缀又是它的前缀的字符串中（它本身除外），最长的长度记作next[i]。”

园长：“非常好！那你能举个例子吗？”

熊猫：“例S为abcababc，则next[5]=2。因为S的前5个字符为abcab，ab既是它的后缀又是它的前缀，并且找不到一个更长的字符串满足这个性质。同理，还可得出next[1] = next[2] = next[3] = 0，next[4] = next[6] = 1，next[7] = 2，next[8] = 3。”

园长表扬了认真预习的熊猫同学。随后，他详细讲解了如何在O(L)的时间内求出next数组。

下课前，园长提出了一个问题：“KMP算法只能求出next数组。我现在希望求出一个更强大num数组一一对于字符串S的前i个字符构成的子串，既是它的后缀同时又是它的前缀，并且该后缀与该前缀不重叠，将这种字符串的数量记作num[i]。例如S为aaaaa，则num[4] = 2。这是因为S的前4个字符为aaaa，其中a和aa都满足性质‘既是后缀又是前缀’，同时保证这个后缀与这个前缀不重叠。而aaa虽然满足性质‘既是后缀又是前缀’，但遗憾的是这个后缀与这个前缀重叠了，所以不能计算在内。同理，num[1] = 0,num[2] = num[3] = 1,num[5] = 2。”

最后，园长给出了奖励条件，第一个做对的同学奖励巧克力一盒。听了这句话，睡了一节课的企鹅立刻就醒过来了！但企鹅并不会做这道题，于是向参观动物园的你寻求帮助。你能否帮助企鹅写一个程序求出num数组呢？

特别地，为了避免大量的输出，你不需要输出num[i]分别是多少，你只需要输出对1,000,000,007取模的结果即可。

Input

第1行仅包含一个正整数n ，表示测试数据的组数。随后n行，每行描述一组测试数据。每组测试数据仅含有一个字符串S，S的定义详见题目描述。数据保证S 中仅含小写字母。输入文件中不会包含多余的空行，行末不会存在多余的空格。

Output

包含 n 行，每行描述一组测试数据的答案，答案的顺序应与输入数据的顺序保持一致。对于每组测试数据，仅需要输出一个整数，表示这组测试数据的答案对 1,000,000,007 取模的结果。输出文件中不应包含多余的空行。

Sample Input

3
aaaaa
ab
abcababc

Sample Output

36
1
32

HINT

n≤5,L≤1,000,000

 

---

这题是15年王鉴浩的论文题。对于本题我们对每个字符串算出next数组，并建立KMP自动机。然后dfs一遍KMP自动机，拿个数组存dfs经过点的编号。在节点u上，二分查找上述数组他所有小于等于u/2的祖先的个数，即为num[I]+1。

 #include<bits/stdc++.h>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define mod 1000000007
 #define LL long long
 using namespace std;
 const int N=1e6+;
 int next[N];
 struct edg
 {
     int next,to;
 }edge[N];
 int head[N],etot;
 void init()
 {
     etot=;
     clr_1(head);
     return ;
 }
 void addedge(int u,int v)
 {
     edge[++etot]=(edg){head[u],v};
     head[u]=etot;
     return ;
 }
 int que[N],ans[N];
 char s[N];
 int n,len,T,rans;
 int getfail(int n,char *s)
 {
     int j=,len=strlen(s);
     next[]=next[]=;
     addedge(,);
     for(int i=;i<len;i++)
     {
         while(j && s[i]!=s[j]) j=next[j];
         if(s[i]==s[j]) j++;
         next[i+]=j;
         addedge(j,i+);
     }
 }
 void dfs(int u,int dep)
 {
     ans[u]=upper_bound(que+,que+dep,u/)-que;
     ans[u]--;
     que[dep]=u;
     for(int i=head[u];i!=-;i=edge[i].next)
         dfs(edge[i].to,dep+);
     return ;
 }
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         init();
         scanf("%s",s);
         len=strlen(s);
         getfail(n,s);
         dfs(,);
         rans=;
         for(int i=;i<=len;i++)
             rans=((LL)ans[i]*rans)%mod;
         printf("%d\n",rans);
     }

 }

bzoj 3172

3172: [Tjoi2013]单词

Time Limit: 10 Sec  Memory Limit: 512 MB
Submit: 4761  Solved: 2333
[Submit][Status][Discuss]

Description

某人读论文，一篇论文是由许多单词组成。但他发现一个单词会在论文中出现很多次，现在想知道每个单词分别在论文中出现多少次。

Input

第一个一个整数N,表示有多少个单词，接下来N行每行一个单词。每个单词由小写字母组成，N<=200,单词长度不超过10^6

Output

输出N个整数，第i行的数字表示第i个单词在文章中出现了多少次。

Sample Input

3
a
aa
aaa

Sample Output

6
3
1

HINT

 

Source

---

此题最朴素想法就是建一个trie图然后在把原文章在trie图上跑一遍，把跑到的每个节点cnt都++。然后在dfs一遍trie树回溯时把节点的cnt加到他的后缀指针节点的cnt上。不过据说会TLE我就没尝试了，毕竟再跑一遍trie图实在是花时间。于是我们想这题能不能把大头的时间去掉。我的选择就是在建立trie图的时候也在原文章上跑，省去了再跑一遍的时间。做法就是建立的时候经过的点cnt++。然后你dfs整个trie树也好，建立一个fail树也好。都是要把所有节点dfs一遍的233。我选择fail树，毕竟是fail树练手题。也就是每个单词出现的次数即其词尾的子树cnt之和。

 #include<bits/stdc++.h>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define mod 1000000007
 #define LL long long
 using namespace std;
 const int N=1e6+;
 const int M=2e2+;
 const int type=;
 char s[N];
 int pt[M];
 struct node
 {
     int next[type],tag,sum,suf;
 }trie[N];
 int tot;
 int makenode()
 {
     ++tot;
     clr(&trie[tot]);
     return tot;
 }
 void add(char *s,int num)
 {
     int now=,len=strlen(s),p;
     for(int i=;i<len;i++)
     {
         p=s[i]-'a';
         if(!trie[now].next[p])
             trie[now].next[p]=makenode();
         now=trie[now].next[p];
         trie[now].sum++;
     }
     trie[now].tag=now;
     pt[num]=now;
     return ;
 }
 struct edg
 {
     int next,to;
 }edge[N];
 int head[N],etot;
 void addedge(int u,int v)
 {
     edge[++etot]=(edg){head[u],v};
     head[u]=etot;
     return ;
 }
 void init()
 {
     tot=etot=;
     clr_1(head);
     return ;
 }
 void build()
 {
     int now,nowto;
     queue<int> que;
     for(int i=;i<type;i++)
         if(trie[].next[i])
         {
             que.push(trie[].next[i]);
             addedge(,trie[].next[i]);
         }
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(nowto)
             {
                 que.push(nowto);
                 trie[nowto].suf=trie[trie[now].suf].next[i];
                 addedge(trie[nowto].suf,nowto);
                 if(!trie[nowto].tag)
                         trie[nowto].tag=trie[trie[nowto].suf].tag;
             }
             else
                 trie[now].next[i]=trie[trie[now].suf].next[i];
         }
     }
     return ;
 }
 void dfs(int u)
 {
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         dfs(edge[i].to);
         trie[u].sum+=trie[edge[i].to].sum;
     }
     return ;
 }
 int n,m,T;
 int main()
 {
     init();
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     {
         scanf("%s",s);
         add(s,i);
     }
     build();
     dfs();
     for(int i=;i<=n;i++)
         printf("%d\n",trie[pt[i]].sum);
     return ;
 }

bzoj 2434

2434: [Noi2011]阿狸的打字机

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 3996  Solved: 2194
[Submit][Status][Discuss]

Description

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和'B'、'P'两个字母。

经阿狸研究发现，这个打字机是这样工作的：

l 输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。

l 按一下印有'B'的按键，打字机凹槽中最后一个字母会消失。

l 按一下印有'P'的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。

例如，阿狸输入aPaPBbP，纸上被打印的字符如下：

a

aa

ab

我们把纸上打印出来的字符串从1开始顺序编号，一直到n。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数(x,y)（其中1≤x,y≤n），打字机会显示第x个打印的字符串在第y个打印的字符串中出现了多少次。

阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

Input

输入的第一行包含一个字符串，按阿狸的输入顺序给出所有阿狸输入的字符。

第二行包含一个整数m，表示询问个数。

接下来m行描述所有由小键盘输入的询问。其中第i行包含两个整数x, y，表示第i个询问为(x, y)。

Output

输出m行，其中第i行包含一个整数，表示第i个询问的答案。

Sample Input

aPaPBbP

3

1 2

1 3

2 3

Sample Output

2

1

0

HINT

1<=N<=10^5

1<=M<=10^5

输入总长<=10^5

Source

Trie

---

 

AC自动机+Fail树+dfs时间戳+树状数组（离线处理）

 

首先建一颗Trie，根据输入字符串建树，遇到B返回父节点，P则是把当前节点作为第k个字符串词尾节点。其他字符则是按照正常建树过程建树。然后把它改造成Trie图并建立Fail树。

我们发觉第i个字符串在第j个字符串出现的次数，是第j个字符串的路径节点失配到第i个字符串的词尾节点p的个数（想想为什么？~）。即我们要统计fail树中p的子树中，第i个字符串路径节点的个数。

那我们把fail树的dfs时间戳求出来，我们的子树就对应了一个区间。

因此我们反过来，把第j个字符串经过的路径节点都+1，然后反过来求所有的i字符串对应的词尾节点的子树区间内的和。这个可以线段树也可以树状数组（当然树状数组啊写起来快一点）。

因此我们再跑一遍输入这个字符串，每跑过一个节点就把它对应的时间戳位置+1，返回就-1。跑到输出（P）第j个字符串的时候，把它所有对应的i都处理，求他们各自的p结点子树区间和，即为他们对应的答案。

 #include<bits/stdc++.h>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define mod 1000000007
 #define LL long long
 #define time timed
 using namespace std;
 const int N=1e5+;
 const int type=;
 char s[N];
 int pt[N];
 struct node
 {
     int next[type],suf,fa;
 }trie[N];
 int tot,cnt,m;
 int makenode()
 {
     ++tot;
     clr(&trie[tot]);
     return tot;
 }
 struct edg
 {
     int next,to;
 }edge[N],ques[N];
 int head[N],qhead[N],qtot,etot;
 int ans[N];
 int u,v,time,fro[N],bac[N],len;
 int bits[N];
 void addedge(int u,int v)
 {
     edge[++etot].next=head[u];
     edge[etot].to=v;
     head[u]=etot;
     return;
 }
 void addques(int u,int v)
 {
     ques[++qtot].next=qhead[u];
     ques[qtot].to=v;
     qhead[u]=qtot;
     return;
 }
 void init()
 {
     cnt=tot=;
     etot=qtot=;
     time=;
     clr_1(head);
     clr_1(qhead);
     clr(bits);
 }
 void create(char *s)
 {
     int now=,len=strlen(s),p;
     for(int i=;i<len;i++)
     {
         if(s[i]=='B') now=trie[now].fa;
         else if(s[i]=='P') pt[++cnt]=now;
         else
         {
             p=s[i]-'a';
             if(!trie[now].next[p])
             {
                 trie[now].next[p]=makenode();
                 trie[trie[now].next[p]].fa=now;
             }
             now=trie[now].next[p];
         }
     }
 }
 void build()
 {
     queue<int> que;
     int now,nowto;
     for(int i=;i<type;i++)
     if(trie[].next[i])
     {
         addedge(,trie[].next[i]);
         que.push(trie[].next[i]);
     }
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(nowto)
             {
                 que.push(nowto);
                 trie[nowto].suf=trie[trie[now].suf].next[i];
                 addedge(trie[nowto].suf,nowto);
             }
             else
                 trie[now].next[i]=trie[trie[now].suf].next[i];
         }
     }
     return ;
 }
 void dfs(int u)
 {
     fro[u]=++time;
     for(int i=head[u];i!=-;i=edge[i].next) dfs(edge[i].to);
     bac[u]=time;
     return ;
 }
 void add(int x,int val)
 {
     while(x<=time)
     {
         bits[x]+=val;
         x+=x&-x;
     }
     return ;
 }
 int getsum(int x)
 {
     int ans=;
     while(x)
     {
         ans+=bits[x];
         x-=x&-x;
     }
     return ans;
 }
 void getans(char *s)
 {
     int now=,len=strlen(s),p;
     int ct=;
     for(int i=;i<len;i++)
     {
         if(s[i]=='B')
         {
             add(fro[now],-);
             now=trie[now].fa;
         }
         else if(s[i]=='P')
         {
             ct++;
             for(int i=qhead[ct];i!=-;i=ques[i].next)
             {
                 p=ques[i].to;
                 ans[i]=getsum(bac[pt[p]])-getsum(fro[pt[p]]-);
             }
         }
         else
         {
             p=s[i]-'a';
             now=trie[now].next[p];
             add(fro[now],);
         }
     }
     return ;
 }
 int main()
 {
     scanf("%s",s);
     init();
     create(s);
     build();
     scanf("%d",&m);
     for(int i=;i<=m;i++)
     {
         scanf("%d%d",&u,&v);
         addques(v,u);
     }
     dfs();
     getans(s);
     for(int i=;i<=m;i++)
         printf("%d\n",ans[i]);
     return ;
 }

 bzoj 3881

3881: [Coci2015]Divljak

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 1041  Solved: 340
[Submit][Status][Discuss]

Description

Alice有n个字符串S_1,S_2...S_n，Bob有一个字符串集合T，一开始集合是空的。

接下来会发生q个操作，操作有两种形式：

“1 P”，Bob往自己的集合里添加了一个字符串P。

“2 x”，Alice询问Bob，集合T中有多少个字符串包含串S_x。（我们称串A包含串B，当且仅当B是A的子串）

Bob遇到了困难，需要你的帮助。

 

 

Input

第1行，一个数n；

接下来n行，每行一个字符串表示S_i；

下一行，一个数q；

接下来q行，每行一个操作，格式见题目描述。

Output

对于每一个Alice的询问，帮Bob输出答案。

Sample Input

3
a
bc
abc
5
1 abca
2 1
1 bca
2 2
2 3

Sample Output

1
2
1

HINT

【数据范围】

1 <= n,q <= 100000；

Alice和Bob拥有的字符串长度之和各自都不会超过 2000000；

字符串都由小写英文字母组成。

---

AC自动机+Fail树+dfs时间戳+虚树（树链的并?）+树状数组

跟上一题差不多，不过我们这次要做的不是包含多少个子串，而是被多少串包含。那么你先把所有alice的字符串建一个Trie图，建立fail树。然后bob加入字符串的时候就相当于在这个trie图上跑，经过的路径点染上相同的颜色。alice询问的时候就相当于查询这个字符串尾节点的子树有多少不同的颜色。

然后难就难在这个不同颜色。你对于所有路径点+根节点点（root）建立虚树。然后每个点给他+1，他的父亲节点-1。这样就能得出结果了。

抄错了虚树板子卡了我好久，其实就是抄一个正确的虚树板子就过了。

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<stack>
 #include<queue>
 #include<algorithm>
 #define clr(x) memset(x,0,sizeof(x))
 #define clr_1(x) memset(x,-1,sizeof(x))
 #define mod 1000000007
 #define LL long long
 using namespace std;
 const int N=2e6+;
 const int M=1e5+;
 const int type=;
 struct node{
     int next[type],suf;
 }trie[N];
 int tcnt;
 char s[N];
 int pt[M];
 queue<int> que;
 stack<int> sta;
 struct edg
 {
     int next,to;
 }edge[N];
 int head[N],ecnt;
 int fa[N][],bit[];
 int clk,fro[N],bac[N],dep[N];
 int tot,ppt[N],vfa[N];
 int bits[N];
 void add(int x,int val)
 {
     while(x<=clk)
     {
         bits[x]+=val;
         x+=x&-x;
     }
     return ;
 }
 int getsum(int x)
 {
     int ans=;
     while(x)
     {
         ans+=bits[x];
         x-=x&-x;
     }
     return ans;
 }
 inline int sum(int l,int r)
 {
     return getsum(r)-getsum(l-);
 }
 void init()
 {
     tcnt=;
     ecnt=;
     clr_1(head);
     bit[]=;
     for(int i=;i<;i++)
         bit[i]=bit[i-]<<;
     clk=;
     return ;
 }
 int makenode()
 {
     ++tcnt;
     memset(&trie[tcnt],,sizeof(trie[tcnt]));
     return tcnt;
 }
 void addedge(int u,int v)
 {
     edge[++ecnt].next=head[u];
     edge[ecnt].to=v;
     head[u]=ecnt;
     return;
 }
 int insert(char *s)
 {
     int now=,p;
     for(int i=;s[i];i++)
     {
         p=s[i]-'a';
         if(!trie[now].next[p])
             trie[now].next[p]=makenode();
         now=trie[now].next[p];
     }
     return now;
 }
 void build()
 {
     int now=,nowto;
     for(int i=;i<type;i++)
         if(trie[now].next[i])
             que.push(trie[now].next[i]);
     while(!que.empty())
     {
         now=que.front();
         que.pop();
         for(int i=;i<type;i++)
         {
             nowto=trie[now].next[i];
             if(!nowto)
                 trie[now].next[i]=trie[trie[now].suf].next[i];
             else
                 que.push(nowto),trie[nowto].suf=trie[trie[now].suf].next[i];
         }
     }
     for(int i=;i<=tcnt;i++)
         addedge(trie[i].suf,i);
     return ;
 }
 void dfs(int u,int deep,int f)
 {
     dep[u]=deep;
     fa[u][]=f;
     fro[u]=++clk;
     for(int i=;bit[i]<=deep;i++) fa[u][i]=fa[fa[u][i-]][i-];
     for(int i=head[u];~i;i=edge[i].next)
         dfs(edge[i].to,deep+,u);
     bac[u]=clk;
 }
 bool cmp(int a,int b)
 {
     return fro[a]<fro[b];
 }
 int lca(int u,int v)
 {
     if(dep[u]<dep[v]) swap(u,v);
     int tmp=dep[u]-dep[v];
     for(int i=;bit[i]<=tmp;i++)
         if(tmp&bit[i]) u=fa[u][i];
     int i=;
     while(bit[i]>dep[u]) i--;
     for(;i>=;i--)
         if(fa[u][i]!=fa[v][i]) {u=fa[u][i]; v=fa[v][i];}
     return (u==v)?(u):(fa[u][]);
 }
 void ins(char *s)
 {
     int p,now=,x;
     tot=;
     ppt[++tot]=;
     for(int i=;s[i];i++)
     {
         p=s[i]-'a';
         now=trie[now].next[p];
         ppt[++tot]=now;
     }
     sort(ppt+,ppt+tot+,cmp);
     tot=unique(ppt+,ppt+tot+)-ppt-;
     for(int i=,nowtot=tot;i<=nowtot;i++)
     {
         if(sta.empty()) {sta.push(ppt[i]);vfa[ppt[i]]=-;continue;}
         p=lca(ppt[i],sta.top());
         while(!sta.empty() && dep[sta.top()]>dep[p])
         {
             x=sta.top();
             sta.pop();
             if((!sta.empty()&& dep[sta.top()]<=dep[p]) || sta.empty())
                 vfa[x]=p;
         }
         if(!sta.empty() && sta.top()!=p)
         {
             vfa[p]=sta.top();
             sta.push(p);
             ppt[++tot]=p;
         }
         else if(sta.empty())
         {
             vfa[p]=-;
             sta.push(p);
             ppt[++tot]=p;
         }
         vfa[ppt[i]]=p; sta.push(ppt[i]);
     }
     for(int i=;i<=tot;i++)
     {
         if(vfa[ppt[i]]==-) continue;
         add(fro[ppt[i]],);
         add(fro[vfa[ppt[i]]],-);
     }
     while(!sta.empty())
         sta.pop();
     return ;
 }
 int main()
 {
     int n,m,op,ques;
     init();
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     {
         scanf("%s",s);
         pt[i]=insert(s);
     }
     build();
     dfs(,,);
     scanf("%d",&m);
     for(int i=;i<=m;i++)
     {
         scanf("%d",&op);
         if(op==)
         {
             scanf("%s",s);
             ins(s);
         }
         else
         {
             scanf("%d",&ques);
             printf("%d\n",sum(fro[pt[ques]],bac[pt[ques]]));
         }
     }
     return ;
 }