Fail树--学习笔记

先看下面这个问题

给定一个文本串S和n个模式串$T_{1...n}$，请你分别求出每个模式串$T_i$在S中出现的次数。

$n\le 2\ast 10^5$,$T_{1...n}$总长度和不超过$2\ast 10^5$,S长度不超过$2\ast 10^6$

---

从AC自动机到Fail树

这个问题似乎和我们学AC自动机时的例题很像？
好像都是统计模式串在文本串中出现的次数
但是当我们飞快地码完AC自动机代码并提交却愉快地TLE了???

回忆AC自动机的匹配过程：
将文本串送入AC自动机，每到达一个结点$u$，就从$u$开始不断跳$fail$直到根
期间跳到的结点代表的串都在文本串中出现

既然可以从文本串的每位开始向上跳$fail$找模式串结尾结点
那为什么不能从模式串结尾结点开始逆着$fail$找文本串节点呢
即从某个模式串结尾结点开始不断逆着跳$fail$，期间跳到的文本串的结点个数就是这个模式串在文本串中出现的次数

依据这个思想
在$Trie$树上构造好$fail$指针后，只留下反向的$fail$指针作为边，就得到了$Fail$树
(因为原本每个节点只有一个$fail$指针，所以构造出的一定是树的结构)

只要将$Fail$树上每个属于文本串的结点权值置为1
那么结点$u$的子树总权值就是$u$代表的串在文本串中出现的次数

而求子树权值和只需要一次$O(n)$的dfs即可
这样复杂度就大大下降，这就是Fail树解题的常见套路

洛谷P5357上述问题的板题
虽然题目标题是AC自动机但其实是Fail树板题

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long lt;

int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const int maxn=200010;
int n;
char txt[maxn*10],pt[maxn];
int ch[maxn][26],fail[maxn];
int rem[maxn],num[maxn],cnt;
struct node{int v,nxt;}E[maxn<<1];
int head[maxn],tot;
int val[maxn],sum[maxn];

void addE(int u,int v)
{
	E[++tot].nxt=head[u];
	E[tot].v=v;
	head[u]=tot;
}

int ins(char *ss)
{
	int u=0,len=strlen(ss);
	for(int i=0;i<len;++i)
	{
		int x=ss[i]-'a';
		if(!ch[u][x]) ch[u][x]=++cnt;
		u=ch[u][x];
	}
	return u;
}

void getFail()
{
    queue<int> q;
    for(int i=0;i<26;++i)
    if(ch[0][i]) fail[ch[0][i]]=0,q.push(ch[0][i]);
     
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=0;i<=25;++i)
        {
            if(!ch[u][i]) continue;
            int tt=fail[u];
            while(!ch[tt][i]&&tt) tt=fail[tt];
            fail[ch[u][i]]=ch[tt][i];
            q.push(ch[u][i]);
        }
    }
    
    for(int i=1;i<=cnt;++i)//构造Fail树
    addE(fail[i],i);
}

void solve(char *ss)
{
	int u=0,len=strlen(ss);
	for(int i=0;i<len;++i)
	{
		int x=ss[i]-'a';
		while(!ch[u][x]&&u) u=fail[u];
		u=ch[u][x];
		
		val[u]++;
	}
}

void dfs(int u)
{
	sum[u]=val[u];
	for(int i=head[u];i;i=E[i].nxt)
	{
		int v=E[i].v;
		dfs(v);
		sum[u]+=sum[v];
	}
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		scanf("%s",&pt);
		rem[i]=ins(pt);
	}
	
	getFail(); 
	
	scanf("%s",&txt);
	solve(txt);//将属于文本串的节点都权值都置为1
	
	dfs(0); // dfs统计子树权值和 
	for(int i=1;i<=n;++i)
	printf("%d\n",sum[rem[i]]);
	
	return 0;
}

---

再看一道稍微难点的

洛谷P2414 [NOI2011]阿狸的打字机

Description

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和’B’、'P’两个字母。
经阿狸研究发现，这个打字机是这样工作的：
l 输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。
l 按一下印有’B’的按键，打字机凹槽中最后一个字母会消失。
l 按一下印有’P’的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。

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

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

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

HINT

1<=N<=10^5
1<=M<=10^5
输入总长<=10^5

---

该题文本串会变化，也就是fail树的子树权值和是动态变化的
所以需要dfs序+树状数组维护子树权值和

用所有串构造好构造出Fail树并求DFS序后
对于一个$(x,y)$这样的询问，只要在Fail树上将所有属于串$y$的结点权值赋为1，查询串$x$末尾结点子树权值和即可

由于多组询问，每次将一个串重新赋值明显会T
我们可以把所有串$y$相同的询问放在一起处理，具体可以用链式结构将这些相同询问串起来

然后重新走一次Trie树的构造过程
每走到一个结点就将这个节点权值+1，遇到’B’就令当前节点权值-1并返回上一个节点
每次遇到’P’时就可以查看是否有串$y$为当前字符串的询问，有就一起处理
这样做就保证了遇到’P’时只有当前字符串全部赋了值，并且遍历完只用$O(n)$

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long lt;
#define lowbit(x) ((x)&(-x))
 
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return x*f;
}
 
