杂题

1

CF446D
题意：给定 500 个点的图，上面有不多于 100 个标记点，其中 n 一定是标记点。求从 1 号点出发，随机游走到的第 K 个点恰好是 n 的概率。随机游走定义为每次在一个点等概率选择一条边走出去。$K\le 10^9$

如果我们求出 $p_{i,j}$ 表示从 i 出发第一个到达的关键点是 j 的概率，其中 i，j 都是关键点。那我们就可以矩乘了，转移矩阵就是这个 p。为了求 p，我们枚举一个 j，可以高斯消元出所有 $p_{i,j}$，复杂度 n⁴。如果我们钦定不等于 j 的关键点 k 的 p 等于 0，发现高消的矩阵每次都不会变，只有最右一列常数项有变化。这样我们求出系数矩阵的逆矩阵，每次用 n² 的时间乘上一个向量即可。时间复杂度 $O(n^3+n^3\log n)$。注意求逆矩阵的时候行变换要做完整。

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
using namespace std;
const int N=510;
struct edge {
	int to,next;
}ed[200010];
struct Matrix {
	double a[510][510]; int n,m;
	Matrix (int _n=0,int _m=0) {n=_n,m=_m;}
	void clr() {memset(a,0,sizeof(a));}
};
int sz,head[N],tag[N],ind[N],n,m,K,cnt,du[N];
Matrix operator * (Matrix a,Matrix b)
{
	Matrix ans(a.n,b.m);
	for(int i=1;i<=a.n;i++)
	{
		for(int j=1;j<=b.m;j++)
		{
			double tmp=0;
			for(int k=1;k<=a.m;k++) tmp+=a.a[i][k]*b.a[k][j];
			ans.a[i][j]=tmp;
		}
	}
	return ans;
}
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
void add_edge(int from,int to)
{
	ed[++sz].to=to,du[to]++;
	ed[sz].next=head[from];
	head[from]=sz;
}
Matrix inv(Matrix a)
{
	Matrix b(a.n,a.m); b.clr();
	Matrix z=a;
	for(int i=1;i<=n;i++) b.a[i][i]=1;
	for(int i=1;i<=n;i++)
	{
		int ind=i; for(int j=i+1;j<=n;j++) if(fabs(a.a[j][i])>fabs(a.a[ind][i])) ind=j;
		if(ind^i) for(int j=1;j<=n;j++) swap(a.a[i][j],a.a[ind][j]),swap(b.a[i][j],b.a[ind][j]);
		double t=a.a[i][i]; for(int j=1;j<=n;j++) a.a[i][j]/=t,b.a[i][j]/=t;
		for(int j=1;j<=n;j++) if(i^j)
		{
			double t=a.a[j][i];
			for(int k=1;k<=n;k++) a.a[j][k]-=t*a.a[i][k],b.a[j][k]-=t*b.a[i][k];
		}
	}
	return b;
}
Matrix qpow(Matrix ans,int b)
{
	Matrix base=ans; b--;
	while(b)
	{
		if(b&1) ans=ans*base;
		base=base*base;
		b>>=1;
	}
	return ans;
}
int main()
{
	n=read(),m=read(),K=read()-1;
	for(int i=1;i<=n;i++)
	{
		tag[i]=read();
		if(tag[i]) ind[i]=++cnt;
	}
	for(int i=1;i<=m;i++) 
	{
		int u=read(),v=read();
		add_edge(u,v),add_edge(v,u);
	}
	Matrix a(n,n);
	for(int u=1;u<=n;u++)
	{
		if(tag[u]) a.a[u][u]=1;
		else 
		{
			for(int i=head[u];i;i=ed[i].next)
			{
				int v=ed[i].to;
				a.a[u][v]+=1.0/du[u];
			}
			a.a[u][u]=-1;
		}
	}
	Matrix trans(n,n),tmp(n,1),z(n,1),p(cnt,cnt),ans(cnt,1);
	trans=inv(a);
	for(int i=1;i<=n;i++) if(tag[i])
	{
		for(int j=1;j<=n;j++) tmp.a[j][1]=0;
		tmp.a[i][1]=1;
		z=trans*tmp;
		for(int j=1;j<=n;j++) if(tag[j])
		{
			for(int k=head[j];k;k=ed[k].next)
			{
				int v=ed[k].to;
				p.a[ind[i]][ind[j]]+=z.a[v][1];
			}
			p.a[ind[i]][ind[j]]/=du[j];
		}
		ans.a[ind[i]][1]=z.a[1][1];
	}
	if(K>1) ans=qpow(p,K-1)*ans;
	printf("%.10lf",ans.a[ind[n]][1]);
	return 0;
}

