题解-Codeforces710F String Set Queries

咕了好久没更博客，最近得知可以去冬眠营玩耍，还可以搭顺风车回广州过年

（最近做到的比较有意思的题目：bzoj3958、hihocoder1419）

Problem

Codeforces-710F--洛谷提交入口

题目概要：维护一个字符串集合，要求支持：加字符串、删字符串和查询当前所有已加入且未被删除的字符串在给出模板串中出现的次数（操作数&字符串总长\(\leq 3\times 10^5\)）

Solution

挺有意思的一道题

看到多串匹配就猜测是AC自动机，然后动态加串删串不好处理

就将加入和删除维护两份，每份只需要维护加入即可，最后处理答案就在加入部分中匹配数减去删除部分中的匹配数（就像那个维护删除堆的套路）

（然后就可以分块了……一些短串就直接暴力重建AC自动机，而对于长串就处理出kmp数组直接kmp）

但是这个想法太惊悚了，不敢尝试

于是乎就有了二项堆的思想：维护二项堆核心思想就是二进制分组（第\(i\)个堆拥有\(2^i\)个元素，第\(i\)个堆可以由两个第\(i-1\)个堆合并而成）

类似的，这里可以将堆换为AC自动机：\(i\)号AC自动机维护\(2^i\)个串，若有两个\(i\)号AC自动机则合并成一个\(i+1\)号AC自动机，合并是拆除原AC自动机，然后暴力合并）

即使这样暴力，但每个串只会被合并\(log_2m\)次，而且每次查询只要在\(log_2m\)个AC自动机中查询即可，复杂度为AC自动机的复杂度再带个\(log_m\)

Code

注意内存回收，还有合并的时候可以直接trie树合并（但前提是不能将fail指针作为儿子以求速度）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

inline void read(int&x){
	char c11=getchar();x=0;while(!isdigit(c11))c11=getchar();
	while(isdigit(c11))x=x*10+c11-'0',c11=getchar();
}

const int N=601000;
struct node{
	int ch[26],fail,end,sum;
	inline void clear(){
		for(int i=0;i<26;++i)ch[i]=0;
		fail=end=sum=0;
	}
}p[N];

struct RECYCLE{
	int stk[N],top,tot;
	RECYCLE(){top=tot=0;}
	inline int newnode(){return top?stk[top--]:++tot;}
	inline void del(int x){stk[++top]=x;p[x].clear();}
}re;

struct AC_Auto{
	int rt;
	void clear(){p[rt=re.newnode()].fail=0;}
	inline void ins(char*a){
		int nw=rt;
		for(int i=0,x;a[i];++i){
			x=a[i]-'a';
			if(!p[nw].ch[x])p[nw].ch[x]=re.newnode();
			nw=p[nw].ch[x];
		}++p[nw].end;
	}
	void build(){
		static int q[N],he,ta;
		q[he=ta=1]=rt;
		while(he<=ta){
			int x=q[he++];
			for(int i=0,c,t;i<26;++i){
				c=p[x].ch[i],t=p[x].fail;
				if(!c)continue;
				q[++ta]=c;
				while(t && !p[t].ch[i])t = p[t].fail;
				if(t&&p[t].ch[i]!=c)p[c].fail = p[t].ch[i];
				else p[c].fail=rt;
				p[c].sum = p[c].end + p[p[c].fail].sum;
			}
		}
	}

	ll scan(char*s){
		int nw=rt;ll res=0;
		for(int i=0,x;s[i];++i){
			x=s[i]-'a';
			while(nw!=rt&&!p[nw].ch[x])nw=p[nw].fail;
			if(p[nw].ch[x])nw=p[nw].ch[x];
			res+=p[nw].sum;
		}return res;
	}

	void merge(int&x,int y){
		if(!y)return ;
		if(!x)x=re.newnode();
		for(int i=0;i<26;++i)
			merge(p[x].ch[i],p[y].ch[i]);
		p[x].end+=p[y].end;
		re.del(y);
	}
};

struct NODE{
	int tot,num[20];
	AC_Auto ac[20];
	NODE(){tot=0;memset(num,0,sizeof num);}
	void INS(char*a){
		num[++tot]=1;
		ac[tot].clear();
		ac[tot].ins(a);
		while(tot>1)
			if(num[tot]==num[tot-1]){
				ac[tot-1].merge(ac[tot-1].rt,ac[tot].rt);
				num[tot-1]+=num[tot];
				num[tot]=0,--tot;
			}
			else break;
		ac[tot].build();
	}
	ll MAT(char*a){
		ll res=0ll;
		for(int i=1;i<=tot;++i)
			res+=ac[i].scan(a);
		return res;
	}
}A,B;

char s[N];

int main(){
	int m,op;read(m);
	while(m--){
		read(op);scanf("%s",s);
		if(op==1)A.INS(s);
		else if(op==2)B.INS(s);
		else printf("%lld\n",A.MAT(s)-B.MAT(s)),fflush(stdout);
	}return 0;
}