LOJ#2444. 「NOI2011」阿狸的打字机

题目描述

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有 \(28\) 个按键，分别印有 \(26\) 个小写英文字母和 B 、 P 两个字母。 经阿狸研究发现，这个打字机是这样工作的：

• 输入小写字母，打字机的一个凹槽中会加入这个字母(按 P 前凹槽中至少有一个字母)。
  
• 按一下印有 B 的按键，打字机凹槽中最后一个字母会消失。
  
• 按一下印有 P 的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失（保证凹槽中至少有一个字母）。

例如，阿狸输入 aPaPBbP ，纸上被打印的字符如下：

a 
aa 
ab

我们把纸上打印出来的字符串从 \(1\) 开始顺序编号，一直到 \(n\) 。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数 \((x,y)\) （其中 \(1 \le x,y \le n\) ），打字机会显示第 \(x\) 个打印的字符串在第 \(y\) 个打印的字符串中出现了多少次。
阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

输入格式

输入的第一行包含一个字符串，按阿狸的输入顺序给出所有阿狸输入的字符。
第二行包含一个整数 \(m\) ，表示询问个数。 接下来 \(m\) 行描述所有由小键盘输入的询问。其中第i行包含两个整数 \(x, y\) ，表示第i个询问为 \((x, y)\) 。

输出格式

输出 \(m\) 行，其中第 \(i\) 行包含一个整数，表示第 \(i\) 个询问的答案。

样例

样例输入

aPaPBbP 
3 
1 2
1 3 
2 3

样例输出

2
1
0

数据范围与提示

所有测试数据的范围和特点如下表所示：

题解

一个比较直观的想法就是按照y来排序，然后对于所有y相同的x询问都只跑一次y，然后用个桶记录答案就可以了。这样能拿70分。

换一个方向来写，将Trie树上属于y的那条链搞上+1的标记，就转化成子树和的问题了，这个可以搞下来dfs序后用树状数组维护子树和。

但是注意处理dfs序的时候，连的边必须是该点的fail向该点连的边（这样才能匹配）。

那么在trie树上dfs一遍（不能是Trie图会进环），每次dfs到一个y的结尾，那么就把对应的x处理了（即查询x子树的区间）。

并且插入字符串要注意边读入边处理，不然读入完后每次重新处理一个串（如70分代码所示）光插入到Trie里面就TLE了...

70分代码

#include <bits/stdc++.h>
using namespace std;

#define N 100010
int ch[N][26], fail[N], last[N], q[N], val[N];
int cnt = 0, tot = 0, num = 0;
int vis[N], ans[N];
char s[N];
vector<char>st[N];
struct Node {
    int x, y, id;
}Q[N];

void insert() {
    int u = 0; ++num;
    for(int i = 1; i <= cnt; ++i) {
        int c = s[i] - 'a';
        st[num].push_back(s[i]);
        if(!ch[u][c]) ch[u][c] = ++tot;
        u = ch[u][c];
    }
    val[u] = num;
}

bool cmp(Node a, Node b) {
    if(a.y == b.y) return a.x < b.x;
    return a.y < b.y;
}

void get_fail() {
    int l = 1, r = 1;
    for(int i = 0; i < 26; ++i) if(ch[0][i]) q[r++] = ch[0][i];
    while(l != r) {
        int u = q[l++];
        if(l == 100000) l = 1;
        for(int i = 0; i < 26; ++i) {
            if(ch[u][i]) {
                fail[ch[u][i]] = ch[fail[u]][i];
                q[r++] = ch[u][i];
                if(r == 100000) r = 1;
            } else ch[u][i] = ch[fail[u]][i];
            last[ch[u][i]] = val[fail[ch[u][i]]] ? fail[ch[u][i]] : last[fail[ch[u][i]]];
        }
    }
}

void query(int id) {
    for(int i = 1; i <= num; ++i) vis[i] = 0;
    int u = 0, len = st[id].size();
    for(int i = 0; i < len; ++i) {
        u = ch[u][st[id][i] - 'a'];
        for(int j = u; j; j = last[j]) {
            if(val[j]) vis[val[j]]++;
        }
    }
}

