P5108 仰望半月的夜空 SAM+线段树覆盖

$ \color{#0066ff}{ 题目描述 }$

半月的夜空中，寄托了多少人与人之间的思念啊

曦月知道，这些思念会汇集成一个字符串\(S(n = |S|)\)

由于思念汇集的过于复杂，因此曦月希望提炼出所有的思念

我们定义\(Y_S(i)\)表示对于字符串\(S\)而言，长度为\(i\)的子串中，字典序最小的，左端点最小的左端点的值

比如对于串\(S = "baa"\)，\(Y_S(1) = 2, Y_S(2) = 2, Y_S(3) = 1\)

曦月会告知你\(S\)串，你只需要告诉曦月\(Y_S(i)(1 \le i \le n)\)即可

\(\color{#0066ff}{输入格式}\)

第一行，两个参数，分别是\(\sigma \in \{10, 26, 10^7\}\)和\(n\)

如果\(\sigma = 26\)，那么第二行将是一个长为\(n\)的小写字母字符串\(S\)

其他情况下，第二行将输入\(n\)个位于\([0, \sigma]内\)的整数

\(\color{#0066ff}{输出格式}\)

输出一行，第iii个数表示\(Y_S(i)\)的值

\(\color{#0066ff}{输入样例}\)

26 11
remoonqaqac

26 11
txdydkwqaqa


10000000 17
9 9 8 2 4 4 3 5 3 1 9 2 6 0 8 1 7

\(\color{#0066ff}{输出样例}\)

8 10 8 8 2 2 2 2 2 2 1
    
9 9 9 5 5 5 5 3 3 1 1
   
14 14 14 14 10 10 10 10 4 4 4 4 4 4 3 2 1

\(\color{#0066ff}{数据范围与提示}\)

\(\color{#0066ff}{题解}\)

建立后缀自动机，要求左端点最小，你需要维护左端点，所以倒着插入，建立后缀树

这样树上的点代表的是某一后缀的前缀

后缀自动机上每个点维护一个pos为起始位置l

然后考虑后缀树上的一条边，它对应的字串长度就是$[父亲len+1，自己的len] $，那么对于这一区间的答案就可以用自己子树的pos最小值来更新

至于字典序最小?，我们可以dfs出后缀树中每个节点是它父亲的那个儿子，然后考虑倒着覆盖，当前字典序是最优的，把原来的覆盖掉，用线段树维护答案就行了

#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 3e5 + 10;
const int inf = 0x7fffffff;
struct Tree {
    protected:
        struct node {
            node *ch[2];
            int l, r, val, tag;
            node(int l = 0, int r = 0, int val = 0, int tag = -1): l(l), r(r), val(val), tag(tag) {
                ch[0] = ch[1] = NULL;
            }
            void trn(int v) { val = tag = v; }
            void dwn() {
                if(tag == -1) return;
                ch[0]->trn(tag);
                ch[1]->trn(tag);
                tag = -1;
            }
            int mid() { return (l + r) >> 1; }
        }*root;
        void build(node *&o, int l, int r) {
            o = new node(l, r);
            if(l == r) return;
            build(o->ch[0], l, o->mid());
            build(o->ch[1], o->mid() + 1, r);
        }
        void lazy(node *o, int l, int r, int val) {
            if(l > r) return;
            if(l <= o->l && o->r <= r) return o->trn(val);
            o->dwn();
            if(l <= o->mid()) lazy(o->ch[0], l, r, val);
            if(r > o->mid()) lazy(o->ch[1], l, r, val);
        }
        void out(node *o) {
            if(o->l == o->r) return (void)(printf("%d ", o->val));
            o->dwn();
            out(o->ch[0]); out(o->ch[1]);
        }
    public:
        void build(int n) { build(root, 1, n); }
        void lazy(int l, int r, int val) { lazy(root, l, r, val); }
        void out() { out(root); }
}tree;
struct SAM {
    protected:
        struct node {
            std::map<int, node*> ch, treech;
            node *fa;
            int len, pos;
            node(int len = 0, int pos = 0): len(len), pos(pos) { 
                fa = NULL;
                ch.clear(), treech.clear();
            }
        }pool[maxn << 1], *tail, *root, *lst;
        int s[maxn];
        char ls[maxn];
        void extend(int c, int id) {
            node *o = new(tail++) node(lst->len + 1, id), *v = lst;
            for(; v && !v->ch[c]; v = v->fa) v->ch[c] = o;
            if(!v) o->fa = root;
            else if(v->len + 1 == v->ch[c]->len) o->fa = v->ch[c];
            else {
                node *n = new(tail++) node(v->len + 1, v->ch[c]->pos), *d = v->ch[c];
                n->ch = d->ch, n->fa = d->fa, d->fa = o->fa = n;
                for(; v && v->ch[c] == d; v = v->fa) v->ch[c] = n;
            }
            lst = o;
        }
        void getmin(node *o) {
            for(std::pair<int, node*> i : o->treech) {
                getmin(i.second);
                o->pos = std::min(o->pos, i.second->pos);
            }
        }
        void getans(node *o) {
            tree.lazy((o->fa? o->fa->len + 1 : 1), o->len, o->pos);
            for(std::map<int, node*>::reverse_iterator it = o->treech.rbegin(); it != o->treech.rend(); it++)
                getans(it->second);
        }
    public:
        SAM() {
            tail = pool;
            root = lst = new(tail++) node();
        }
        void init(int bel, int len) {
            if(bel == 26) {
                scanf("%s", ls + 1);
                for(int i = 1; i <= len; i++) s[i] = ls[i] - 'a';
            }
            else {
                for(int i = 1; i <= len; i++) s[i] = in();
            }
            for(int i = len; i >= 1; i--) extend(s[i], i); 
        }
        void build() { 
            for(node *o = pool + 1; o != tail; o++)
                o->fa->treech[s[o->pos + o->fa->len]] = o;
        }
        void getmin() { getmin(root); }
        void getans() { getans(root); }
}s;
int main() {
    int val = in(), n = in();
    s.init(val, n);
    tree.build(n);
    s.build();
    s.getmin();
    s.getans();
    tree.out();
    return 0;
}

转载于:https://www.cnblogs.com/olinr/p/10580458.html