Codeforces 710F - String Set Queries（AC 自动机）
题意：强制在线的 AC 自动机。
\(n,\sum|s|\leq 3\times 10^5\)
如果不是强制在线那此题就是道 sb 题，加了强制在线就不那么 sb 了。
这里介绍两种做法：
- 根号分治
考虑到 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;
}
- 二进制分组
感觉这应该是正解吧，本题官方题解给的就这个做法。
还是将加入的字符串分成若干组，每组建一个 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;
}