const int maxn=1000010;
int n,m;
int rem[maxn],fa[maxn],cnt;
int ch[maxn][26],fail[maxn];
char txt[maxn];
struct edge{int v,nxt;}E[maxn];
int head[maxn],tot;
int dfn[maxn],size[maxn],sz;
struct node{int x,y,ans,nxt;}Q[maxn];
int hq[maxn],sum[maxn];
 
void add(int x,int v){ for(int i=x;i<=sz;i+=lowbit(i))sum[i]+=v;}
int qsum(int x){ int res=0; for(int i=x;i>0;i-=lowbit(i))res+=sum[i]; return res;}
 
void addE(int u,int v)
{
    E[++tot].nxt=head[u];
    E[tot].v=v;
    head[u]=tot;
}
 
void ins(char* ss,int len)
{
    int u=0;
    for(int i=0;i<len;++i)
    {
        if(ss[i]=='P') rem[++n]=u;
        else if(ss[i]=='B') u=fa[u];
        else{
            int x=ss[i]-'a';
            if(!ch[u][x]) ch[u][x]=++cnt,fa[cnt]=u;
            u=ch[u][x];
        }
    }
}
 
void getf()
{
    queue<int> q;
    for(int i=0;i<26;++i)
    if(ch[0][i]) fail[ch[0][i]]=0,q.push(ch[0][i]);
     
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=0;i<=25;++i)
        {
            if(!ch[u][i]) continue;
            int tt=fail[u];
            while(!ch[tt][i]&&tt) tt=fail[tt];
            fail[ch[u][i]]=ch[tt][i];
            q.push(ch[u][i]);
        }
    }
}
 
void dfs(int u)
{
    dfn[u]=++sz; size[u]=1;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        dfs(v);
        size[u]+=size[v];
    }
}
 
void solve(char* ss,int len)
{
    int u=0,p=0;//重新走一次Trie的构造
    for(int i=0;i<len;++i)
    {
        if(ss[i]=='B') add(dfn[u],-1),u=fa[u];//遇到'B'令当前节点权值-1，并返回上一个节点
        else if(ss[i]=='P')
        {
            p++;//构造出第p个字符串，处理所有y为第p个字符串的询问
            for(int k=hq[p];k;k=Q[k].nxt)
            {
                int v=rem[Q[k].x];
                Q[k].ans+=qsum(dfn[v]+size[v]-1)-qsum(dfn[v]-1);//查询x末尾节点的子树权值和
            }
        }
        else//走到新的节点令其权值+1
        {
            u=ch[u][ss[i]-'a'];
            add(dfn[u],1);
        }
    }
}
 
int main()
{
    scanf("%s",&txt); m=read();
    ins(txt,strlen(txt));
     
    getf();
    for(int i=1;i<=cnt;++i)
    addE(fail[i],i);
     
    dfs(0);
    for(int i=1;i<=m;++i)
    {
        int x=read(),y=read();
        Q[i].nxt=hq[y];//这里用链式结构把y相同的询问串起来
        Q[i].x=x; Q[i].y=y;
        hq[y]=i; 
    }
     
    solve(txt,strlen(txt));
    for(int i=1;i<=m;++i)
    printf("%d\n",Q[i].ans);
    return 0;
}


---

Fail树的其他巧妙用法

有时根据题目的特殊性也可以不使用树状数组维护

洛谷P3966 [TJOI2013]单词

Description

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

Input

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

Output

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

---

依旧是Fail树十分常规的套路题
思路就是把所有文本串结点权值赋值为1，求每个模式串末尾结点子树权值和

但是此题中发现文本串就是所有模式串接在一起，所以甚至没必要建出Fail树
构造Trie树时令每个经过的节点权值+1
构造fail指针时记录下BFS序
直接按反向BFS序即可$O(n)$统计出每个结点子树权值和，最后根据模式串节点回答即可

虽然没有直接建出Fail树，但其实依旧是利用了它的思想

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
 
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return x*f;
}
 
const int maxn=1000010;
int n;
int rem[maxn],sum[maxn],cnt;
int ch[maxn][30],fail[maxn];
int q[maxn],head,tail;
char pt[maxn];
 
void ins(char* ss,int len,int k)
{
    int u=0;
    for(int i=0;i<len;++i)
    {
        int x=ss[i]-'a';
        if(!ch[u][x]) ch[u][x]=++cnt;
        u=ch[u][x];
        sum[u]++;
    }
    rem[k]=u;
}
 
void getf()
{
    head=tail=0;
    for(int i=0;i<26;++i)
    if(ch[0][i]) fail[ch[0][i]]=0,q[++tail]=ch[0][i];
     
    while(head<tail)
    {
        int u=q[++head];
        for(int i=0;i<=25;++i)
        {
            if(!ch[u][i]) continue;
            int tt=fail[u];
            while(!ch[tt][i]&&tt) tt=fail[tt];
            fail[ch[u][i]]=ch[tt][i];
            q[++tail]=ch[u][i];
        }
    }
}
 
int main()
{
    n=read();
    for(int i=1;i<=n;++i)
    {
        scanf("%s",&pt);
        ins(pt,strlen(pt),i);
    }
     
    getf();
    for(int i=tail;i;--i)//反向bfs序统计每个子树权值和
    sum[fail[q[i]]]+=sum[q[i]];
     
    for(int i=1;i<=n;++i)
    printf("%d\n",sum[rem[i]]);
    return 0;
}