BZOJ1396识别子串（后缀自动机）

题目链接

BZOJ

解析

后缀自动机+线段树

若一个子串可识别，那么它的\(right\)集合大小一定为\(1\)

对于一个\(right\)大小为\(1\)的节点：

1. 它的\(right\)仅包含\(maxlen\)

2. 对\([1,minlen]\)的每一个位置\(x\)产生\(maxlen - x + 1\)的贡献，因为\(str[x..maxlen]\)只在\(maxlen\)处出现，是一个可识别子串

3. 对\([minlen - 1, maxlen]\)的每个位置\(x\)产生\(minlen\)的贡献，因为\(str[x..maxlen]\)必定在其它位置出现，不是可识别子串，包含该位置的最短可识别子串为\(str[maxlen - minlen + 1..maxlen]\)

两种贡献分别建线段树统计每个位置的最小值即可

代码

P.S.字符串长度先处理出来，否则像我开始一样T得飞起。。。。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#define MAXN 100005

typedef long long LL;
struct SuffixAutomaton {
    struct Node {
        Node *next[26], *link;
        int maxlen, once;
        void friend cpy(Node *a, const Node *b) {
            a->maxlen = b->maxlen, a->once = b->once, a->link = b->link;
            for (int i = 0; i < 26; ++i) a->next[i] = b->next[i];
        }
    } * root, *last, *node[MAXN << 1];
    int cnt;
    SuffixAutomaton() { last = root = new Node(); }
    void build(char *);
    Node *add(char);
    void work();
} sam;
struct SegmentTree {
    int tree[MAXN << 4], upd[MAXN << 4];
    SegmentTree() { memset(tree, 0x3f, sizeof tree); memset(upd, 0x3f, sizeof upd); }
    void push_down(int);
    void update(int, int, int, int, int, int);
    int query(int, int, int, int);
} tree1, tree2;
char string[MAXN];
int N;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin >> (string + 1);
    N = strlen(string + 1);
    sam.build(string);
    sam.work();
    for (int i = 1; i <= N; ++i)
        std::cout << std::min(tree1.query(1, 1, MAXN, i) - i, tree2.query(1, 1, MAXN, i)) << std::endl;
    
    return 0;
}
void SuffixAutomaton::build(char *str) {
    for (int i = 1; i <= N; ++i) last = add(str[i]);
}
SuffixAutomaton::Node *SuffixAutomaton::add(char ch) {
    int c = ch - 'a';
    Node *np = new Node(), *p = last;
    node[++cnt] = np;
    np->maxlen = p->maxlen + 1, np->once = 1;
    while (p && !p->next[c]) p->next[c] = np, p = p->link;
    if (!p) np->link = root;
    else {
        Node *q = p->next[c];
        if (p->maxlen + 1 == q->maxlen) np->link = q;
        else {
            Node *nq = new Node();
            node[++cnt] = nq;
            cpy(nq, q);
            nq->maxlen = p->maxlen + 1;
            q->link = np->link = nq;
            while (p && p->next[c] == q) p->next[c] = nq, p = p->link;
        }
    }
    return np;
}
void SuffixAutomaton::work() {
    for (int i = 1; i <= cnt; ++i)
        node[i]->link->once = 0;
    for (int i = 1; i <= cnt; ++i)
        if (node[i]->once) {
            SuffixAutomaton::Node *p = node[i];
            tree1.update(1, 1, MAXN, 1, p->maxlen - p->link->maxlen, p->maxlen + 1);
            tree2.update(1, 1, MAXN, p->maxlen - p->link->maxlen, p->maxlen, p->link->maxlen + 1);
        }
}
void SegmentTree::push_down(int id) {
    if (upd[id] ^ 0x3f3f3f3f) {
        upd[id << 1] = std::min(upd[id << 1], upd[id]);
        upd[id << 1 | 1] = std::min(upd[id << 1 | 1], upd[id]);
        tree[id << 1] = std::min(tree[id << 1], upd[id]);
        tree[id << 1 | 1] = std::min(tree[id << 1 | 1], upd[id]);
        upd[id] = 0x3f3f3f3f;
    }
}
void SegmentTree::update(int id, int L, int R, int l, int r, int v) {
    if (L >= l && R <= r) tree[id] = std::min(tree[id], v), upd[id] = std::min(upd[id], v);
    else {
        int mid = (L + R) >> 1;
        if (l <= mid) update(id << 1, L, mid, l, r, v);
        if (r > mid) update(id << 1 | 1, mid + 1, R, l, r, v);
    }
}
int SegmentTree::query(int id, int L, int R, int p) {
    if (L == R) return tree[id];
    push_down(id);
    int mid = (L + R) >> 1;
    if (p <= mid) return query(id << 1, L, mid, p);
    else return query(id << 1 | 1, mid + 1, R, p);
}
//Rhein_E

转载于:https://www.cnblogs.com/Rhein-E/p/10447303.html