2

BZOJ4664 Count
题意：给出 n 个数，把他们任意排列，定义一个序列的混乱程度为相邻两项差的绝对值。求混乱程度为 L 的方案数。$n\le 100,a_i,L\le 1000$

一个显然的想法是类似 BZOJ4998，发现对于相邻两项一定是大数的贡献为正，小数的贡献为负。可以从小到大把数插进去，维护已经插入的数是连续的几段。每次插入一个数讨论是新建一段还是合并两段还是放在某段的一端，就可以计算这个数的贡献。但是这样复杂度不能接受，因为当前很负的贡献最后可能合法。

观察到贡献是可以拆开计算的。$h_r-h_l={\sum }_{l<i\le r}{h}_i-h_{i-1}$，按照这个贡献的计算方式发现贡献只增不减，就可以只存到 L 了。

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
using namespace std;
const int mod=1e9+7;
int f[2][110][1010][4],h[110];
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
inline void add(int &a,int b) {a+b>=mod?a+=b-mod:a+=b;}
int main()
{
	int n=read(),L=read(),now=0;
	for(int i=1;i<=n;i++) h[i]=read();
	sort(h+1,h+n+1);
	f[now][1][0][0]=1;
	if(n>1) f[now][1][0][1]=2;	//f[i][j][k][0/1/2] 放了前i个数，形成连续j段，混乱度为k，两端放了l个的方案数 
	else f[now][1][0][2]=1;
	for(int i=1;i<n;i++,now^=1)
	{
		memset(f[now^1],0,sizeof(f[now^1]));
		for(int j=1;j<=i;j++)
		{
			for(int k=0;k<=L;k++)
			{
				for(int l=0;l<=2;l++) if(f[now][j][k][l])
				{
					ll t=f[now][j][k][l]; int nxt=min(L+1,k+(h[i+1]-h[i])*(2*j-l));
					
					if(j+1-l>0) add(f[now^1][j+1][nxt][l],t*(j+1-l)%mod);
					add(f[now^1][j+1][nxt][l+1],t*(2-l)%mod);
					add(f[now^1][j][nxt][l],t*(j*2-l)%mod);
					add(f[now^1][j][nxt][l+1],t*(2-l)%mod);
					if(j>1) add(f[now^1][j-1][nxt][l],t*(j-1)%mod);
				}
			}
		}
	}
	int ans=0;
	for(int i=0;i<=L;i++) ans=(ans+f[now][1][i][2])%mod;
	cout<<ans;
	return 0;
}

3

定义字符串 s 的子串是 s 的重复子串当且仅当这个子串在 s 里出现了两次（不要求不相交）。给定 s，每次询问给出 l,r，求 s[l…r] 的最长重复子串的长度。

首先有一个 LCT 的做法。从左到右扫描线，在后缀树上每个点维护上一次出现的位置，并且用线段树维护每个左端点的答案。右端点移动一个位置，access 的时候更新答案即可。

