洛谷P2336 喵星球上的点名

解：SAM + 线段树合并 + DFS序。

姓和名之间插入特殊字符，转化为下题：

给定串集合S，T，问S中每个串包含了T中的几个串？T中每个串被多少个S中的串包含?

解：对S建广义SAM，并线段树合并维护每个节点有多少串。

T中每个串在S的sam上跑，如果没能跑完就被包含0次。否则答案就是到达的节点上的串数。第二问解决。

标记T中每个串最后到达的节点。S中每个串跑S的sam会得到若干个点。统计这些点到根路径的并集上的标记个数即可。

按DFS序排序，加上每个节点到根路径的贡献，减去相邻节点lca到根路径的贡献。第一问解决。

#include <bits/stdc++.h>

const int N = 400010, M = 10000010;

struct Edge {
    int nex, v;
}edge[N]; int tp;

std::map<int, int> tr[N];
int fail[N], len[N], tot = 1, e[N], n, m, siz[N], ed[N],
    stk[N], top, num2, pos2[N], ST[N << 1][22], pw[N << 1], d[N];
int ls[M], rs[M], num, sum[M], rt[N];
std::vector<int> str[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

inline bool cmp(const int &a, const int &b) {
    return pos2[a] < pos2[b];
}

void insert(int p, int l, int r, int &o) {
    if(!o) o = ++num;
    if(l == r) {
        sum[o] = 1;
        return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) insert(p, l, mid, ls[o]);
    else insert(p, mid + 1, r, rs[o]);
    sum[o] = sum[ls[o]] + sum[rs[o]];
    return;
}

int merge(int x, int y) {
    if(!x || !y) return x | y;
    int o = ++num;
    ls[o] = merge(ls[x], ls[y]);
    rs[o] = merge(rs[x], rs[y]);
    if(!ls[o] && !rs[o]) sum[o] = 1;
    else sum[o] = sum[ls[o]] + sum[rs[o]];
    return o;
}

int ask(int L, int R, int l, int r, int o) {
    if(!o) return 0;
    if(L <= l && r <= R) return sum[o];
    int mid = (l + r) >> 1, ans = 0;
    if(L <= mid) ans += ask(L, R, l, mid, ls[o]);
    if(mid < R) ans += ask(L, R, mid + 1, r, rs[o]);
    return ans;
}

void DFS_1(int x) {
    pos2[x] = ++num2;
    ST[num2][0] = x;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        d[y] = d[x] + 1;
        DFS_1(y);
        ST[++num2][0] = x;
        rt[x] = merge(rt[x], rt[y]);
    }
    return;
}

inline void prework() {
    for(int i = 2; i <= num2; i++) pw[i] = pw[i >> 1] + 1;
    for(int j = 1; j <= pw[num2]; j++) {
        for(int i = 1; i + (j << 1) - 1 <= num2; i++) {
            if(d[ST[i][j - 1]] < d[ST[i + (1 << (j - 1))][j - 1]])
                ST[i][j] = ST[i][j - 1];
            else
                ST[i][j] = ST[i + (1 << (j - 1))][j - 1];
        }
    }
    return;
}

inline int lca(int x, int y) {
    x = pos2[x];
    y = pos2[y];
    if(x > y) std::swap(x, y);
    int t = pw[y - x + 1];
    if(d[ST[x][t]] < d[ST[y - (1 << t) + 1][t]])
        return ST[x][t];
    else
        return ST[y - (1 << t) + 1][t];
}

void DFS_2(int x) {
    siz[x] += ed[x];
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        siz[y] = siz[x];
        DFS_2(y);
    }
    return;
}

inline int split(int p, int f) {
    int Q = tr[p][f], nQ = ++tot;
    len[nQ] = len[p] + 1;
    fail[nQ] = fail[Q];
    fail[Q] = nQ;
    //memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
    tr[nQ] = tr[Q];
    while(tr[p][f] == Q) {
        tr[p][f] = nQ;
        p = fail[p];
    }
    return nQ;
}

inline int insert(int p, int f, int id) {
    int np;
    if(tr[p].count(f)) {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            np = Q;
        }
        else {
            np = split(p, f);
        }
        insert(id, 1, n, rt[np]);
        return np;
    }
    np = ++tot;
    len[np] = len[p] + 1;
    while(p && !tr[p].count(f)) {
        tr[p][f] = np;
        p = fail[p];
    }
    if(!p) {
        fail[np] = 1;
    }
    else {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            fail[np] = Q;
        }
        else {
            fail[np] = split(p, f);
        }
    }
    insert(id, 1, n, rt[np]);
    return np;
}

void out(int l, int r, int o) {
    if(!o) return;
    if(l == r) {
        printf("%d ", r);
        return;
    }
    int mid = (l + r) >> 1;
    out(l, mid, ls[o]);
    out(mid + 1, r, rs[o]);
    return;
}

inline void clear() {
    for(int i = 1; i <= tot; i++) {
        e[i] = len[i] = fail[i] = rt[i] = 0;
        tr[i].clear();
    }
    for(int i = 1; i <= num; i++) {
        ls[i] = rs[i] = sum[i] = 0;
    }
    tp = num = 0;
    tot = 1;
    return;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) {
        int k, x, p = 1;
        scanf("%d", &k);
        for(int j = 1; j <= k; j++) {
            scanf("%d", &x);
            str[i].push_back(x);
            p = insert(p, x, i);
        }
        str[i].push_back(-1);
        p = insert(p, -1, i);
        scanf("%d", &k);
        for(int j = 1; j <= k; j++) {
            scanf("%d", &x);
            str[i].push_back(x);
            p = insert(p, x, i);
        }
    }
    /// build
    for(int i = 2; i <= tot; i++) {
        //printf("add %d %d 
", fail[i], i);
        add(fail[i], i);
    }
    DFS_1(1);

    for(int i = 1; i <= m; i++) {
        int k, x, p = 1, fd = 0, ans = 0;
        scanf("%d", &k);
        for(int j = 1; j <= k; j++) {
            scanf("%d", &x);
            if(!tr[p].count(x)) fd = 1;
            else p = tr[p][x];
        }
        if(!fd) {
            ans = sum[rt[p]];
            ed[p]++;
        }
        printf("%d
", ans);
    }

    DFS_2(1);
    prework();

    for(int i = 1; i <= n; i++) {
        int p = 1; top = 0;
        for(int j = 0; j < (int)str[i].size(); j++) {
            int x = str[i][j];
            p = tr[p][x];
            stk[++top] = p;
        }
        std::sort(stk + 1, stk + top + 1,cmp);
        top = std::unique(stk + 1, stk + top + 1) - stk - 1;
        int ans = 0;
        for(int j = 1; j <= top; j++) {
            ans += siz[stk[j]];
            if(j < top) ans -= siz[lca(stk[j], stk[j + 1])];
        }
        printf("%d ", ans);
    }

    return 0;
}

AC自动机解法。