SPOJ LCS 最长公共子串 后缀自动机&后缀树(Ukkonen)

　　终于搞清楚了这两个恶心的算法。其实后缀树也不难写嘛。

题目

　　给定两个字符串a和b，求在a和b中都有出现的连续子串的最长长度。

样例输入

alsdfkjfjkdsal
fdjskalajfkdsla

样例输出

3

做法1

　　使用后缀自动机。clj的课件讲得很详细了，这里不细说。主要说几件事：

1. 后缀自动机的状态的本质是right集合（见课件），parent意味着right集合的最小扩充。时刻记着这一点可以使很多性质的证明变得很直观。
2. 有一个没什么用但挺有意思的性质是，字符串s的后缀自动机的每个状态和a的反串的后缀树的状态是一一对应的。原因其实很简单，后缀自动机的每个状态代表一系列子串，这些子串在s中出现的结束位置（right集合）是一样的。后缀树同样如此，每个节点连同它指向父亲的边一起代表一系列子串，而边上的串能够被压缩成一条边正是因为中间不会分叉，即出现某个前缀的地方也一定会出现另一个前缀，即它们在s中出现的起始位置（可以叫left集合）是一样的。后缀自动机和后缀树的节点的本质都可以认为是“同生共死的子串”。

3. 有关后缀自动机的线性性质。首先点和非空边的个数都是O(n)的，证明详见clj课件。其次构建自动机的效率也是O(n)的：考虑追加一个字符c需要的两个循环，第一个循环使得一些没有c儿子的点有了c儿子，第二个循环使得一些有c儿子的点更新了c儿子。首先第一个循环的总次数显然不超过边数。第二个循环的次数其实也不超过边数，因为每个点的每个儿子最多被更新一次，这是因为每次被更新的点都是之前所有有c儿子的点之中right集合最小的点，而只有当这个right集合可以更小时才会进行这种更新。有点绕，但如果能脑补出一个过程动画的话，其实挺直观的。

   　　现在看这道题。如果能对每个j都能求出最大的len使得b[j-len+1..j]在a中出现，那么所有的len的最大值就是答案。
   　　首先建立字符串a的后缀自动机，之后向其中依次输入b的每个字符。若能够输入，则++len；否则意味着当前状态代表的一系列子串后面都没有所需字符，此时需要不断尝试缩短len来扩充子串集合，直到新加入的子串后面有了所需字符为止。注意自动机的每个状态代表的是a的子串，这个串可能很长，长到超出已匹配的长度，超出的这部分和b没有关系，只有重叠的那部分（较小的那个长度）才可以用来更新答案。

// vim: set noet ts=4 sw=4 fileencoding=utf-8:
#include <cstdio>
#include <cstring>
#include <algorithm>
using std::max;
using std::min;
using std::copy;
using std::fill;

const int MAX_N = 250009;

struct Node {
    static Node buf[], *bufp;
    void *operator new(size_t) {return bufp++;}

    int lim;
    Node *ch[26], *f;
    Node() = default;
    Node(int lim_): lim(lim_) {
        fill(ch, ch+26, nullptr);
    }
} Node::buf[MAX_N*4], *Node::bufp=buf, *root, *last;

void append(char c) {
    int x = c-'a';
    Node *now=new Node(last->lim+1), *p;
    for (p=last; p && !p->ch[x]; p=p->f)
        p->ch[x] = now;
    if (!p) {
        now->f = root;
    } else {
        Node *q = p->ch[x];
        if (q->lim == p->lim+1) {
            now->f = q;
        } else {
            Node *r = new Node(p->lim+1);
            copy(q->ch, q->ch+26, r->ch);
            r->f = q->f;
            q->f = now->f = r;
            for (; p && p->ch[x]==q; p=p->f)
                p->ch[x] = r;
        }
    }
    last = now;
}

char a[MAX_N], b[MAX_N];

int main() {
    scanf("%s%s", &a, &b);
    last = root = new Node(0);
    for (char *p=a; *p; ++p)
        append(*p);

    Node *now = root;
    int ans = 0, pref = 0;
    for (char *p=b; *p; ++p) {
        int x = *p-'a';
        for (; now && !now->ch[x]; now=now->f)
            ;
        if (!now) {
            now = root;
            pref = 0;
            continue;
        }
        pref = min(pref, now->lim)+1;
        ans = max(ans, pref);
        now = now->ch[x];
    }
    printf("%d\n", ans);
}

做法2

