题目链接

首先可以发现两种算法

一. 暴力处理

对"特征串"建SAM

枚举路径的一个端点，\(dfs\)另一个端点，同时维护在SAM上的位置.

每到一个位置会有SAM上对应节点的right集合大小的贡献

复杂度\(O(size^2)\)

二. 处理经过一个点的所有路径

设这个点是\(u\)，字符为\(a[u]\)

需要建出正反特征串的后缀树

考虑从点\(u\)出发的所有路径(\(a[u]\)为字符串的开头)，统计出以特征串的每一位为起始的这些串的数量

同理将这些串\(reverse\)(\(a[u]\)为串的最后一位)，统计出在特征串每一位结束的串的数量

对应位上两组串数量的乘积的和即为贡献，因为某正串在一位起始，某反串在这位结束，即可拼出一个路径

由于\(dfs\)时正串是每次在末尾加字符维护在特征串中起始位置，反串是每次开头加字符维护结束位置，将特征串和路径串翻转后即为同一个问题，我们只考虑\(push\ front\)维护结束位置

后缀自动机的转移只能支持末尾插入，于是需要利用后缀树

后缀树上一条边会对应原串中的一段区间

转移时需要注意从上往下走了不满一条边的情况，此时大概需要走到儿子处，注意判无转移时无解

每次在节点上打标记，最后全部下放到叶子处 统计每个位置的出现次数

复杂度\(O(size+m)\)

然后使用点分治，若分治的大小\(size>\sqrt{m}\)使用方法2， 否则暴力做方法1

这里需要注意同一子树的去重 在去重的时候应使用对应的方法保证复杂度

易知复杂度为\(O((n+m)\sqrt{m})\)

代码如下

#include<cstdio>
#include<algorithm>
#include<ctype.h>
#include<string.h>
#include<math.h>using namespace std;
#define ll long long
#define rep(i,x,y) for(int i=(x);i<=(y);++i)
#define travel(i,x) for(int i=h[x];i;i=pre[i])inline char read() {static const int IN_LEN = 1000000;static char buf[IN_LEN], *s, *t;return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin), (s == t ? -1 : *s++) : *s++);
}
template<class T>
inline void read(T &x) {static bool iosig;static char c;for (iosig = false, c = read(); !isdigit(c); c = read()) {if (c == '-') iosig = true;if (c == -1) return;}for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');if (iosig) x = -x;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;*ooh++ = c;
}
template<class T>
inline void print(T x) {static int buf[30], cnt;if (x == 0) print('0');else {if (x < 0) print('-'), x = -x;for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;while (cnt) print((char)buf[cnt--]);}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
const int N = 50005;
int n, m, num, tot1[N], tot2[N], h[N], pre[N<<1], e[N<<1];
bool vis[N];
char a[N], s[N];
inline void add(int x, int y){ e[++num]=y, pre[num]=h[x], h[x]=num;}
struct sam{int last, cnt, b[N], str[N], t[N<<1], lazy[N<<1], q[N<<1], siz[N<<1], len[N<<1], fa[N<<1], ch[N<<1][26], son[N<<1][26];bool isl[N<<1];inline sam(){ last=cnt=1;}inline void ins(int c){int p=last, np=++cnt;last=np, str[len[np]=len[p]+1]=c, t[np]=len[np];while(p && !ch[p][c]) ch[p][c]=np, p=fa[p];if(!p) fa[np]=1;else{int q=ch[p][c];if(len[q]==len[p]+1) fa[np]=q;else{int nq=++cnt;len[nq]=len[p]+1, memcpy(ch[nq], ch[q], sizeof ch[0]);t[nq]=t[q], fa[nq]=fa[q], fa[q]=fa[np]=nq;while(ch[p][c]==q) ch[p][c]=nq, p=fa[p];}}siz[np]=isl[np]=1;}inline void init(){rep(i, 1, cnt) ++b[len[i]];rep(i, 1, m) b[i]+=b[i-1];rep(i, 1, cnt) q[b[len[i]]--]=i;for(int i=cnt; i>1; --i) son[fa[q[i]]][str[t[q[i]]-len[fa[q[i]]]]]=q[i], siz[fa[q[i]]]+=siz[q[i]];}inline void trans(int &p, int c){ p=ch[p][c];}void dfs5(int u, int fa, int p, int l){if(!p) return;if(l==len[p]) p=son[p][a[u]];else if(str[t[p]-l]!=a[u]) p=0;if(!p) return;++lazy[p];travel(i, u) if(e[i]!=fa && !vis[e[i]]) dfs5(e[i], u, p, l+1);}inline void work(int *tot){rep(i, 2, cnt) lazy[q[i]]+=lazy[fa[q[i]]];rep(i, 1, cnt) if(isl[i]) tot[len[i]]=lazy[i];memset(lazy, 0, sizeof lazy);}
}sam1, sam2;
ll ans;
int root, ctr, Siz, mn, top, lim, siz[N], stk[N];
void dfs1(int u, int fa=0){siz[u]=1;int mx=0;travel(i, u) if(!vis[e[i]] && e[i]!=fa) dfs1(e[i], u), siz[u]+=siz[e[i]], mx=max(mx, siz[e[i]]);mx=max(mx, Siz-siz[u]);if(mx<mn) mn=mx, ctr=u;
}
inline int getctr(int u, int size){ return Siz=mn=size, dfs1(u), ctr;}
void dfs3(int u, int p, int W, int fa=0){sam1.trans(p, a[u]);if(p){ans+=W*sam1.siz[p];travel(i, u) if(!vis[e[i]] && e[i]!=fa) dfs3(e[i], p, W, u);}
}
void dfs2(int u, int fa=0){stk[++top]=a[u];int p=1;for(int i=top; i; --i) sam1.trans(p, stk[i]);dfs3(root, p, -1);travel(i, u) if(e[i]!=fa && !vis[e[i]]) dfs2(e[i], u);--top;
}
void dfs4(int u, int fa=0){dfs3(u, 1, 1);travel(i, u) if(!vis[e[i]] && e[i]!=fa) dfs4(e[i], u);
}
void solve(int u, int fa=0, int v=0){int size=Siz;if(size<=lim){if(fa){stk[top=1]=a[fa];root=v, dfs2(v);}dfs4(u);}else{if(fa){sam1.dfs5(v, fa, sam1.son[1][a[fa]], 1), sam2.dfs5(v, fa, sam2.son[1][a[fa]], 1);sam1.work(tot1), sam2.work(tot2);rep(i, 1, m) ans-=tot1[i]*tot2[m-i+1];}sam1.dfs5(u, 0, 1, 0), sam2.dfs5(u, 0, 1, 0);sam1.work(tot1), sam2.work(tot2);rep(i, 1, m) ans+=tot1[i]*tot2[m-i+1];vis[u]=1;travel(i, u) if(!vis[e[i]]) solve(getctr(e[i], siz[e[i]]<siz[u]?siz[e[i]]:size-siz[u]), u, e[i]);}
}
int main() {read(n), read(m);lim=sqrt(m);rep(i, 2, n){static int x, y;read(x), read(y);add(x, y), add(y, x);}while(isspace(a[1]=read()));rep(i, 2, n) a[i]=read();rep(i, 1, n) a[i]-='a';while(isspace(s[1]=read()));rep(i, 2, m) s[i]=read();rep(i, 1, m) sam1.ins(s[i]-='a');for(int i=m; i; --i) sam2.ins(s[i]);sam1.init(), sam2.init();solve(getctr(1, n));return printf("%lld", ans), 0;
}