洛谷P2414 阿狸的打字机【AC自动机】【fail树】【dfs序】【树状数组】

居然真的遇上了这种蔡队题。瑟瑟发抖。

题目背景

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。

题目描述

打字机上只有28个按键，分别印有26个小写英文字母和'B'、'P'两个字母。经阿狸研究发现，这个打字机是这样工作的：

·输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。

·按一下印有'B'的按键，打字机凹槽中最后一个字母会消失。

·按一下印有'P'的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。

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

a aa ab 我们把纸上打印出来的字符串从1开始顺序编号，一直到n。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数(x,y)（其中1≤x,y≤n），打字机会显示第x个打印的字符串在第y个打印的字符串中出现了多少次。

阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

输入输出格式

输入格式：

输入的第一行包含一个字符串，按阿狸的输入顺序给出所有阿狸输入的字符。

第二行包含一个整数m，表示询问个数。

接下来m行描述所有由小键盘输入的询问。其中第i行包含两个整数x, y，表示第i个询问为(x, y)。

输出格式：

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

输入输出样例

输入样例#1： 复制

aPaPBbP
3
1 2
1 3
2 3

输出样例#1： 复制

2
1
0

说明

数据范围:

对于100%的数据，n<=100000,m<=100000,第一行总长度<=100000。

题意：

给n个字符串问每次有m个询问，问第x个字符串在第y个字符串中出现了几次。

思路：

最开始是暴力建树，在字符串的结尾标记序号，然后每次询问暴力在树上查找。40分TLE

后来去看题解。题解看了无敌久。

实际上我们可以发现我们每次都是沿着AC自动机的fail指针在跳，在y中匹配x就是在属于y字符串的节点中能找到多少个节点可以跳到x的结束节点。

那么我们可以把原本的边都删去只保留fail指针，这就是AC自动机上的fail树。

把fail指针的方向反过来，其实就是找以x为根的树中有多少个节点是属于y的。

但是查询有很多组，暴力查询还是不可以的。由于每次查询我们需要去标记y节点，查询完了y节点的标记要删去。所以可以考虑先把所有查询排个序，把所有y相同的放在一起进行查询。并且我们处理出查询中某个x的下标区间，当dfs过程中访问到了这个x的结束节点就同时更新这些查询的答案。

建树的过程中先记下对应序号的字符串的结束节点下标和父亲节点，遇到“B”我们就回退到父亲节点，遇到“P”就打结束标记。

然后获取fail指针，并用fail指针建边，跑一遍dfs序，得到以x为根的子树的区间。

对排好序的问题，我们预处理出所有以y为第二个参数的查询的编号区间。

用树状数组维护子树和，dfs查询子树和，当访问到y的结尾时，说明这一组y完成了打标记工作，可以去求子树和了。那么就更新一下这一组查询的答案。然后要记得将这段子树的值-1

最后重新将答案映射会原来的顺序输出。

暴力40分代码：

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
typedef long long LL;
#define inf 0x7f7f7f7f

int n, m;
const int maxn = 1e5 + 5;

struct Tree{
    int fail;//失配指针
    int vis[26];//子节点位置
    int ed = -1;
}AC[maxn];
string s[maxn];
int tot = 0, cnt = 0;

void build(string sss, int id)
{
    //cout<<sss<<endl;
    int len = sss.length();
    int now = 0;//字典树当前指针
    for(int i = 0; i < len; i++){
        if(AC[now].vis[sss[i] - 'a'] == 0){
            AC[now].vis[sss[i] - 'a'] = ++tot;
        }
        now = AC[now].vis[sss[i] - 'a'];
    }
    AC[now].ed = id;
}

void get_fail()
{
    queue<int> que;
    for(int i = 0; i < 26; i++){
        if(AC[0].vis[i] != 0){
            AC[AC[0].vis[i]].fail = 0;
            que.push(AC[0].vis[i]);
        }
    }
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i = 0; i < 26; i++){
            if(AC[u].vis[i] != 0){
                AC[AC[u].vis[i]].fail = AC[AC[u].fail].vis[i];
                que.push(AC[u].vis[i]);
            }
            else{
                AC[u].vis[i] = AC[AC[u].fail].vis[i];
            }
        }
    }
}

int AC_query(int x, int y)
{
    int leny = s[y].length();
    int now = 0, ans = 0;
    for(int i = 0; i < leny; i++){
        now = AC[now].vis[s[y][i] - 'a'];
        for(int t = now; t; t = AC[t].fail){
            if(AC[t].ed == x){
                ans++;
            }
        }
    }
    return ans;
}

