洛谷P2414 阿狸的打字机

题意：以trie的形式给出n个字符串，每次询问第x个字符串在第y个字符串中出现了几次。

解：总串长是n²级别的，所以不能用什么后缀自动机...

[update]可以建triesam但是不知道trie上的一个节点对应到了sam上的哪几个节点...感觉可以做...好混乱

听说是个AC自动机上DP，然后怎么想状态都是n²的，然后看题解发现跟DP没啥关系...

是这样的：对于x在y中出现的每一次，我们把它的前面一直补齐，这样每个串就对应着y的一个前缀，且这个前缀的一个后缀是x。

可知，trie上y节点到根的链就代表这些前缀。

然后要求后缀是x。因为x也在这些串中出现了，所以这些前缀一直跳fail的话一定会跳到x节点。即他们全都在x的fail树的子树中。

然后我们就发现，trie上y到根的路径上的节点和fail树上x的子树的节点的交就是答案。

一个很朴素的想法就是把这两棵树剖出来，就是一个二维数点问题。把主席树建出来，因为用了树剖所以每次回答询问是nlog²n的，可以做到在线。

一个高端想法就是离线下来，按照fail树建DFS序。在trie上DFS，维护trie树上当前节点到根的路径权值为1，别的地方为0。

然后查询就是当在trie上DFS到y的时候，查询x在fail树中的子树权值和。

这是单点修改，区间查询。树状数组即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>

const int N = 100010;

struct Edge {
    int nex, v;
}edge[N << 1]; int top;

struct Node {
    int x, y, ans;
}node[N];

int tr[N][26], fail[N], tot = 1;
char str[N];
int ed[N], e[N], pos[N], siz[N], num;
std::vector<int> v[N];

namespace bit {
    int ta[N];
    inline void add(int p) {
        for(int i = p; i < N; i += i & (-i)) {
            ta[i]++;
        }
        return;
    }
    inline void del(int p) {
        for(int i = p; i < N; i += i & (-i)) {
            ta[i]--;
        }
        return;
    }
    inline int getSum(int p) {
        int ans = 0;
        for(int i = p; i >= 1; i -= i & (-i)) {
            ans += ta[i];
        }
        return ans;
    }
    inline int ask(int l, int r) {
        return getSum(r) - getSum(l - 1);
    }
}

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

inline void getAC() {
    std::stack<int> S;
    std::queue<int> Q;
    int n = strlen(str), t = 0, p = 1;
    for(int i = 0; i < n; i++) {
        if(str[i] == 'P') {
            ed[++t] = p;
            continue;
        }
        if(str[i] == 'B') {
            if(!S.empty()) {
                p = S.top();
                S.pop();
            }
            continue;
        }
        int f = str[i] - 'a';
        if(!tr[p][f]) {
            tr[p][f] = ++tot;
        }
        S.push(p);
        p = tr[p][f];
    }
    // getfail
    fail[1] = 1;
    Q.push(1);
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        for(int f = 0; f < 26; f++) {
            if(!tr[x][f]) {
                continue;
            }
            int y = tr[x][f], j = fail[x];
            while(!tr[j][f] && j != 1) {
                j = fail[j];
            }
            if(tr[j][f] && x != 1) {
                j = tr[j][f];
            }
            fail[y] = j;
            add(j, y);
            Q.push(y);
        }
    }
    return;
}

void DFS_1(int x) {
    pos[x] = ++num;
    siz[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        DFS_1(y);
        siz[x] += siz[y];
    }
    return;
}

void DFS_2(int x) {
    bit::add(pos[x]);
    for(int i = 0; i < v[x].size(); i++) {
        int t = node[v[x][i]].x;
        node[v[x][i]].ans = bit::ask(pos[ed[t]], pos[ed[t]] + siz[ed[t]] - 1);
    }
    for(int i = 0; i < 26; i++) {
        if(tr[x][i]) {
            DFS_2(tr[x][i]);
        }
    }
    bit::del(pos[x]);
    return;
}

int main() {
    scanf("%s", str);
    //
    getAC();
    DFS_1(1);
    int m;
    scanf("%d", &m);
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &node[i].x, &node[i].y);
        v[ed[node[i].y]].push_back(i);
    }

    DFS_2(1);

    for(int i = 1; i <= m; i++) {
        printf("%d \n", node[i].ans);
    }
    return 0;
}