字符串匹配（kmp+trie+aho-corasic automaton+fail tree）
kmp
对于一个字符串\(s_{0\dots n}\),称\(s_{0\dots i}(0 \leq i < n）\) 为它的前缀， 称\(s_{i\dots n}(0 < i \leq n)\)为它的后缀
例如字符串\(abcdef\)的前缀有\(a, ab, abc, abcde, abcdef\), 后缀有\(f, ef, def, cdef, bcdef\)
如果前缀后缀之中有相同的……在匹配中可以起到出其不意的效果。
例如对于模式串\(t=ababacb\), 文本串\(s=abababaababacb\)
设匹配进行到文本串的第\(i\)位，模式串的第\(j\)位，即模式串第\(j\)位之前已经匹配成功(开头是第1位开始算的话)
然后我们就发现程序很顺利进行到\(i = 5, j = 5\)并且匹配成功，这个时候\(i++, j++\), \(i = 6, j = 6\)
然后就发现\(t[6] = 'c' \neq s[6] = 'b'\)按照正常暴力思路就是回到\(i = 2, j = 1\)重新开始暴力
但是我们其实是可以发现已经成功匹配的模式子串\(t_{1\dots5} = "ababa"\)有相同的前缀后缀\(a, aba\),即\(t_1 = t_5, t_{1\dots3} = t_{3\dots5}\)，且\(t_{1\dots4} \neq t_{2\dots5}\)（这样的话前缀后缀应该有四位才对）
因为成功匹配，所以会有\(s_{1\dots5} = t_{1\dots5}\), 所以我们就可以知道\(s_{1\dots3} = t_{1\dots3} = t_{3\dots5} = s_{3\dots5}\), \(s_{3\dots5} = t_{1\dots3} \neq s_{2\dots4}\)
这就是说在模式串的前三位我们又快速匹配成功了，根据上一次失败的匹配的结果。这里我们就可得到现在\(i = 6, j = 3 + 1 = 4\)开始匹配
这里\(j=3+1\)的3是根据已经匹配的模式子串的最长前缀后缀长度为3得到的
那么怎么快速求最长前缀后缀呢
对于字符串\(t_{1\dots n}\)，注意这次从1开始（当然从0开始也没问题），我们要匹配，就要求出所有前缀 的最长前缀后缀长度。
也就是要求出所有的\(t_{1\dots i}(1\leq i\leq n)\)的最长前缀后缀的长度。
我们就设数组\(f[i]\)表示\(t_{1\dots i}\)的最长前缀后缀的长度，很容易得到\(f[0] = 0\)（明显犯规了嘛）， \(f[1] = 0\)（就一个字母哪来前缀后缀）
接下来就可以递推了
对于已经求得的\(f[i-1] = j\),他表示\(t_{1\dots j} = t_{i - j\dots i - 1}\), 那么如果\(t_{j+1} = t_i\),就会有\(t_{1\dots j+1} = t_{i-j\dots i}\)，这就是一个相同的前缀后缀且一定是最长的（因为\(f[i-1]\)表示的也是最长的）,\(f[i] = j + 1\)
但是如果\(t_{j+1} \neq t_i\)，是不是直接判\(f[i] = 0\)呢。
我们也可以考虑看一下\(t_{1\dots j}\)的最长相同前缀后缀。因为我们是一路推过来的，而且根据定义必定有前缀后缀的长度小于字符串的长度，即\(i > f[i]\), 那么我们就可以知道\(t_{1\dots j}\)的最长前缀后缀一定是已经求出来的，为\(f[j]\),他表示\(t_{1\dots f[j]} = t_{j - f[j] + 1\dots j}\),同时又因为\(t_{1\dots j} = t_{i - j\dots i - 1}\),所以我们可以得到\(t_{j - f[j] + 1\dots j} = t_{i - f[j]\dots i - 1} = t_{1\dots f[j]}\),
\(t_{1\dots f[j]} = t_{i-f[j]\dots i-1}\),也就是说长度为\(f[j]\)的子串\(t_{1\dots f[j]}\)也是模式子串\(t_{1\dots i - 1}\)的相同前缀后缀（只不过不是最长而已）
同理可得，\(j, f[j], f[f[j]], f[f[f[j]]]\dots\)均为\(t_{1\dots i-1}\)的相同前缀后缀的长度,我们就可以一一看看这样的长度的相同前缀后缀能不能多接一个。边界就是0的时候，空串是不会有前缀后缀的了……
写成代码就是这样
for (int i=2;i<=lb;i++)
{
int j = kmp[i-1];
while(j&&b[i]!=b[j+1]) j=kmp[j];
if(b[j+1]==b[i])kmp[i]=j+1;
else kmp[i]=0;
}
trie
类似于字典的构造，建立一棵树，每个节点表示一个字母，层深度表示串的长度，把有相同前缀的串放在同一个子树内。可以快速完成多个文本串中匹配一个模式串的任务。
比如这棵trie，打了红色标记就表示有一个串到尾了。所以这棵trie存储了文本串\(abc, abd, abcd, b, bcd, efg, hi?\)
对于有相同前缀\(ab\)的串\(abc, abd, abcd\)，都放在了字数\(ab\)内，那么如果我们找的模式串前缀也是\(ab\)，那么只需要在\(ab\)子树内寻找就可以了。
aho-corasic automaton
trie上kmp，一个文本串中匹配多个模式串
众所周知kmp是因为有回溯指针才能快速匹配，那么我们把多个模式串建立一个trie，然后用文本串一一匹配，如果找到标记了结束的红点就说明找到了一个模式串。
那么其实我们也可以建立一个回溯指针的。如果匹配失败就看看回溯指针那边能否匹配成功。
在AC自动机里面也叫做失配指针。
这里就是搞定之后的失配指针
对于建立了的字典树，第一层（也就是第一个字母）的失配指针全部指向根节点（就一个字母你指什么指了也是自己还是失配）并且扔入队列（对就用BFS）
然后每次就从队头取出元素，我们可以叫它\(j\)， 如果\(j\)的\(nxt[i]\)存在，那么我们就可以去寻找这个\(nxt[i]\)的失配指针。这里先说如果不存在，那么可以加一个小优化，把\(nxt[i]\)指向\(j\)的失配指针的\(nxt[i]\), 这样就可以直接连到可能匹配到的模式串。但是这样会破坏字典树的结构，在某些题目用了会WA……
这里失配指针也模仿kmp的\(f\)的求法，如果\(j\)的失配指针有\(nxt[i]\)，那么\(j\)的\(nxt[i]\)的失配指针就指向\(j \rightarrow fail \rightarrow nxt[i]\) 如果还是没有就看看\(j \rightarrow fail \rightarrow fail\)有没有……因为失配指针指向的不是根节点就是同一个字母，保证指向的节点所表示的串会等于当前节点的某个后缀。
匹配的时候，就用文本串从根节点开始匹配，匹配成功文本串指针后移，并且看看下一个字母能不能匹配。如果不能，那就跳去失败指针…………如果最后到了根节点还是没有这个字母，那么……没办法，文本串指针还是要后移一位。
每匹配到一位，我们就检查所有的失配指针指向的节点，\(j \rightarrow fail, j \rightarrow fail \rightarrow fail \dots\)，如果有标志是某个模式串的末尾，那么就说明， 啊，我匹配到了！
但是与此同时也要把这个标志取消，以免以后重复访问到，重复计算。这样也可以标记访问过，下次不再访问，节省时间。
代码如下：（题目）
#include <cstdio>
#include <cstring>
#include <queue>
namespace Aho_Corasic_automaton
{
class A_C_maton
{
private:
public:
A_C_maton();
~A_C_maton();
int query(const char*);
void set_fail();
const A_C_maton* operator [](const int k) const
{ if(k < 0 or k >= 26) return nxt[26]; return nxt[k]; }
void add(const char*);
protected:
A_C_maton *fail, *nxt[27];
int ed;
};
A_C_maton::A_C_maton()
{
fail = NULL; ed = 0;
for(register int i = 0; i < 27; ++i) nxt[i] = NULL;
}
A_C_maton::~A_C_maton()
{
for(register int i = 0; i < 27; ++i) if(nxt[i]) delete nxt[i];
delete fail;
}
void A_C_maton::add(const char* str)
{
const register int len = std::strlen(str);
A_C_maton* p = this;
for(register int i = 0; i < len; ++i)
{
if(p -> nxt[str[i] - 'a'] == NULL) p -> nxt[str[i] - 'a'] = new A_C_maton;
p = p -> nxt[str[i] - 'a'];
}
++(p -> ed);
}
void A_C_maton::set_fail()
{
this -> fail = this;
std::queue <A_C_maton*> q;
for(register int i = 0; i < 27; ++i)
{
if(this -> nxt[i])
{
this -> nxt[i] -> fail = this;
q.push(this -> nxt[i]);
}else this -> nxt[i] = this;
}
while(not q.empty())
{
A_C_maton* p = q.front(); q.pop();
for(register int i = 0; i < 26; ++i)
{
if(p -> nxt[i])
{
q.push(p -> nxt[i]);
if(p -> fail -> nxt[i]) p -> nxt[i] -> fail = p -> fail -> nxt[i];
}else p -> nxt[i] = p -> fail -> nxt[i];
}
}
}
int A_C_maton::query(const char* str)
{
int ans = 0;
set_fail();
A_C_maton* p = this;
const register int len = std::strlen(str);
for(register int i = 0; i < len; ++i)
{
p = p -> nxt[str[i] - 'a'];
for(register A_C_maton* r = p; r and r -> ed != -1; r = r -> fail)
{
ans += r -> ed;
r -> ed = -1;
}
}
return ans;
}
}
using namespace Aho_Corasic_automaton;
A_C_maton* root = new A_C_maton;
int n;
char str[1000001];
int main()
{
scanf("%d", &n);
while(n--)
{
scanf("%s", str);
root -> add(str);
}
scanf("%s", str);
printf("%d\n", root -> query(str));
return 0;
}
fail tree
Aho-Corasic automaton求的是出现的模式串的个数
如果要求模式串出现的次数呢？
那么其实时间复杂度就有点高了。而且对于\(aaaaaaaaaaaaaaaaaaa\)这样的模式串，不断跳失配指针，是很慢的。
那么怎么办呢。
我们回忆一下Aho-Corasic automaton的工作过程。
首先在Trie树里跳文本串，每跳到一个节点就沿着失配指针遍历下去。如果遍历到某个模式串的末尾，那么就说明这个模式串在文本串中出现了一次，可以打上一个标记。那么正常的Aho-Corasic automaton 就是跳完文本串之后，统计每个模式串的结尾的标记个数，就是这个模式串在文本串中出现的次数。
但是这样即使我们提前存储下每个模式串结尾在Trie中的位置，还是会很慢，因为我们不仅要跳很多个失配指针，而且还可能多次跳过一个节点（因为模式串的出现次数肯定很多orz）
我们就可以考虑一下怎么优化。
我们可以发现，一个节点被打上标记，当且仅当它被文本串直接访问或者通过跳失配指针访问。
所以对于每个被标记的节点，我们都可以沿着网线失配指针爬回去，一定可以访问到某个被文本串直接访问过的节点。
那么如果我们根据失配指针反向建有向图，一个模式串的结尾能走到多少个标记，说明有多少次文本串可以直接访问、或通过失配指针访问到这个模式串。
也就是说，我们只要让文本串直接访问到的节点打上标记，跳完之后就统计每个模式串的结尾节点，通过失配指针反向建的有向边来询问节点，统计标记的个数，就是这个模式串出现的次数。这样每个失配指针只跳了一次，文本串也只跳了一次Trie，复杂度大大降低
但是这里要注意建fail的时候不能用优化。这个优化其实就是改变了Trie的结构，同样也会改变失配指针，使其不满足一棵树的结构，就不能正常计算。
这里就告诉你，为什么根据失配指针反向建图是树的结构。
每个节点只有一个失配指针，所以出度是1。反向建图，每个节点的入度是1，也就是只有一个父亲。
那不就是树吗！
而且由于我们通过失配指针最后访问到的都是根，所以反向建图出来的树的根节点就是原来Trie的根。
所以对于每个模式串的末尾，其实就是统计以这个末尾节点为根的子树里面有多少个标记。
然后我们再想想标记是怎么来的。每次文本串遍历到节点才加上一个标记。
那么我们可以假设所有节点的初值都是0，然后每次文本串访问到一个节点就加上1（单点修改），最后就是查找这个子树里面所有节点的和（区间查询）。
单点修改+区间查询 = 树状数组
但是这是一棵树，怎么换成一段数组呢？
我们可以用前缀表达式，对于\(u\)为根的子树, 大小为\(sz\), 用前缀表达式dfs出dfs序dfn，那么就可以保证\(dfn_u\)到\(dfn_{u + sz - 1}\)全部都是这棵子树的上节点的下标，并且这棵子树上节点全部都在这个序列里。
所以我们通过\(dfn\)来统计子树上标记的个数
看有注释的代码：（题目）
这道题，所谓的文章就是所有单词组合在一起，但是每个单词之间要插入一个分隔符。文本串跳到了分隔符就要跳回根节点重新跳。
#include<bits/stdc++.h>
using namespace std;
template <typename T>
struct Edge
{
Edge *nxt;
T* t;
}; /// 反向建图用链式前向星
struct Trie
{
Trie* nxt[27], *fail;
Edge <Trie> *edge;
int dfn, sz;
Trie* operator [] (int k) const
{
if(k < 0 or k > 26) return nxt[0];
return nxt[k];
}
Trie()
{
for(register int i = 0; i < 27; ++ i) nxt[i] = NULL;
fail = NULL; edge = NULL;
dfn = 0; sz = 1;
}
}*root;
Trie* add(Trie* p, char * str)
{
/// 把str加入到Trie中
for(register int i = 0; str[i]; ++i)
{
if(p -> nxt[str[i] - 'a' + 1] == NULL) p -> nxt[str[i] - 'a' + 1] = new Trie;
p = (*p)[str[i] - 'a' + 1];
}
return p;
}
int n;
char t[1000201];
Trie* ed[210];
void set_fail(Trie* p)
{
/// 建立失配指针
p -> fail = p;
std::queue <Trie*> q;
for(register int i = 0; i < 27; ++i)
{
if(p -> nxt[i])
{
p -> nxt[i] -> fail = p;
q.push(p -> nxt[i]);
}else p -> nxt[i] = p;
// 第一层字母如果就失配就要跳回根节点
}
while(not q.empty())
{
register Trie* j = q.front(); q.pop();
for(register int i = 0; i < 27; ++i)
{
if(j -> nxt[i])
{
q.push(j -> nxt[i]);
Trie* k = j -> fail;
while(k and k != p and k -> fail and k -> nxt[i] == NULL) k = k -> fail;
j -> nxt[i] -> fail = k -> nxt[i];
}/// else p -> nxt[i] = p -> fail -> nxt[i];
/// 这个优化不能要。如果没有这个节点就没有，优化了就破坏了结构，会影响下面建图
}
}
}
void addE(Trie* a, Trie* b)
{
/// 反向建图，加边
Edge<Trie> *e = new Edge<Trie>();
e -> nxt = a -> edge;
e -> t = b;
a -> edge = e;
return ;
}
void set_up(Trie *p)
{
/// 反向建图
queue <Trie*> q;
q.push(p);
/// 通过广搜来遍历每一个节点，通过失配指针反向建图
while(not q.empty())
{
Trie *j = q.front(); q.pop();
for(register int i = 1; i < 27; ++i)
{
if(j -> nxt[i] and j -> nxt[i] != p)
{
// 有这个子节点而且这个节点不是根节点
// 如果根节点进入到队列，那么就会永远在队列中……就MLE了
q.push(j -> nxt[i]);
addE(j -> nxt[i] -> fail, j -> nxt[i]);
}
}
}
}
int dfn;
void dfs(Trie *p)
{
/// 先序遍历求dfs序
p -> dfn = ++dfn;
for(register Edge<Trie>* i = p -> edge; i; i = i -> nxt)
{
dfs(i -> t);
// 对于每一条边都深搜下去
p -> sz += i -> t -> sz;
// 并且维护父节点的大小
}
}
int lowbit(int);
void change(int, int);
int query(int);
int sum[1000201];
// 树状数组求和
void solve(Trie* p, char *str, int len)
{
for(register int i = 0; i < len; ++i)
{
// 标记文本串直接跳到的节点
register const int x = str[i] - 'a' + 1;
while(not p -> nxt[x] and p -> fail != p) p = p -> fail;
p = p -> nxt[x];
change(p -> dfn, 1);
}
}
int len;
int main()
{
root = new Trie;
cin >> n;
for(register int i = 1; i <= n; ++ i)
{
cin >> (t + len);
ed[i] = add(root, t + len);
len += strlen(t + len);
t[len++] = 'a' - 1;
// 储存文章
}
set_fail(root);
set_up(root);
dfs(root);
solve(root, t, len);
for(register int i = 1; i <= n; ++i)
{
int ans = query(ed[i] -> dfn + ed[i] -> sz - 1) - query(ed[i] -> dfn - 1);
cout << ans << endl;
}
return 0;
}
int lowbit(int x)
{
return x & (-x);
}
void change(int n, int x)
{
for(int i = n; i <= dfn; i += lowbit(i)) sum[i] += x;
}
int query(int n)
{
int res = 0;
while(n)
{
res += sum[n];
n -= lowbit(n);
}
return res;
}
