字符串总结-三大“自动机”

复习笔记-字符串算法

AC自动机

本质

在字典树上进行KMP匹配

实现思路

正常建立Trie树

处理失配指针

在AC自动机中，失配指针fail和KMP的next是一样的作用，如下图(from SuperJvRuo)

 

 不难看出fail指针的构造方法：通过Bfs，设这个节点上的字母为c，沿着他父亲的fail走，直到走到一个节点，他的儿子中也有字母为c的节点，我们就找到了所求的fail。

匹配

类比KMP，我们可以先在树上走，如果失去匹配，就跳fail指针

优化

进行路径压缩，把Trie树变成图

代码实现

#include <bits/stdc++.h>

const int maxn = 1000010;
char ss[maxn];

struct node {
    node *ch[26];
    int exist;
    node *fail;
    node(): exist(0), fail(0) {
        memset(ch, 0, sizeof ch);
    }
};

node *root = new node;

void insert(char *s) {//字典树建立
    node *p = root;
    for (int i = 0; s[i]; ++i) {
        int x = s[i] - 'a';
        if (p -> ch[x] == NULL) p -> ch[x] = new node;
        p = p -> ch[x];
    }
    ++p -> exist;
}

void get_fail() {//处理失配指针
    node *p, *tmp;
    std::queue<node*> q;
    q.push(root);
    while (!q.empty()) {
        tmp = q.front();
        q.pop();
        for (int i = 0; i < 26; ++i) 
            if (tmp -> ch[i]) {
                if (tmp == root) {
                    tmp -> ch[i] -> fail = root;
                } else {
                    p = tmp -> fail;
                    while (p) {
                        if (p -> ch[i]) {
                            tmp -> ch[i] -> fail = p -> ch[i];
                            break;
                        }
                        p = p -> fail;
                    }
                    if (p == NULL) tmp -> ch[i] -> fail = root;
                }
                q.push(tmp -> ch[i]);
            }
    }
}

int AC(char *s) {//匹配
    int cnt = 0;
    int l = strlen(s);
    node *p = root;
    for (int i = 0; i < l; ++i) {
        int x = s[i] - 'a';
        while (!p -> ch[x] and p != root) p = p -> fail;
        p = p -> ch[x];
        if (!p) p = root;
        node *tmp = p;
        while (tmp != root) {
            if (tmp -> exist >= 0) cnt += tmp -> exist, tmp -> exist = -1;
            else break;
            tmp = tmp -> fail;
        }
    }
    return cnt;
}

int main() {
    int n;
    scanf("%d", &n);
    while (n--) {
        scanf("%s", ss);
        insert(ss);
    }
    get_fail();
    scanf("%s", ss);
    printf("%d", AC(ss));
    return 0;
}

　　

 回文自动机

不是很熟

本质

是两棵回文树。其中一个维护长度为奇数的字符串，另一个是长度为偶数的字符串

结构

• 回文自动机的每一条边代表一个字符。对于每一条边，它的起点字符串左右都加上这个字符就得到终点的字符串
• 回文自动机的每一个节点代表一个字符串，它的每一个子节点都是它在左右两端分别加上相同的字符得到的
• 回文自动机的每一个节点都有一个fail指针，它指向这个字符串最长满足回文的后缀的节点。如果没有，就指向根。

建树

直接在字符串两端进行扩展。每次要加入一个点的时候，先跳最后加入的一个节点的fail指针，直到满足节点字符等于新加入字符。然后加入新节点，把刚刚找到的那个节点的对应边连到新节点上， 更新节点维护的所有值

代码实现

#include<cstdio>

const int maxn=555555;

int cnt=1;
char s[maxn];
int son[maxn][26];
int len[maxn],fail[maxn];

int new_node(int length)
{
    len[++cnt]=length;
    return cnt;
}

int get_fail(char T[],int pre,int now)
{
    while(T[now-len[pre]-1]!=T[now])
        pre=fail[pre];
    return pre;
}

void build(char T[])
{
    int last=0;
    len[0]=0,len[1]=-1;
    fail[0]=1,fail[1]=1;
    for(int i=1;T[i];i++)
    {
        int cur=get_fail(T,last,i);
        if(!son[cur][T[i]-'a'])
        {
            int now=new_node(len[cur]+2);
            fail[now]=son[get_fail(T,fail[cur],i)][T[i]-'a'];
            son[cur][T[i]-'a']=now;
        }
        last=son[cur][T[i]-'a'];
    }
}

int main()
{
    scanf("%s",s+1);
    build(s);
    printf("%d\n",cnt-1);
    return 0;
}

 

后缀自动机

不是很熟+1

结构

一个DAG，满足从根出发走到所有结束点的所有路径都是字符串的一个后缀

构造过程

每次尽可能利用上一次的状态得到新的状态。我也说不明白，背的板子。。

用途

可以解决哈希解决不了的所有字符串问题。广义后缀自动机还可以解决其他很多问题。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>

typedef long long ll;
const int maxn=1111111;

struct node
{
    int son[26];
    int len,link;
}sam[maxn<<1];

int cnt=1,last=1;
int size[maxn<<1];

void insert(int ch)
{
    int cur=++cnt;
    sam[cur].len=sam[last].len+1;
    int p=last;
    while(p&&!sam[p].son[ch])
    {
        sam[p].son[ch]=cur;
        p=sam[p].link;
    }
    if(!p) sam[cur].link=1;
    else
    {
        int q=sam[p].son[ch];
        if(sam[p].len+1==sam[q].len) sam[cur].link=q;
        else
        {
            int clone=++cnt;
            sam[clone].len=sam[p].len+1;
            sam[clone].link=sam[q].link;
            memcpy(sam[clone].son,sam[q].son,sizeof(sam[q].son));
            while(p&&sam[p].son[ch]==q)
            {
                sam[p].son[ch]=clone;
                p=sam[p].link;
            }
            sam[q].link=sam[cur].link=clone;
        }
    }
    size[cur]=1;
    last=cur;
}

ll ans;
char s[maxn];
int tong[maxn];
int topo[maxn<<1];

int main()
{
    scanf("%s",s+1);
    int len=strlen(s+1);
    for(int i=1;i<=len;i++)
        insert(s[i]-'a');
    for(int i=1;i<=cnt;i++)
        tong[sam[i].len]++;
    for(int i=1;i<=len;i++)
        tong[i]+=tong[i-1];
    for(int i=cnt;i>=1;i--)
        topo[tong[sam[i].len]--]=i;
    for(int i=cnt;i>=1;i--)
    {
        int now=topo[i];
        size[sam[now].link]+=size[now];
        if(size[now]>1)
            ans=std::max(ans,1LL*size[now]*sam[now].len);
    }
    printf("%lld\n",ans);
    return 0;
}