　　就是后缀树啦。建立字符串a…a@b…b#的后缀树。每个节点到根的路径代表一个子串。一个节点代表的子串同时在a和b中出现，当且仅当此节点的子树的所有叶子里既有开始于@之前也有开始于@之后的。

　　后缀树构建的算法也不细说了，直接去看Ukkonen的原文就好。其实算法的原理很简单，首先后缀树就是压缩过的Trie，而在Trie上所有问题都是显然的。在Trie上追加一个字符的步骤是追着后缀链接跑，在后缀树上同样如此，只不过因为我们只关心分叉而省掉了对叶子和不许要分叉的点的处理。这里只说几个困扰过我的地方：
1. 对于后缀树的所有叶子，我们不关心也不记录它们的后缀链接。叶子永远是在随着字符串往后生长的。我们只关心分叉的点和进行分叉的过程。
2. 一般来说，在一颗合法的后缀树上，分叉节点x的后缀链接指向的节点y也是分叉节点，这是因为所有x出现的地方，y都有出现。不过，在追加字符串的过程中，后缀树可能会临时变得不完整、不合法。考虑字符串aaaaa@。在添加@之前，后缀树只有一条边，而在添加@时，我们需要知道分叉节点aaaa的后缀链接，而此时aaa还没有分叉，由此衍生出一堆特殊情况。Ukkonen对此的处理方式是新建一个点作为根的后缀链接点，同时将它的所有儿子都赋成根节点。这是一个十分巧妙的处理，至少它可以利用root的后缀链接神奇地处理aaaaa@这种情况。Ukkonen的论文还给出了这种处理的数学意义（单字符的逆），但我觉得这种解释不如对上述例子的处理有说服力。

　　最后说一句，只要用心构造代码，后缀树真的不难写。核心代码和后缀自动机一样也就20多行。

// vim: set noet ts=4 sw=4 fileencoding=utf-8:
#include <cstdio>
#include <climits>
#include <cstring>
#include <algorithm>
using std::fill;
using std::max;

const int MAX_N = 250009;

struct Node {
    static Node buf[], *bufp;
    void *operator new(size_t) {return bufp++;}
    Node *link, *ch[28];
    int l, r, len;
    Node() = default;
    Node(int _l, int _r, int _len): l(_l), r(_r), len(_len), link(nullptr) {
        fill(ch, ch+28, nullptr);
    }
} Node::buf[MAX_N*4], *Node::bufp=buf, *root, *neg, *par;

char a[MAX_N*4];
inline int idx(int i) {return a[i]-'a';}
int span = 0;

void insert(int pos, char c) {
    Node *now, *last=nullptr, *next;
    int x = c-'a';
    for (;;par=par->link) {
        while ((now=par->ch[idx(pos-span)])
                && span>=now->r-now->l) {
            span -= now->r-now->l;
            par = now;
        }
        if (par==neg || (now && a[now->l+span]==c)) {
            if (last) last->link = par;
            ++span;
            return;
        }
        if (span>0) {
            next = new Node(now->l, now->l+span, par->len+span);
            now->l += span;
            next->ch[idx(now->l)] = now;
            par->ch[idx(next->l)] = next;
        } else next = par;
        next->ch[x] = new Node(pos, INT_MAX, 0);
        if (last) last->link = next;
        last = next;
    }
}

int main() {
    scanf("%s", &a);
    int len1=strlen(a), len2=len1;
    a[len1] = 'z'+1;
    scanf("%s", &a[++len2]);
    len2 += strlen(&a[len2]);
    a[len2++] = 'z'+2;
    a[len2] = '\0';

    par = root = new Node(-1, 0, 0);
    neg = root->link = new Node();
    fill(neg->ch, neg->ch+28, root);
    for (int i=0; i<len2; ++i)
        insert(i, a[i]);

    static Node *q[MAX_N*4];
    static int head, tail, pre[MAX_N*4], mask[MAX_N*4], ans;
    q[head=tail=0] = root;
    for (; head<=tail; ++head) {
        Node *k = q[head];
        for (int i=0; i<28; ++i)
            if (k->ch[i]) {
                q[++tail] = k->ch[i];
                pre[tail] = head;
            }
    }
    for (int i=tail; i>=0; --i) {
        if (q[i]->r == INT_MAX)
            mask[i] = q[i]->l<=len1 ? 0x1 : 0x2;
        else if (mask[i]==0x3)
            ans = max(ans, q[i]->len);
        if (i>0) mask[pre[i]] |= mask[i];
    }
    printf("%d\n", ans);
}