Luogu4218 [CTSC2010]珠宝商
Luogu4218 [CTSC2010]珠宝商
\(SAM\)+点分治+根号分治
又被\(SAM\)神仙题教育了一顿。。。
字符串上树了，看起来很不可做的样子。由于本题需要维护的是所有链的信息，容易想到点分治。
既然要使用点分治，不可避免地要面临统计子树信息和两条链合并的难题。
比如当前连通块的重心为\(x\)，要统计信息并合并\(u \rightarrow x \rightarrow v\)，如何操作呢？
我们统计答案时，必然需要把信息集中在合并点处，也就是说，链\(u \rightarrow x\)对应模式串\(T\)的区间\([l,i]\)，而链\(x \rightarrow v\)对应模式串\(T\)的区间\([i,r]\)，那么我们可以在\(i\)处统计贡献。
考虑\(SAM\)上只有后缀会拥有一个指定的节点，我们先考虑\(u \rightarrow x\)的一部分，它将作为\([l,i]\)出现，而节点\(x\)将作为\(i\)位置。
发现我们遍历子树时，不是我们习惯的向后插入字符，而是向前插入字符。
但是这仅仅是查找而已，强大的\(SAM\)可以完成这个任务。具体来说，我们考虑原串一定是新串的后缀，那么对应于\(parent\)树上，原串所在位置\(p\)与新串所在位置相同或是它的父亲。当长度小于\(len_p\)时，要么失配（只要记录\(p\)的任意一个后缀位置即可），要么长度\(+1\)；而长度大于\(len_p\)时，它可能失配，也可能到达它的其中一个儿子节点。我们需要建立一种全新的转移边，表示一个节点到达最大长度之后加入字符\(c\)会到达哪个儿子，可以在建\(SAM\)时预处理（不明白可以看代码，很容易理解）。
而链\(x \rightarrow v\)只是\(S\)的反串\(S^r\)上同样的操作而已。
接下来，就是合并答案了。
对于\(i\)位置，我们会在\(S\)的\(SAM\)上记录其后缀，在\(S^r\)的\(SAM\)上记录其前缀，我们发现只要是\(i\)的前缀、后缀都可以记录入答案，也就是\(i\)所在的节点以及其\(parent\)树上的祖先，我们可以最后一次处理统计答案，一次计算时间复杂度为\(O(m+size)\)。
但是点分治需要有去重，直接去重一次时间复杂度仍然是\(O(m+size)\)。
我们一分析复杂度\(O(n \log n + nm)\)，白干了？？？
根号分治就出场了。
除了\(O(m+size)\)的统计算法，我们显然还有\(O(size^2)\)的暴力。
我们设定一个阈值\(B=\sqrt n\)，使得在\(\le B\)时跑暴力，\(>B\)时跑\(O(m+size)\)的算法。
由于点分治一层子树大小必然比上一层至少减半，那么我们计算一下，在最劣情况下，点分树呈现二叉树的形式，第\(k\)层的子树大小不会超过\(\frac{n}{2^k}\)，在本题数据范围中第\(8\)层的数据已经小于\(\sqrt n\)了，这时候子树个数上限大约是\(2^8=256\)，可以近似看成\(\sqrt n\)了。所以这一部分的复杂度为\(O(n \sqrt n)\)。
对于大子树，可以把小子树看成它们的叶子节点，那么大子树个数与小子树个数同阶，这一部分时间复杂度为\(O(m \sqrt n)\)。
现在我们的去重仍然存在时间复杂度问题。
我们需要观察重复的是哪一部分，也就是说原来的\(u \rightarrow x \rightarrow v\)的\(u,v\)在同一子树中。
同样进行根号分治，对于大子树仍然执行\(O(m+size)\)算法。而小子树可以\(O(size)\)枚举子树中一个点，记录其到达当前点分到的重心节点的路径，然后返回同一子树中进行暴力统计，时间复杂度为\(O(size^2)\)。
进行平衡后，时间复杂度为\(O(n \sqrt n)\)，可以轻松通过此题。
\(Code:\)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define ll long long
#define N 50005
using namespace std;
const int INF=1000000007;
char s[N],t[N];
int n,m,x,y,block,rc[N],c[N];
ll ans=0;
struct edge
{
int nxt,v;
edge (int Nxt=0,int V=0)
{
nxt=Nxt,v=V;
}
}e[N << 1];
int tot,fr[N];
int lsz,rt,rtsz,sz[N],f[N],q[N];
bool vis[N];
void add(int x,int y)
{
++tot;
e[tot]=edge(fr[x],y),fr[x]=tot;
}
struct SAM
{
int cnt=1,lst=1,tr[N << 1][26],pre[N << 1],len[N << 1],R[N << 1];
int g[N << 1],a[N << 1],loc[N],ct[N << 1],son[N << 1][26];
char t[N];
void ins(int c,int I)
{
int p=lst,np=++cnt;
loc[I]=lst=np,len[np]=len[p]+1,R[np]=I,++ct[np];
for (;p && !tr[p][c];p=pre[p])
tr[p][c]=np;
if (!p)
pre[np]=1; else
{
int q=tr[p][c];
if (len[p]+1==len[q])
pre[np]=q; else
{
int g=++cnt;
memcpy(tr[g],tr[q],sizeof(tr[q]));
len[g]=len[p]+1,pre[g]=pre[q],R[g]=R[q];
for (;p && tr[p][c]==q;p=pre[p])
tr[p][c]=g;
pre[q]=pre[np]=g;
}
}
}
void build()
{
for (int i=1;i<=m;++i)
ins(t[i]-'a',i);
memset(c,0,(m+1)*sizeof(int));
for (int i=1;i<=cnt;++i)
++c[len[i]];
for (int i=1;i<=m;++i)
c[i]+=c[i-1];
for (int i=1;i<=cnt;++i)
a[c[len[i]]--]=i;
for (int i=cnt;i>=2;--i)
{
int u=a[i];
ct[pre[u]]+=ct[u];
if (pre[u]!=1)
son[pre[u]][t[R[u]-len[pre[u]]]-'a']=u;
}
}
int nxt(int u,int L,char c)
{
if (len[u]>=L)
return (t[R[u]-L+1]==c)?u:0;
return son[u][c-'a'];
}
void clear()
{
memset(g,0,(cnt+1)*sizeof(int));
}
void dfs(int u,int F,int Len,int st)
{
if (!st)
return;
++g[st];
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (v==F || vis[v])
continue;
dfs(v,u,Len+1,nxt(st,Len+1,s[v]));
}
}
void calc()
{
for (int i=2;i<=cnt;++i)
g[a[i]]+=g[pre[a[i]]];
}
}s1,s2;
void findrt(int u,int F,int rn)
{
int mx=-1;
sz[u]=1;
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (v==F || vis[v])
continue;
findrt(v,u,rn);
sz[u]+=sz[v],mx=max(mx,sz[v]);
}
mx=max(mx,rn-sz[u]);
if (mx<rtsz)
rtsz=mx,rt=u;
}
void getrt(int u,int rn)
{
rtsz=INF,findrt(u,0,rn);
}
void dfs1(int u,int F)
{
q[++q[0]]=u;
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (v==F || vis[v])
continue;
f[v]=u;
dfs1(v,u);
}
}
void dfs2(int u,int F,int st,int t)
{
if (!st)
return;
ans+=t*s1.ct[st];
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (v==F || vis[v])
continue;
dfs2(v,u,s1.tr[st][rc[v]],t);
}
}
void calc(int u,int c,int t)
{
s1.clear(),s2.clear();
if (t==1)
{
s1.dfs(u,0,1,s1.tr[1][rc[u]]);
s2.dfs(u,0,1,s2.tr[1][rc[u]]);
} else
{
s1.dfs(u,0,2,s1.nxt(s1.tr[1][c],2,s[u]));
s2.dfs(u,0,2,s2.nxt(s2.tr[1][c],2,s[u]));
}
s1.calc(),s2.calc();
for (int i=1;i<=m;++i)
ans+=(ll)t*s1.g[s1.loc[i]]*s2.g[s2.loc[m-i+1]];
}
void calc2(int u,int rt)
{
q[0]=0,f[u]=rt,dfs1(u,0);
for (int i=1;i<=q[0];++i)
{
int t=q[i],st=1;
while (t!=rt)
st=s1.tr[st][rc[t]],t=f[t];
st=s1.tr[st][rc[t]],st=s1.tr[st][rc[u]];
dfs2(u,0,st,-1);
}
}
void solve(int u)
{
if (lsz<=block)
{
q[0]=0,dfs1(u,0);
for (int i=1;i<=q[0];++i)
dfs2(q[i],0,s1.tr[1][rc[q[i]]],1);
return;
}
int tsz=lsz;
vis[u]=true;
calc(u,1,1);
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (vis[v])
continue;
int ts=(sz[u]<sz[v])?tsz-sz[u]:sz[v];
if (ts>block)
calc(v,rc[u],-1); else
calc2(v,u);
}
for (int i=fr[u];i;i=e[i].nxt)
{
int v=e[i].v;
if (vis[v])
continue;
lsz=(sz[u]<sz[v])?tsz-sz[u]:sz[v];
getrt(v,lsz);
solve(rt);
}
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<n;++i)
{
scanf("%d%d",&x,&y);
add(x,y),add(y,x);
}
scanf("%s%s",s+1,t+1);
for (int i=1;i<=n;++i)
rc[i]=s[i]-'a';
block=(int)sqrt(n);
for (int i=1;i<=m;++i)
s1.t[i]=t[i],s2.t[i]=t[m-i+1];
s1.build(),s2.build();
lsz=n,getrt(1,n);
solve(rt);
printf("%lld\n",ans);
return 0;
}
