BZOJ 4545: DQS的trie 後綴自動機 LCT

4545: DQS的trie

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 206  Solved: 76
[Submit][Status][Discuss]

Description

DQS的自家陽臺上種着一棵顆粒飽滿、顏色純正的trie。

DQS的trie非常的奇特，它初始有n0個節點，n0-1條邊，每條邊上有一個字符。並且，它擁有極強的生長力：某個i時刻，某個節點就會新生長出一顆子樹，它擁有si個節點且節點之間的邊上有一個字符，並且新生長出來的子樹也是一個樹結構。然而因爲是新長出來的，根據生活常識可知si必定不會大於i時刻之前的樹的大小。

DQS定義trie的子串爲從根節點（1號節點）往下走到所有節點所構成的字符串的所有的後綴。DQS身爲一個單身doge，常常取出其中一個子串送給妹子，然而他並不希望送給妹子兩個相同的子串，所以他非常關心當前trie的本質不同的子串數目。

DQS有時還會去商店購買子串，若他在商店看上某個子串，他希望得知這個子串是否在自家陽臺的trie上已經出現，若出現則出現了多少次。如果出現了，他就可以直接回家取trie上的子串辣！

然而DQS身爲一個蒟蒻，看着自家陽臺的trie樹一天天在長大，他被如此衆多的節點弄得眼花繚亂，於是他找到了IOI2016Au的你。他會告訴你自家trie樹的成長曆程，他希望你能夠對於每一次詢問都做出正確回覆。

Input

第一行輸入一個整數id，代表測試點編號。

接下來一行輸入一個整數n0，表示初始樹的大小。

接下來n0-1行，每行兩個整數u,v和一個字符c，表示u號節點和v號節點之間有一條邊，邊上的字母爲c。

接下來輸入m表示有m組操作。

對於每一組，第一行輸入一個整數opt。

若opt=1，則是一組詢問，詢問當前trie的本質不同的子串數目是多少。

若opt=2，則後面跟兩個整數rt,si，表示以點rt爲根向下長出一個子樹，大小爲si。

接下來si-1行，每行兩個整數u,v和一個字符c，表示u號節點和v號節點之間有一條邊，邊上的字母爲c。若長出子樹之前當前樹的大小是n，則這si-1點的編號分別爲n+1,n+2…n+si-1。

若opt=3，則是一組詢問，後面輸入一個字符串S，詢問字符串S在當前trie中的出現次數。 

Output

對於每個opt=1或3，輸出一行表示答案。

Sample Input

1
4
1 2 a
1 3 b
2 4 b
6
1
2 2 4
2 5 b
2 6 c
5 7 b
1
3 ab
2 6 3
6 8 a
6 9 b
1

Sample Output

3
7
2
11

【數據範圍及提示】
第一個詢問，本質不同的子串是 a,b,ab。
第二個詢問，本質不同的子串是 a,b,c,ab,ac,bb,abb。
第三個詢問，ab出現次數是 2。
第四個詢問，本質不同的子串是 a,b,c,ab,ac,ca,cb,bb,abb,aca,acb。
opt=1或3時對原樹不做修改，只是詢問。
每次opt=2，會增加si-1個節點，因爲有一個節點是原樹上作爲新樹的根出現的。
數據中，對於鏈的部分分，滿足端點爲根節點，每次新建子樹都從尾部插入。
對於全部數據，保證從始至終每條邊上的字符均爲小寫字母’a’或’b’或’c’。
n是最終樹的大小,N<=100000,M<=100000,Si<=當前樹的大小

好久沒打數據結構了

感覺代碼力逐漸歸零...

本質不同串數 sigma(mx[i]-mx[par[i]])

子串出現次數|Right(ST(S))|

用LCT動態維護後綴自動機

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

