题目链接 P5840
给一组比较强的样例（我刚好是过了这个才过的）：
3
aa
ba
cc
2
1 aabacc
2 2
ans:1
然后，讲一下思维的过程：
刚看到这个问题的时候，卡在了怎样去处理“访问到仅能算一次”，而不是“访问到几次就算几次”。大白话的意思就是“aaaaaa”里有6个“a”，但是我们只能对“a”算一次，所以，返回到fail树上去。
现在看到fail树，我们想要去重的操作，那么还是先打一下dfs序出来，然后在一条链上，我们知道dfs序更大的，一定是更深的。所以，如果说我们要去给某个点算一次的话，我们可以对它的子树中最深的算，当然，如果他的两个子树都会产生贡献的话，我们还要用LCA的差分来减一下，保证每条链上最多是“+1”。
处理这个问题，当然有可能遇到一个点被重复出现，就譬如说“aabaa”中“a”可以出现4次，我们不能一直对着这个“a”反复操作，所以（虽然不影响——因为在同一条链上不会再产生贡献），但是为了时间上的少许优化，我们仍然可以去unique去重一下（手动最好啦！），又有dfs序更大的往往是在一条链的下面的，所以呢我们按照将序来排，先处理下面的，然后再处理上面的。
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e6 + 7;
int N, M, tot = 0, head[maxN] = {-1}, cnt = 0, ith[100005];
char s[maxN];
struct node
{
int nex[26], fail;
}a[maxN];
inline void Insert(int id)
{
int len = (int)strlen(s), root = 0;
for(int i=0, ch; i<len; i++)
{
ch = s[i] - 'a';
if(!a[root].nex[ch]) { a[root].nex[ch] = ++tot; head[tot] = -1; }
root = a[root].nex[ch];
}
ith[id] = root;
}
struct Eddge
{
int nex, to;
Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[maxN];
inline void addEddge(int u, int v)
{
edge[cnt] = Eddge(head[u], v);
head[u] = cnt++;
}
inline void build_fail()
{
queue<int> Q; Q.push(0);
int tmp, p, son;
while(!Q.empty())
{
tmp = Q.front(); Q.pop();
for(int i=0; i<26; i++)
{
son = a[tmp].nex[i];
if(son)
{
if(!tmp) a[son].fail = 0;
else
{
p = a[tmp].fail;
while(p && !a[p].nex[i]) p = a[p].fail;
a[son].fail = a[p].nex[i];
}
Q.push(son);
addEddge(a[son].fail, son);
}
}
}
}
int dfn[maxN], _Index = 0, siz[maxN], fa[maxN][21] = {0}, deep[maxN] = {0};
void dfs(int u, int father)
{
dfn[u] = ++_Index; siz[dfn[u]] = 1;
if(~father)
{
fa[dfn[u]][0] = dfn[father]; deep[dfn[u]] = deep[dfn[father]] + 1;
for(int i=0; i < 20; i++) { fa[dfn[u]][i + 1] = fa[fa[dfn[u]][i]][i]; }
}
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
dfs(v, u);
siz[dfn[u]] += siz[dfn[v]];
}
}
bool live_the_same = true;
inline int _LCA(int u, int v)
{
if(deep[u] < deep[v]) swap(u, v);
int det = deep[u] - deep[v];
if(det) for(int i=log2(det); ~i; i--) if((det >> i) & 1) u = fa[u][i];
if(u == v) return u;
live_the_same = false;
for(int i=20; i>=0; i--)
{
if(fa[u][i] ^ fa[v][i])
{
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
int vt[maxN], iter;
inline bool cmp(int e1, int e2) { return e1 > e2; }
int trie[maxN] = {0};
inline void update(int x, int val) { while(x < maxN) { trie[x] += val; x += lowbit(x); } }
inline int query(int x) { int ss = 0; while(x) { ss += trie[x]; x -= lowbit(x); } return ss; }
inline int Range_Query(int l, int r) { return query(r) - query(l - 1); }
inline void _Fid()
{
int len = (int)strlen(s), root = 0;
iter = 0;
for(int i=0, ch; i<len; i++)
{
ch = s[i] - 'a';
if(a[root].nex[ch])
{
root = a[root].nex[ch];
vt[++iter] = dfn[root];
}
else
{
root = a[root].fail;
while(root && !a[root].nex[ch]) root = a[root].fail;
if(a[root].nex[ch])
{
root = a[root].nex[ch];
vt[++iter] = dfn[root];
}
}
}
sort(vt + 1, vt + iter + 1, cmp);
len = 0;
if(iter)
{
vt[++len] = vt[1];
for(int i=2; i<=iter; i++)
{
if(vt[i] ^ vt[len]) vt[++len] = vt[i];
}
}
int u, v;
if(len == 1)
{
u = vt[1];
update(u, 1);
}
else
{
u = vt[1];
update(u, 1);
for(int i=2, _lca; i<=len; i++)
{
live_the_same = true;
v = vt[i]; _lca = _LCA(u, v);
if(!live_the_same)
{
update(v, 1); update(_lca, -1);
}
u = v;
}
}
}
int main()
{
scanf("%d", &N);
for(int i=1; i<=N; i++)
{
scanf("%s", s);
Insert(i);
}
build_fail();
dfs(0, -1);
scanf("%d", &M);
int op, x;
while(M--)
{
scanf("%d", &op);
if(op == 1)
{
scanf("%s", s);
_Fid();
}
else
{
scanf("%d", &x);
printf("%d\n", Range_Query(dfn[ith[x]], dfn[ith[x]] + siz[dfn[ith[x]]] - 1));
}
}
return 0;
}