int main()
{
    string str;
    char tmp[maxn];
    cin>>str;
    int len = str.length(), j = 0;
    for(int i = 0; i < len; i++){
        if(str[i] == 'B'){
            tmp[j] = 0;
            j--;
        }
        else if(str[i] == 'P'){

            s[cnt] = tmp;
            //cout<<s[cnt]<<endl;
            build(s[cnt], cnt);cnt++;
        }
        else{
            tmp[j++] = str[i];
        }
    }
    AC[0].fail = 0;
    get_fail();
    scanf("%d", &m);
    while(m--){
        int x, y;
        scanf("%d %d", &x, &y);
        //cout<<s[x - 1]<<" "<<s[y - 1]<<endl;
        cout<<AC_query(x - 1, y - 1)<<endl;
    }
    //cout<<s[maxid]<<endl;
    //cout<<AC_query(s)<<endl;
    return 0;
}

AC100分代码：

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
typedef long long LL;
#define inf 0x7f7f7f7f

int n, m;
const int maxn = 1e5 + 5;

char ss[maxn];
int nd[maxn], tot;
int ans[maxn];
int tree[maxn];
int dfn[maxn], low[maxn], tim;
int ql[maxn], qr[maxn];//dfs序左端点和右端点
struct Tree{
    int fail, fa;
    int son[26];//子节点位置
    int vis[26];
    int ed = -1;
}AC[maxn];
struct query{
    int x, y, id, ans;
}q[maxn];
bool operator < (query a, query b){return a.y < b.y;}
void update(int x, int k)
{
    while(x <= tim){
        tree[x] += k;
        x += x & (-x);
    }
}

int sum(int x)
{
    int ans = 0;
    while(x){
        ans += tree[x];
        x -= x & (-x);
    }
    return ans;
}

/*void build(string sss, int rt)
{
    //cout<<sss<<endl;
    int len = sss.length();
    int now = 0;//字典树当前指针
    for(int i = 0; i < len; i++){
        if(AC[now].vis[sss[i] - 'a'] == 0){
            AC[now].vis[sss[i] - 'a'] = ++tot;
        }
        now = AC[now].vis[sss[i] - 'a'];
    }
    AC[now].ed = id;
}*/

void get_fail()
{
    queue<int> que;
    for(int i = 0; i < 26; i++){
        if(AC[0].son[i] != 0){
            //AC[AC[0].vis[i]].fail = 0;
            que.push(AC[0].son[i]);
        }
    }
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i = 0; i < 26; i++){
            if(AC[u].son[i] != 0){
                AC[AC[u].son[i]].fail = AC[AC[u].fail].son[i];
                que.push(AC[u].son[i]);
            }
            else{
                AC[u].son[i] = AC[AC[u].fail].son[i];
            }
        }
    }
}

struct edge{
    int v, nxt;
}e[maxn << 1];
int head[maxn], cnt = 1;
void addedge(int u, int v)
{
    e[cnt] = (edge){v, head[u]};
    head[u] = cnt++;
}

void dfs_sort(int rt)
{
    dfn[rt] = ++tim;
    for(int i = head[rt]; i; i = e[i].nxt)dfs_sort(e[i].v);
    low[rt] = tim;
}

void dfs(int rt)
{
    update(dfn[rt], 1);
    if(AC[rt].ed){
        for(int i = ql[AC[rt].ed]; i <= qr[AC[rt].ed]; i++){
            q[i].ans = sum(low[nd[q[i].x]]) - sum(dfn[nd[q[i].x]] - 1);
        }
    }
    for(int i = 0; i < 26; i++){
        if(AC[rt].vis[i]){
            dfs(AC[rt].vis[i]);
        }
    }
    update(dfn[rt], -1);
}

int main()
{
    scanf("%s", ss + 1);
    int now = 0;
    int len = strlen(ss + 1);
    for(int i = 1; i <= len; i++){
        if(ss[i] == 'B'){
            now = AC[now].fa;
        }
        else if(ss[i] == 'P'){
            nd[++n] = now;
            AC[now].ed = n;
        }
        else{
            if(!AC[now].son[ss[i] - 'a']){
                AC[now].son[ss[i] - 'a']= ++tot;
                AC[tot].fa = now;
                now = AC[now].son[ss[i] - 'a'];
            }
        }
    }
    for(int i = 0; i <= tot; i++){
        for(int j = 0; j < 26; j++){
            AC[i].vis[j] = AC[i].son[j];
        }
    }
    //AC[0].fail = 0;
    get_fail();
    for(int i = 1; i <= tot; i++){
        addedge(AC[i].fail, i);
    }
    dfs_sort(0);
    scanf("%d", &m);
    for(int i = 1; i <= m; i++){
        scanf("%d %d", &q[i].x, &q[i].y);
        q[i].id = i;
        //cout<<s[x - 1]<<" "<<s[y - 1]<<endl;
    }
    sort(&q[1], &q[m + 1]);
    for(int i = 1, pos = 1; i <= m; i = pos){
        ql[q[i].y] = i;
        while(q[pos].y == q[i].y) pos++;
        qr[q[i].y] = pos - 1;
    }
    dfs(0);
    for(int i = 1; i <= m; i++){
        ans[q[i].id] = q[i].ans;
    }
    for(int i = 1; i <= m; i++){
        printf("%d
", ans[i]);
    }
    //cout<<s[maxid]<<endl;
    //cout<<AC_query(s)<<endl;
    return 0;
}