bzoj4545

lct+SAM

bzoj4516+bzoj2555

这道题唯一的用处就是教会了我真正的广义SAM

dfs时保留当前节点在后缀自动机中的位置，每个点接着父亲建

lct动态维护right集合大小，用lct维护子树就行了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5 + ;
struct edge {
    int nxt, to, w;
} e[N << ];
int n, m, cnt = ;
int h[N], pos[N];
char s[N];
long long sum;
namespace lct
{
    struct node {
        int ch[];
        int f, tag, reg;
    } t[N << ];
    bool isr(int x) {
        return !t[x].f || (t[t[x].f].ch[] != x && t[t[x].f].ch[] != x);
    }
    int wh(int x) {
        return x == t[t[x].f].ch[];
    }
    void paint(int x, int d) {
        t[x].tag += d;
        t[x].reg += d;
    }
    void pushdown(int x) {
        if(t[x].tag) {
            paint(t[x].ch[], t[x].tag);
            paint(t[x].ch[], t[x].tag);
            t[x].tag = ;
        }
    }
    void pd(int x) {
        if(!isr(x)) {
            pd(t[x].f);
        }
        pushdown(x);
    }
    void rotate(int x) {
        int y = t[x].f, z = t[y].f, w = wh(x);
        if(!isr(y)) {
            t[z].ch[wh(y)] = x;
        }
        t[x].f = z;
        t[y].ch[w] = t[x].ch[w ^ ];
        t[t[x].ch[w ^ ]].f = y;
        t[y].f = x;
        t[x].ch[w ^ ] = y;
    }
    void splay(int x) {
        pd(x);
        for(; !isr(x); rotate(x)) {
            if(!isr(t[x].f)) {
                rotate(wh(t[x].f) == wh(x) ? t[x].f : x);
            }
        }
    }
    void access(int x) {
        for(int y = ; x; y = x, x = t[x].f) {
            splay(x);
            t[x].ch[] = y;
        }
    }
    void link(int u, int v) {
        access(u);
        splay(u);
        access(v);
        splay(v);
        paint(v, t[u].reg);
        t[u].f = v;
    }
    void cut(int u, int v) {
        access(u);
        splay(u);
        t[u].ch[] = ;
        t[v].f = ;
        paint(v, -t[u].reg);
    }
}
namespace SAM
{
    struct node {
        int ch[];
        int par, val;
    } t[N << ];
    int root = , sz = ;
    int nw(int x) {
        t[++sz].val = x;
        return sz;
    }
    int extend(int last, int c) {
        int p = last, np = nw(t[p].val + );
        lct::t[np].reg = ;
        while(p && !t[p].ch[c]) {
            t[p].ch[c] = np;
            p = t[p].par;
        }
        if(!p) {
            t[np].par = root;
            lct::link(np, root);
        } else {
            int q = t[p].ch[c];
            if(t[q].val == t[p].val + ) {
                t[np].par = q;
                lct::link(np, q);
            } else {
                int nq = nw(t[p].val + );
                lct::link(nq, t[q].par);
                lct::cut(q, t[q].par);
                lct::link(np, nq);
                lct::link(q, nq);
                t[nq].par = t[q].par;
                t[np].par = t[q].par = nq;
                memcpy(t[nq].ch, t[q].ch, sizeof(t[q].ch));
                while(p && t[p].ch[c] == q) {
                    t[p].ch[c] = nq;
                    p = t[p].par;
                }
            }
        }
        sum += t[np].val - t[t[np].par].val;
        return np;
    }
    void solve(char *s) {
        int len = strlen(s), now = root;
        for(int i = ; i < len; ++i) {
            if(!t[now].ch[s[i] - 'a']) {
                puts("");
                return;
            }
            now = t[now].ch[s[i] - 'a'];
        }
        lct::pd(now);
        printf("%d\n", lct::t[now].reg);
        lct::splay(now);
    }
}
void link(int u, int v, int w) {
    e[++cnt].nxt = h[u];
    h[u] = cnt;
    e[cnt].to = v;
    e[cnt].w = w;
}
void dfs(int u, int last) {
    for(int i = h[u]; i; i = e[i].nxt) {
        if(e[i].to == last) {
            continue;
        }
        pos[e[i].to] = SAM::extend(pos[u], e[i].w);
        dfs(e[i].to, u);
    }
    h[u] = ;
}
int main() {
//    freopen("1.out", "w", stdout);
    int laji;
    scanf("%d%d", &laji, &n);
    for(int i = ; i < n; ++i) {
        int u, v;
        scanf("%d%d%s", &u, &v, s);
        link(u, v, s[] - 'a');
        link(v, u, s[] - 'a');
    }
    pos[] = ;
    dfs(, );
    scanf("%d", &m);
    while(m--) {
        int opt;
        scanf("%d", &opt);
        if(opt == ) {
            printf("%lld\n", sum);
        } else if(opt == ) {
            int rt, sz;
            scanf("%d%d", &rt, &sz);
            while(--sz) {
                int u, v;
                scanf("%d%d%s", &u, &v, s);
                link(u, v, s[] - 'a');
                link(v, u, s[] - 'a');
            }
            dfs(rt, );
        } else {
            scanf("%s", s);
            SAM::solve(s);
        }
    }
    return ;
}