Codeforces 710F - String Set Queries（AC 自动机）

题面传送门

题意：强制在线的 AC 自动机。

\(n,\sum|s|\leq 3\times 10^5\)

如果不是强制在线那此题就是道 sb 题，加了强制在线就不那么 sb 了。

这里介绍两种做法：

1. 根号分治
   
   考虑到 KMP 擅长处理单个字符串匹配的情况，但对于多模式串的情况复杂度就不那么优秀了。
   
   而 AC 自动机擅长处理多模式串匹配的情况，但预处理复杂度是线性的，每加进来一个字符串都预处理一遍复杂度显然吃不消。
   
   考虑将二者结合，设一个临界值 \(B\)，每 \(B\) 个串建一个 AC 自动机。剩余的若干个串暴力跑 KMP。
   
   算下复杂度，最多要在 AC 自动机上匹配 \(\frac{n}{B}\) 次，每次匹配都是 \(|s|\) 的，故 AC 自动机部分的复杂度是 \(\frac{n}{B}\times \sum|s|\)。
   
   再考虑 KMP，单次 KMP 是 \(\mathcal O(n+m)\) 的，每个模式串最多跟 \(B\) 个询问串匹配，而每个询问串也最多跟 \(B\) 个模式串匹配，所以贡献为 \(B\sum|s|\)。
   
   最后是删除操作，众所周知，AC 自动机是不支持删除操作的，但发现一加一减，贡献可以抵消掉，所有我们可以建两个 AC 自动机，一个处理所有 \(1\) 操作加入进来的字符串，一个处理所有 \(2\) 操作删除的字符串，二者相减即可。
   
   总复杂度 \(\mathcal O(\sum|s|(B+\frac{n}{B}))\)，\(3\times 10^5\) \(n\sqrt{n}\) 大约是 \(2\times 10^8\) 级别，理论上是可以的，可惜我没卡过去 qwq。

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define fz(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define ffe(it,v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define fill0(a) memset(a,0,sizeof(a))
#define fill1(a) memset(a,-1,sizeof(a))
#define fillbig(a) memset(a,63,sizeof(a))
#define pb push_back
#define ppb pop_back
#define mp make_pair
template<typename T1,typename T2> void chkmin(T1 &x,T2 y){if(x>y) x=y;}
template<typename T1,typename T2> void chkmax(T1 &x,T2 y){if(x<y) x=y;}
typedef pair<int,int> pii;
typedef long long ll;
template<typename T> void read(T &x){
	char c=getchar();T neg=1;
	while(!isdigit(c)){if(c=='-') neg=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	x*=neg;
}
const int BLK=548;
const int MAXN=3e5+5;
const int ALPHA=26;
char buf[MAXN+5];
string reads(){
	scanf("%s",buf+1);int len=strlen(buf+1);
	string ret;for(int i=1;i<=len;i++) ret+=buf[i];
	return ret;
}
class solver{
public:
	struct ACAM{
		int rt[BLK+5];
		int ch[MAXN+BLK+5][ALPHA+2],fail[MAXN+BLK+5],cnt[MAXN+BLK+5],ncnt=0;
		void insert(int r,string s){
			int cur=r;
			for(int i=0;i<s.size();i++){
				if(!ch[cur][s[i]-'a']) ch[cur][s[i]-'a']=++ncnt;
				cur=ch[cur][s[i]-'a'];
			} cnt[cur]++;
		}
		void getfail(int r){
			queue<int> q;
			for(int i=0;i<ALPHA;i++){
				if(ch[r][i]) q.push(ch[r][i]),fail[ch[r][i]]=r;
				else ch[r][i]=r;
			}
			while(!q.empty()){
				int x=q.front();q.pop();
				for(int i=0;i<ALPHA;i++){
					if(ch[x][i]) fail[ch[x][i]]=ch[fail[x]][i],q.push(ch[x][i]),cnt[ch[x][i]]+=cnt[fail[ch[x][i]]];
					else ch[x][i]=ch[fail[x]][i];
				}
			}
		}
		int query(int r,string s){
			int cur=r,ret=0;
			for(int i=0;i<s.size();i++){
				cur=ch[cur][s[i]-'a'];ret+=cnt[cur];
			} return ret;
		}
	} a;
	int fail[MAXN+5];
	int getkmp(string s,string t){
		int ls=s.size(),lt=t.size();s=" "+s;t=" "+t;
		int pos=0,ret=0;
		for(int i=2;i<=lt;i++){
			while(pos&&t[pos+1]!=t[i]) pos=fail[pos];
			if(t[pos+1]==t[i]) pos++;fail[i]=pos;
		} pos=0;
		for(int i=1;i<=ls;i++){
			while(pos&&t[pos+1]!=s[i]) pos=fail[pos];
			if(t[pos+1]==s[i]) pos++;
			if(pos==lt) ret++;
		} return ret;
	}
	string ss[MAXN+5];
	int num=0,pre=0,cnt=0;
	void insert(string s){
		ss[++num]=s;
		if(num%BLK==0){
			a.rt[++cnt]=++a.ncnt;
			for(int i=pre+1;i<=num;i++) a.insert(a.rt[cnt],ss[i]);
			a.getfail(a.rt[cnt]);pre=num;
		}
	}
	int query(string s){
		int ret=0;
		for(int i=1;i<=cnt;i++) ret+=a.query(a.rt[i],s);
		for(int i=pre+1;i<=num;i++) ret+=getkmp(s,ss[i]);
		return ret;
	}
} s1,s2;
int T;
int main(){
	scanf("%d",&T);
	while(T--){
		int opt;string s;scanf("%d",&opt);s=reads();
		if(opt==1) s1.insert(s);
		else if(opt==2) s2.insert(s);
		else printf("%d\n",s1.query(s)-s2.query(s)),fflush(stdout);
	}
	return 0;
}

1. 二进制分组
   
   感觉这应该是正解吧，本题官方题解给的就这个做法。
   
   还是将加入的字符串分成若干组，每组建一个 AC 自动机。
   
   不过与之前不同的是这次我们按二进制分组，即每组的大小都是 \(2\) 的整数次幂。
   
   那么这玩意儿怎么支持插入操作呢？假设我们插入字符串 \(s\)，我们先建一个只有一个串的 AC 自动机，然后不断与前面的 AC 自动机像启发式合并堆一样合并。最后暴力重构一发。
   
   是不是有点抽象？打个形象的比喻，2048，假设我们现在有 \(23\) 个串，那么会分为 \(4\) 组，大小分别为 \(16,4,2,1\)，此时你再加入一个串，就变为 \(16,4,2,1,1\)，最后两个 \(1\) 合并，变为一个 \(2\)；最后两个 \(2\) 合并，变为一个 \(4\)……以此类推。最后会得到 \(16,8\)。
   
   算下复杂度，暴力重构复杂度是 \(\sum|s|\) 的，而我们每个字符串最多被重构 \(\log n\) 次，故插入的总复杂度是 \(n\log n\) 的，而查询的时候你最多在 \(\log n\) 个 AC 自动机中查询，故总复杂度为 \(n\log n\)，碾压算法 1。
   
   实测 1s，可能因为有个 \(26\) 的常数吧。

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define fz(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define ffe(it,v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define fill0(a) memset(a,0,sizeof(a))
#define fill1(a) memset(a,-1,sizeof(a))
#define fillbig(a) memset(a,63,sizeof(a))
#define pb push_back
#define ppb pop_back
#define mp make_pair
template<typename T1,typename T2> void chkmin(T1 &x,T2 y){if(x>y) x=y;}
template<typename T1,typename T2> void chkmax(T1 &x,T2 y){if(x<y) x=y;}
typedef pair<int,int> pii;
typedef long long ll;
template<typename T> void read(T &x){
	char c=getchar();T neg=1;
	while(!isdigit(c)){if(c=='-') neg=-1;c=getchar();}
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
	x*=neg;
}
const int MAXN=3e5;
const int LOG_N=19;
const int ALPHA=26;
class solver{
public:
	int sz[LOG_N+3],rt[LOG_N+3],cnt=0;
	int oc[MAXN*2+5][ALPHA+2],ch[MAXN*2+5][ALPHA+2],ncnt=0,ed[MAXN*2+5],val[MAXN*2+5],fail[MAXN+5];
	void insert(char *s,int r){
		int len=strlen(s+1),cur=r;
		for(int i=1;i<=len;i++){
			if(!oc[cur][s[i]-'a']) oc[cur][s[i]-'a']=++ncnt;
			cur=oc[cur][s[i]-'a'];
		} ed[cur]++;
	}
	void getfail(int r){
		queue<int> q;
		for(int i=0;i<ALPHA;i++){
			if(oc[r][i]){
				fail[oc[r][i]]=r;q.push(oc[r][i]);
				val[oc[r][i]]=ed[oc[r][i]];ch[r][i]=oc[r][i];
			} else ch[r][i]=r;
		}
		while(!q.empty()){
			int x=q.front();q.pop();
			for(int i=0;i<ALPHA;i++){
				if(oc[x][i]){
					ch[x][i]=oc[x][i];
					fail[oc[x][i]]=ch[fail[x]][i];
					val[oc[x][i]]=val[fail[oc[x][i]]]+ed[oc[x][i]];
					q.push(oc[x][i]);
				} else ch[x][i]=ch[fail[x]][i];
			}
		}
	}
	int merge(int x,int y){
		if(!x||!y) return x+y;
		ed[x]+=ed[y];
		for(int i=0;i<ALPHA;i++) oc[x][i]=merge(oc[x][i],oc[y][i]);
		return x;
	}
	void insert(char *s){
		sz[++cnt]=1;rt[cnt]=++ncnt;insert(s,rt[cnt]);
		while(sz[cnt]==sz[cnt-1]){
			rt[cnt-1]=merge(rt[cnt-1],rt[cnt]);
			sz[cnt-1]<<=1;sz[cnt]=0;cnt--;
		} getfail(rt[cnt]);
	}
	int query(char *s,int r){
		int len=strlen(s+1),cur=r,ret=0;
		for(int i=1;i<=len;i++){
			cur=ch[cur][s[i]-'a'];
			ret+=val[cur];
		} return ret;
	}
	int query(char *s){
		int ret=0;
		for(int i=1;i<=cnt;i++) ret+=query(s,rt[i]);
		return ret;
	}
} s1,s2;
char buf[MAXN+5];
int main(){
	int T;scanf("%d",&T);
	while(T--){
		int opt;scanf("%d%s",&opt,buf+1);
		if(opt==1) s1.insert(buf);
		else if(opt==2) s2.insert(buf);
		else printf("%d\n",s1.query(buf)-s2.query(buf)),fflush(stdout);
	}
	return 0;
}