int main() {
    char c = getchar();
    while(c != '\n') {
        if(c == 'B') --cnt;
        else if(c == 'P') insert();
        else s[++cnt] = c;
        c = getchar();
    }
    int m;
    scanf("%d", &m);
    for(int i = 1, x, y; i <= m; ++i) {
        scanf("%d%d", &x, &y);
        Q[i] = (Node) {x, y, i};
    } 
    sort(Q + 1, Q + m + 1, cmp);
    get_fail();
    for(int i = 1; i <= m; ++i) {
        if(Q[i].y != Q[i - 1].y) {
            query(Q[i].y);
            ans[Q[i].id] = vis[Q[i].x];
        } else ans[Q[i].id] = vis[Q[i].x];
    }
    for(int i = 1; i <= m; ++i) {
        printf("%d\n", ans[i]);
    }
    return 0;
}

100分做法

#include <bits/stdc++.h>
using namespace std;

#define N 100010
int ch[N][26], fail[N], lst[N], val[N];
int cnt = 0, tot = 0, n = 0;
int ql[N], qr[N], ans[N];
char s[N];
struct Node {
    int x, y, id;
}Q[N];
struct edge {
    int to, nxt;
}e[N];
int head[N];

inline void ins(int u, int v) {
    e[++cnt] = (edge) {v, head[u]};
    head[u] = cnt;
}

bool cmp(Node a, Node b) {
    if(a.y == b.y) return a.x < b.x;
    return a.y < b.y;
}

int q[N];
inline void get_fail() {
    int l = 1, r = 1;
    for(int i = 0; i < 26; ++i) if(ch[0][i]) q[r++] = ch[0][i];
    while(l != r) {
        int u = q[l++];
        if(l == 100000) l = 1;
        for(int i = 0; i < 26; ++i) {
            if(ch[u][i]) {
                fail[ch[u][i]] = ch[fail[u]][i];
                q[r++] = ch[u][i];
                if(r == 100000) r = 1;
            } else ch[u][i] = ch[fail[u]][i];
        }
    }
}

int tim, dfn[N], low[N];
int t[N][26], fa[N];
void pre_dfs(int u) {
    dfn[u] = ++tim;
    for(int i = head[u]; i; i = e[i].nxt) pre_dfs(e[i].to);
    low[u] = tim;
}

int c[N];
inline int lowbit(int x) { return x & -x; }
inline void add(int x, int val) {
    for(int i = x; i <= tim; i += lowbit(i)) c[i] += val;
}
inline int query(int x) {
    int ans = 0;
    for(int i = x; i; i -= lowbit(i)) ans += c[i];
    return ans;
}

void dfs(int u) {
    add(dfn[u], 1);
    if(val[u])
        for(int i = ql[val[u]]; i <= qr[val[u]]; ++i)  
            ans[Q[i].id] = query(low[lst[Q[i].x]]) - query(dfn[lst[Q[i].x]] - 1);
    for(int i = 0; i < 26; ++i) if(t[u][i]) dfs(t[u][i]); 
    add(dfn[u], -1);
}

int main() {
    int u = 0;
    char c = getchar();
    while(c != '\n') {
        if(c >= 'a' && c <= 'z') {
            if(!ch[u][c - 'a']) ch[u][c - 'a'] = ++tot, fa[tot] = u;;
            u = ch[u][c - 'a'];
        } 
        if(c == 'B') u = fa[u];
        if(c == 'P') lst[++n] = u, val[u] = n;
        c = getchar();
    }
    int m;
    scanf("%d", &m);
    for(int i = 1, x, y; i <= m; ++i) {
        scanf("%d%d", &x, &y);
        Q[i] = (Node) {x, y, i};
    }
    sort(Q + 1, Q + m + 1, cmp);
    for(int i = 0; i <= tot; ++i) 
        for(int j = 0; j < 26; ++j) t[i][j] = ch[i][j];
    get_fail(); cnt = 0;
    for(int i = 1; i <= tot; ++i) ins(fail[i], i);
    pre_dfs(0); 
    for(int i = 1, p = 1; i <= m; i = p) {
        ql[Q[i].y] = i;
        while(Q[p].y == Q[i].y) ++p;
        qr[Q[i].y] = p - 1;
    }
    dfs(0);
    for(int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
    return 0;
}