typedef long long ll;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=10*x+ch-'0';ch=getchar();}
	return x*f;
}
inline int read_ch()
{char ch=getchar();while(ch<'a'||ch>'c')ch=getchar();return ch-'a';}
void print(ll x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=200100;

ll tot;

struct LCT
{
	int ch[N<<1][2],fa[N<<1];
	ll w[N],tag[N];
	
	ll& operator [](int x){return w[x];}
	
	inline bool isroot(int x)
	{return ch[fa[x]][0]!=x && ch[fa[x]][1]!=x;}
	
	inline void pushdown(int x)
	{
		if(tag[x])
		{
			int ls=ch[x][0],rs=ch[x][1];
			if(ls) w[ls]+=tag[x],tag[ls]+=tag[x];
			if(rs) w[rs]+=tag[x],tag[rs]+=tag[x];
			tag[x]=0;
		}
	}
	
	void getdown(int x)
	{if(!isroot(x)) getdown(fa[x]);pushdown(x);}
	
	void rotate(int x)
	{
		int y=fa[x],z=fa[y],l,r;
		l=(ch[y][1]==x);r=l^1;
		if(!isroot(y)) ch[z][ch[z][1]==y]=x;
		fa[y]=x;fa[x]=z;fa[ch[x][r]]=y;
		ch[y][l]=ch[x][r];ch[x][r]=y;
	}
	
	void splay(int x)
	{
		getdown(x);
		int y,z;
		while(!isroot(x))
		{
			y=fa[x],z=fa[y];
			if(!isroot(y))
			{
				if((ch[y][0]==x)^(ch[z][0]==y)) rotate(x);
				else rotate(y);
			}
			rotate(x);
		}
	}
	
	void access(int x)
	{int t(0);while(x){splay(x);ch[x][1]=t;t=x;x=fa[x];}}
	
	void rever(int x)
	{access(x);splay(x);}
	
	void link(int x,int y)
	{fa[x]=y;rever(y);w[y]+=w[x];tag[y]+=w[x];}
	
	void cut(int x)
	{rever(x);int y=ch[x][0];ch[x][0]=0;fa[y]=0;if(y) w[y]-=w[x],tag[y]-=w[x];}
	
	ll query(int x)
	{splay(x);return w[x];}
};

struct SAM
{
	LCT lct;
	int sz,root;
	int trans[N<<1][3],par[N<<1],mx[N<<1];
	
	SAM(){sz=root=1;}
	
	int insert(int p,int x)
	{
		int np=++sz;
		lct[np]=1;
		mx[np]=mx[p]+1;
		while(p && !trans[p][x])
			trans[p][x]=np,p=par[p];
		if(!p) par[np]=root,tot+=mx[np],lct.link(np,root);
		else
		{
			int q=trans[p][x];
			if(mx[q]==mx[p]+1) par[np]=q,tot+=mx[np]-mx[q],lct.link(np,q);
			else
			{
				int nq=++sz;
				mx[nq]=mx[p]+1;
				tot-=mx[q]-mx[par[q]];
				memcpy(trans[nq],trans[q],sizeof(trans[q]));
				lct.link(nq,par[q]);lct.cut(q);
				par[nq]=par[q];
				lct.link(q,nq);lct.link(np,nq);
				par[q]=par[np]=nq;
				tot+=mx[q]-mx[par[q]]+mx[nq]-mx[par[nq]]+mx[np]-mx[par[np]];
				while(p && trans[p][x]==q)
					trans[p][x]=nq,p=par[p];
			}
		}
		return np;
	}
	
	void solve(char *s)
	{
		int now(1);
		for(int i=1;s[i];++i) now=trans[now][s[i]-'a'];
		if(!now){puts("0");return ;}
		print(lct.query(now));puts("");
	}
}sam;

int last[N],ecnt;
struct EDGE{int to,nt,val;}e[N<<1];
inline void add(int u,int v,int val)
{e[++ecnt]=(EDGE){v,last[u],val};last[u]=ecnt;}

int fa[N],pos[N];

void dfs(int u)
{
	for(int i=last[u],v;i;i=e[i].nt)
		if(fa[u]!=(v=e[i].to))
			fa[v]=u,pos[v]=sam.insert(pos[u],e[i].val),dfs(v);
	last[u]=0;
}

char s[N];

int main()
{freopen("trie5.in","r",stdin);
	register int rt,si,i,u,v,val,Q,opt;
	si=read();si=read();
	for(i=1;i<si;++i)
		u=read(),v=read(),val=read_ch(),
		add(u,v,val),add(v,u,val);
	pos[1]=1;dfs(1);ecnt=0;
	Q=read();
	while(Q--)
	{
		opt=read();
		switch(opt)
		{
			case 1: print(tot);puts("");break;
			case 2:
				rt=read();si=read();
				for(i=1;i<si;++i)
					u=read(),v=read(),val=read_ch(),
					add(u,v,val),add(v,u,val);
					dfs(rt);ecnt=0;
				break;
			case 3: scanf("%s",s+1);sam.solve(s);break;
		}
	}
	return 0;
}