Fail树--学习笔记

先看下面这个问题

BZOJ2434 [Noi2011]阿狸的打字机

Time Limit: 10 Sec Memory Limit: 256 MB

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

---

从AC自动机到Fail树

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

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

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

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

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

而求子树权值和很容易想到DFS序+树状数组
这样复杂度就大大下降，这就是Fail树解题的常见套路

---

应用Fail树

回到上述问题并套用上述思想

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

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

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

#include
#include
#include
#include
#include
#include
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<26;++i)
        {
            if(!ch[u][i]) ch[u][i]=ch[fail[u]][i];
            else fail[ch[u][i]]=ch[fail[u]][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)//构造Fail树
    addE(fail[i],i);
     
    dfs(0);//求dfs序
    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树的其他巧妙用法

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

BZOJ3172 [Tjoi2013]单词

Time Limit: 10 Sec Memory Limit: 512 MB

Description

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

Input

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

Output

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

---

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

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

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

#include
#include
#include
#include
#include
#include
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<26;++i)
        {
            if(!ch[u][i]) ch[u][i]=ch[fail[u]][i];
            else fail[ch[u][i]]=ch[fail[u]][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;
}

---

CodeForces - 163E

Time limit 1000 ms Memory limit 262144 kB

The best programmers of Embezzland compete to develop a part of the project called “e-Government” — the system of automated statistic collecting and press analysis.

We know that any of the k citizens can become a member of the Embezzland government. The citizens’ surnames are a1, a2, …, ak. All surnames are different. Initially all k citizens from this list are members of the government. The system should support the following options:

Include citizen ai to the government.
Exclude citizen ai from the government.
Given a newspaper article text, calculate how politicized it is. To do this, for every active government member the system counts the number of times his surname occurs in the text as a substring. All occurrences are taken into consideration, including the intersecting ones. The degree of politicization of a text is defined as the sum of these values for all active government members.
Implement this system.

题目大意

给定k个模式串，n次操作
每次操作可能是删除/增加第 i 个模式串(可能重复)，或询问每个模式串在给定的文本串中出现次数的总和

---

此题和前面两题不同之处在于文本串没有出现在构造好的Trie树中
于是此题需要结合AC自动机和Fail树各自的长处

一开始k个模式串构造好Trie，并构造fail指针以及Fail树并求DFS序
对于没有被删除的模式串
利用差分数组，每个模式串结尾结点权值+1，其子树中最后一个dfs序编号结点权值-1

每次询问将文本串送入AC自动机逐位匹配
若当前走到AC自动机结点$u$，令$ans+=qsum(1,dfn[u])$
这样即统计了该结点延fail指针走到根路径上 模式串结尾结点的个数（其他子树内的结点会因为差分数组抵消掉）

这样虽然不能准确统计每个模式串各自出现的次数
但将AC自动机和Fail树各自的特点巧妙地结合起来直接达到了统计总数的目的

#include
#include
#include
#include
#include
#include
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,k,num;
int rem[maxn],cnt;
int ch[maxn][26],fail[maxn];
queue<int> q;
char pt[maxn];
struct edge{int v,nxt;}E[maxn];
int head[maxn],tot;
int dfn[maxn],size[maxn],judge[maxn],sz;
lt sum[maxn];

int get(char* ss)
{
	int x=0,len=strlen(ss);
    for(int i=0;i<len;++i) x=x*10+ss[i]-'0';
    return x;
}

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

lt qsum(int x){ lt res=0; for(int i=x;i>0;i-=lowbit(i))res+=sum[i]; return res;}
void add(int x,int v){ for(int i=x;i<=sz;i+=lowbit(i))sum[i]+=v;}
void update(int ll,int rr,int v){ add(ll,v); add(rr+1,-v);}

void ins(char* ss,int len,int d)
{
	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];
	}
	rem[d]=u;
}

void getf()
{
    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<26;++i)
        {
            if(!ch[u][i]) ch[u][i]=ch[fail[u]][i];
            else{
                fail[ch[u][i]]=ch[fail[u]][i];
                q.push(ch[u][i]);
            }
        }
    }
    
    for(int i=1;i<=cnt;++i)
    addE(fail[i],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];
	}
}

lt query(char*ss)
{
	lt ans=0;
	int u=0,len=strlen(ss);
	for(int i=0;i<len;++i)
	{
		u=ch[u][ss[i]-'a'];
		ans+=qsum(dfn[u]);
	}
	return ans;
}

int main()
{
	n=read();k=read();
	for(int i=1;i<=k;++i)
	{
		scanf("%s",&pt);
		ins(pt,strlen(pt),i);
	}
	
	getf(); dfs(0);
	for(int i=1;i<=k;++i)
	{
		update(dfn[rem[i]],dfn[rem[i]]+size[rem[i]]-1,1);
		judge[i]=1;
	}
	
	for(int i=1;i<=n;++i)
	{
		scanf("%s",&pt);
		if(pt[0]=='+')
		{
			int x=get(pt+1);
			if(judge[x]) continue;
			update(dfn[rem[x]],dfn[rem[x]]+size[rem[x]]-1,1);
			judge[x]=1;
		}
		else if(pt[0]=='-')
		{
			int x=get(pt+1);
			if(!judge[x]) continue;
			update(dfn[rem[x]],dfn[rem[x]]+size[rem[x]]-1,-1);
			judge[x]=0;
		}
		else if(pt[0]=='?')
		printf("%lld\n",query(pt+1)); 
	}
	
	return 0;
}