说一下后缀树上 right 集合并的做法。如果二分了一个答案，问题就变成了在一个区间内能不能找到两个点在后缀树上的 lca 深度 >=mid，显然我们只需要关注 height>=mid 的那些连续段里在原串位置相邻的点对即可。而 height 相当于后缀树上 lca，因此我们可以在后缀树上启发式合并 right，这样会产生 nlogn 个点对，剩下的用主席树维护即可。

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
#define pb push_back
using namespace std;
const int N=200010;
typedef pair<int,int> P;
int rt[N],l[N],fa[N],ch[N][26],lst=1,cnt=1,c[N];
char s[N];
vector <P> d[N];
set <int> ss[N];
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
void extend(int c,int x)
{
	int np=++cnt,p=lst;
	l[np]=l[p]+1,lst=np;
	for(;p&&!ch[p][c];p=fa[p]) ch[p][c]=np;
	if(!p) fa[np]=1;
	else
	{
		int q=ch[p][c];
		if(l[q]==l[p]+1) fa[np]=q;
		else
		{
			int nq=++cnt;
			l[nq]=l[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fa[nq]=fa[q],fa[np]=fa[q]=nq;
			for(;ch[p][c]==q;p=fa[p]) ch[p][c]=nq;
		}
	}
	ss[lst].insert(x);
}
namespace Segment
{
	int tot,ls[N*400],rs[N*400],Min[N*400];
	void modify(int pre,int &root,int l,int r,int x,int y)
	{
		root=++tot,Min[root]=1e9;
		if(l==r) {Min[root]=min(Min[root],y); return;}
		int mid=l+r>>1;
		if(x<=mid) modify(ls[pre],ls[root],l,mid,x,y),rs[root]=rs[pre];
		else modify(rs[pre],rs[root],mid+1,r,x,y),ls[root]=ls[pre];
		Min[root]=min(Min[ls[root]],Min[rs[root]]);
	}
	int query(int root,int l,int r,int x,int y)
	{
		if(x<=l&&y>=r) return Min[root];
		int mid=l+r>>1,ans=1e9;
		if(x<=mid) ans=query(ls[root],l,mid,x,y);
		if(y>mid) ans=min(ans,query(rs[root],mid+1,r,x,y));
		return ans;
	}
}
using namespace Segment;
bool cmp(int a,int b) {return l[a]>l[b];}
int main()
{
	int n=read(),m=read(); scanf("%s",s+1); Min[0]=1e9;
	for(int i=1;i<=n;i++) extend(s[i]-'a',i);
	for(int i=1;i<=cnt;i++) ss[i].insert(-1e9),ss[i].insert(1e9);
	for(int i=1;i<=cnt;i++) c[i]=i; sort(c+1,c+cnt+1,cmp);
	for(int i=1;i<=cnt;i++)
	{
		int u=c[i],a=fa[u],b=u; if(ss[a].size()<ss[b].size()) swap(ss[a],ss[b]);
		while(!ss[b].empty())
		{
			int x=*ss[b].begin(); ss[b].erase(ss[b].begin());
			if(x<0||x>n) continue;
			int k=*--ss[a].lower_bound(x),z=*ss[a].lower_bound(x);
			if(k>=1&&k<=n) d[l[fa[u]]].pb(P(k,x));
			if(z>=1&&z<=n) d[l[fa[u]]].pb(P(x,z));
			ss[a].insert(x);
		}
	}
	for(int i=n;i>=1;i--)
	{
		rt[i]=rt[i+1];
		for(int j=0;j<d[i].size();j++) modify(rt[i],rt[i],1,n,d[i][j].fir,d[i][j].sec);
	}
	for(int i=1;i<=m;i++)
	{
		int x=read(),y=read(),l=1,r=n,ans=0;
		while(l<=r)
		{
			int mid=l+r>>1;
			if(query(rt[mid],1,n,x+mid-1,y)<=y) l=mid+1,ans=mid;
			else r=mid-1;
		}
		cout<<ans<<'\n';
	}
	return 0;
}

4

BZOJ4762 最小集合
题意：定义一个非空集合是合法的，当且仅当它满足以下两个条件。
1.集合内所有元素and和为0
2.它的非空子集中仅有它本身满足1
给出一个集合S，求它的合法非空子集数。$n\le 1000,a_i\le 1024$

第二个条件等价于删去集合里的每个元素的 and 都不为 0，相当于有 |S| 个限制，那么我们就可以容斥。枚举一个集合不满足条件，答案等于 ${\sum }_S[f(S)=0]{\sum }_{T\subseteq S}[{\text{OR}}_{x\in T}f(S\oplus x)=0](-1{)}^{|T|}$。然后就可以 DP 了，设 f[i][S][T] 表示考虑了前 i 个数，选出一些数 and 为 S，去掉每个数的 f 的或为 T 的方案数（带上-1）。答案是 f[n][0][0]。

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
using namespace std;
const int mod=1e9+7;
int f[2][1030][1030],a[1010];
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
inline void add(int &a,int b) {a+b>=mod?a+=b-mod:a+=b;}
int main()
{
	int n=read(),now=0,U=1023;
	for(int i=1;i<=n;i++) a[i]=read();
	f[now][1023][1023]=1;
	for(int i=0;i<n;i++,now^=1)
	{
		for(int S=0;S<=U;S++)
		{
			for(int T=S;T<=U;T=(T+1)|S)
			{
				f[now^1][S][T]=0;
			}
		}
		int x=a[i+1];
		for(int S=0;S<=U;S++)
		{
			for(int T=S;T<=U;T=(T+1)|S)
			{
				int t=f[now][S][T];
				add(f[now^1][S][T],t);
				add(f[now^1][S&x][T&x],t);
				add(f[now^1][S&x][S|(T&x)],mod-t);
			}
		}
	}
	cout<<f[now][0][0];
	return 0;
}

5

给定一棵树，求 ${\sum }_{i=1}^n{\sum }_{j=1}^{n}dis(i,j)\cdot \phi (ij)$。$n\le 10^5$

众所周知，$\phi (ij)=\frac{\phi (i)\cdot \phi (j)}{\phi (\gcd (i,j))}\cdot \gcd (i,j)$。证明的话按照容斥的式子展开即可。最后化简出来：
$$ans=\sum _{d=1}^n\frac{d}{\phi (d)}\sum _{e=1}^{n/d}\mu (e)g(de)$$

其中 $g(n)={\sum }_{n|i}{\sum }_{n|j}dis(i,j)\cdot \phi (i)\cdot \phi (j)$。g 显然可以通过虚树上乱搞得到。

（代码稍微压了压）

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
using namespace std;
const int N=200010,mod=998244353;
struct edge {int to,next;} ed[N<<1];
int sz,head[N],deep[N],seq[N],f[N][20],g[N],phi[N],st[N],top,sigma,cnt,val[N],mu[N],np[N],tim,A[N],B[N],vis[N],prime[N],gg[N],a[N],inv[N],n,size[N];
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
void add1(int from,int to)
{
	ed[++sz]=(edge){to,head[from]};
	head[from]=sz;
}
void dfs0(int u,int ff)
{
	deep[u]=deep[ff]+1; seq[A[u]=++tim]=u;
	for(int i=head[u];i;i=ed[i].next)
	{
		int v=ed[i].to; if(v==ff) continue;
		dfs0(v,u),seq[++tim]=u;
	}	B[u]=tim;
}
void pre(int n)
{
	phi[1]=1,mu[1]=1;
	for(int i=2;i<=n;i++)
	{
		if(!np[i]) prime[++cnt]=i,phi[i]=i-1,mu[i]=-1;
		for(int j=1;j<=cnt&&i*prime[j]<=n;j++)
		{
			np[i*prime[j]]=1;
			if(i%prime[j]==0) {phi[i*prime[j]]=phi[i]*prime[j];break;}
			phi[i*prime[j]]=phi[i]*(prime[j]-1),mu[i*prime[j]]=-mu[i];
		}
	}
}
int Lca(int x,int y)
{
	x=A[x],y=A[y]; if(x>y) swap(x,y); int k=gg[y-x+1];
	return deep[f[x][k]]<=deep[f[y-(1<<k)+1][k]]?f[x][k]:f[y-(1<<k)+1][k];
}
bool cmp(int a,int b) {return A[a]<A[b];}
ll solve()
{
	sort(a+1,a+cnt+1,cmp); ll ans=0;
	for(int i=cnt,t;i>1;i--) if(!vis[t=Lca(a[i],a[i-1])]) vis[t]=2,a[++cnt]=t;
	sort(a+1,a+cnt+1,cmp); st[top=1]=a[1];
	for(int i=2;i<=cnt;i++)
	{
		while(top&&(A[a[i]]<A[st[top]]||A[a[i]]>B[st[top]])) (size[st[top-1]]+=size[st[top]])%=mod,ans=(ans+1ll*val[top]*size[st[top]]%mod*(sigma-size[st[top]]))%mod,top--;
		st[++top]=a[i],val[top]=deep[a[i]]-deep[st[top-1]];
	}
	while(top) (size[st[top-1]]+=size[st[top]])%=mod,ans=(ans+1ll*val[top]*size[st[top]]%mod*(sigma-size[st[top]]))%mod,top--;
	for(int i=1;i<=cnt;i++) vis[a[i]]=size[a[i]]=val[i]=0;
	return ans;
}
int main()
{
	n=read();int ans=0; for(int i=1,u,v;i<n;i++,u=read(),v=read(),add1(u,v),add1(v,u)); pre(n),dfs0(1,0);
	for(int i=2;i<=2*n;i++) gg[i]=gg[i>>1]+1;
	inv[1]=1; for(int i=2;i<=n;i++) inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
	for(int i=1;i<=tim;i++) f[i][0]=seq[i]; 
	for(int j=1;j<=18;j++) for(int i=1;i+(1<<j)-1<=tim;i++) 
		f[i][j]=deep[f[i][j-1]]<=deep[f[i+(1<<j-1)][j-1]]?f[i][j-1]:f[i+(1<<j-1)][j-1];
	for(int i=1;i<=n;i++)
	{
		cnt=sigma=0;
		for(int j=i;j<=n;j+=i) a[++cnt]=j,sigma=(sigma+phi[j])%mod,size[j]=phi[j],vis[j]=1;
		g[i]=2*solve()%mod;
	}
	for(int d=1,t=0;d<=n;ans=(ans+1ll*d*inv[phi[d]]%mod*t)%mod,d++,t=0) for(int e=1;e<=n/d;e++) t=(t+1ll*mu[e]*g[d*e])%mod;
	cout<<(ans%mod+mod)%mod;
	return 0;
}

6

给定一个长度为 n 的字符串 s，有 m 个串 Ai（一开始为空），和一个集合 S（一开始为空），维护三种操作：1.向 S 里添加一个编号 i（i<=m）2.把下标在 S 里的串 Ai 后面同时添加一个读入的字符 c。3.查询 Ai 在 S 里出现了多少次。 $n,q\le 10^5$

假设我们得到了添加字符 c 组成的字符串 T，观察到每个串进出集合一次会在后面添加 T 的一个子串。也就是说如果给出 S+T 的两个子串 A，B，我们能定位到 A+B 的信息，这个题目就做完了。考场上一直在想 SAM 的做法，发现这个问题“匹配”的性质不强。发现匹配 A+B 的后缀一定是字典序一段连续区间，因此我们可以在 sa 上二分。

启示：1.一个串匹配的后缀在 sa 上是一个区间，查询某个串可以在 sa 上二分。

#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
using namespace std;
const int N=1000010;
int sum[N],gg[N],wb[N],pos[N],sa[N],x[N],y[N],xx[N],cnt,f[N][21],rk[N],height[N],lst[N],opt[N],n,m,q,vis[N];
char s[N];
struct node {
	int x,y,len;
	node (int _x=0,int _y=0,int _len=0) {x=_x,y=_y,len=_len;}
	void print()
	{
		if(len==0) puts("0");
		else if(len==-1) puts("0");
		else cout<<sum[y]-sum[x-1]<<'\n';
	}
}ksj[N];
int read()
{
	int x=0,flag=1;char c=getchar();
	while(!isdigit(c)) {if(c=='-') flag=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	return x*flag;
}
void build(int n,int tt)
{
	int m=200,p=0,k=0;
	for(int i=1;i<=n;i++) wb[x[i]=s[i]]++;
	for(int i=1;i<=m;i++) wb[i]+=wb[i-1];
	for(int i=1;i<=n;i++) sa[wb[x[i]]--]=i;
	for(int j=1;p<n;j<<=1,m=p) 
	{
		p=0;
		for(int i=n-j+1;i<=n;i++) y[++p]=i;
		for(int i=1;i<=n;i++) if(sa[i]>j) y[++p]=sa[i]-j;
		for(int i=1;i<=m;i++) wb[i]=0;
		for(int i=1;i<=n;i++) wb[x[y[i]]]++;
		for(int i=1;i<=m;i++) wb[i]+=wb[i-1];
		for(int i=n;i>=1;i--) sa[wb[x[y[i]]]--]=y[i];
		swap(x,y),x[sa[1]]=1;p=1;
		for(int i=2;i<=n;i++) 
		{
			if(y[sa[i]]==y[sa[i-1]]&&y[sa[i]+j]==y[sa[i-1]+j]) x[sa[i]]=p;
			else x[sa[i]]=++p;
		}
	}
	for(int i=1;i<=n;i++) rk[sa[i]]=i;
	for(int i=1;i<=n;i++)
	{
		if(k) k--;
		if(rk[i]==1) continue;
		int j=sa[rk[i]-1];
		while(s[i+k]==s[j+k]) k++;
		height[rk[i]]=k;
	}
	for(int i=1;i<=n;i++) f[i][0]=height[i];
	for(int j=1;j<=20;j++) for(int i=1;i+(1<<j)-1<=n;i++) f[i][j]=min(f[i][j-1],f[i+(1<<j-1)][j-1]); 
	for(int i=1;i<=n;i++) sum[i]=sum[i-1]+(sa[i]<=tt);
}
inline int lcp(int l,int r) 
{
	if(l==r) return 1e9;
	l=rk[l],r=rk[r]; if(l>r) swap(l,r); l++; int k=gg[r-l+1];
	return min(f[l][k],f[r-(1<<k)+1][k]);
}
inline bool xydy(int x,int y,int len) 
{
	int t=lcp(x,y);
	if(t>=len) return 1;
	return s[x+t]<=s[y+t];
}
inline bool dydy(int x,int y,int len)
{
	int t=lcp(x,y);
	if(t>=len) return 1;
	return s[x+t]>=s[y+t];
}
node merge(node a,node b)
{
	if(a.len==-1) return a;
	if(b.len==0) return a;
	int l=a.x,r=a.y,ansl=a.y+1,ansr=a.x-1;
	while(l<=r)
	{
		int mid=l+r>>1;
		if(dydy(sa[mid]+a.len,b.x,b.len)) ansl=mid,r=mid-1;
		else l=mid+1;
	}
	l=a.x,r=a.y;
	while(l<=r)
	{
		int mid=l+r>>1;
		if(xydy(sa[mid]+a.len,b.x,b.len)) ansr=mid,l=mid+1;
		else r=mid-1;
	}
	if(ansl>ansr) return node(0,0,-1);
	return node(ansl,ansr,a.len+b.len);
}
int main()
{
	for(int i=2;i<=1000000;i++) gg[i]=gg[i>>1]+1;
	int id=read(); n=read(),m=read(),q=read(); scanf("%s",s+1); s[n+1]='a'-2; cnt=n+1;
	for(int i=1;i<=q;i++) 
	{
		opt[i]=read(); 
		if(opt[i]!=2) xx[i]=read();
		else 
		{
			char c=getchar(); while(c<'a'||c>'z') c=getchar();
			s[++cnt]=c;
		}
		pos[i]=cnt;
	}
	build(cnt,n);
	s[cnt+1]='a'-1;
	for(int i=1;i<=m;i++) ksj[i]=node(1,cnt,0);
	for(int i=1;i<=q;i++)
	{
		int x=xx[i];
		if(opt[i]==1)
		{
			if(vis[x]) ksj[x]=merge(ksj[x],node(lst[x]+1,0,pos[i]-lst[x]));
			else lst[x]=pos[i];
			vis[x]^=1;
		}
		else if(opt[i]==3)
		{
			if(!vis[x]) ksj[x].print();
			else merge(ksj[x],node(lst[x]+1,0,pos[i]-lst[x])).print();
		}
	}
	return 0;
}