CF710F String Set Queries 三种解法

已于 2022-05-06 17:01:53 修改
阅读量447 收藏 1
点赞数 1
分类专栏： 字符串 文章标签： 算法 数据结构 哈希算法
于 2022-05-04 11:09:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FelFa_1414666/article/details/124567736
版权

本蒟蒻来介绍一下三种方法吧

codeforces 传送门 & 洛谷传送门

Solution 1（暴力&哈希）

第一种方法比较暴力，它的关键点在于：

所有字符串的总长不超过 m = 3 × 1 0 5 m=3\times10^5 m=3×105，不难想到最多有不超过 2 m 2\sqrt m 2m ​ 种不同的长度。大概是不超过 800 的。所以遍历子串时只需要遍历 O ⁡ ( m ) \operatorname O(\sqrt m) O(m ​) 种长度的子串就行了。

根据这一结论，我们可以暴力地维护 O ⁡ ( m ) \operatorname O(\sqrt m) O(m ​) 个 set，里面存所有对应长度字符串的哈希值。

  • 插入&删除：对该长度的 set 进行相应操作。 O ⁡ ( log ⁡ m ) \operatorname O(\log m) O(logm).
  • 询问：暴力的遍历文本串 s s s 所有出现过的长度的子串，用滚动哈希每次去对应 set 里查找哈希值。 O ⁡ ( m log ⁡ m ) \operatorname O(\sqrt m \log m) O(m ​logm).

这样一来就能暴力的解决。注意一下哈希的细节，最好开双哈希避免冲突，因为这题数据很强（真实体会）。

  • 时间复杂度： O ⁡ ( m m log ⁡ m ) \operatorname O(m\sqrt m \log m) O(mm ​logm)

  • 空间复杂度： O ⁡ ( m ) \operatorname O(m) O(m)

Code

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define mp make_pair
#define F first
#define S second
using namespace std;
const ll p1=37,M1=998244353,p2=97,M2=1610612741;//双哈希常数&模数
int q,id[300005],sz[805],num;
ll pw1[300005],pw2[300005];
set<ll> se[805];//存不同长度哈希值的set
int main()
{
	ios::sync_with_stdio(false),cin.tie(nullptr);
	cin>>q;
	memset(id,-1,sizeof(id));
	pw1[0]=pw2[0]=1ll;
	for(int i=1;i<=300000;i++)//预处理哈希常数的幂
	{
		pw1[i]=pw1[i-1]*p1%M1;
		pw2[i]=pw2[i-1]*p2%M2;
	}
	while(q--)
	{
		int tp;string s;
		cin>>tp>>s;
		int len=s.size();
		if (tp==1)
		{
			ll H1=0ll,H2=0ll;
			for(int i=0;i<len;i++)//求双哈希值
			{
				H1=(H1*p1+(ll)(s[i]-'a'))%M1;
				H2=(H2*p2+(ll)(s[i]-'a'))%M2;
			}
			if (id[len]==-1)
			{
				sz[num]=len;
				id[len]=num++;
			}
			se[id[len]].insert(H1<<31|H2);//插入
		}
		else if (tp==2)
		{
			ll H1=0ll,H2=0ll;
			for(int i=0;i<len;i++)
			{
				H1=(H1*p1+(ll)(s[i]-'a'))%M1;
				H2=(H2*p2+(ll)(s[i]-'a'))%M2;
			}
			se[id[len]].erase(H1<<31|H2);//删除
		}
		else
		{
			int n=s.size(),res=0;
			for(int i=0;i<num;i++)//枚举长度
			{
				int len=sz[i];
				if (len>n)
					continue;
				ll H1=0ll,H2=0ll;
				for(int j=0;j<len;j++)
				{
					H1=(H1*p1+(ll)(s[j]-'a'))%M1;
					H2=(H2*p2+(ll)(s[j]-'a'))%M2;
				}
				res+=se[i].count(H1<<31|H2);
				for(int j=len;j<n;j++)//滚动哈希遍历
				{
					H1=(H1*p1+(ll)(s[j]-'a')+M1-pw1[len]*(ll)(s[j-len]-'a')%M1)%M1;
					H2=(H2*p2+(ll)(s[j]-'a')+M2-pw2[len]*(ll)(s[j-len]-'a')%M2)%M2;
					res+=se[i].count(H1<<31|H2);
				}
			}
			cout<<res<<endl;cout.flush();
		}
	}
	return 0;
}

Solution 2 （暴力&trie 树&KMP）

这个方法不是我想的，是另一位巨佬写出来的。当时看的我大为震撼。

他的暴力思路是：将较小的模式串都插入到 trie 树中，较大的模式串单独扔在一遍用 KMP 匹配。

每次查询时，对文本串的所有后缀扔到 trie 里查询子串匹配个数，求总和。再把文本串与所有较大模式串单独 KMP。

看到这个方法能过的时候，我甚至开始思考 AC 自动机解法有什么存在的必要。

Code

#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;

struct Trie{//trie树的构体
public:
	static const int maxn = 300010, maxc = 26;
    int child[maxn][maxc], value[maxn];
	int cnttrie, root;
	
    int newnode(){
        cnttrie++; value[cnttrie] = 0;
        memset(child[cnttrie], -1, sizeof(child[cnttrie]));
        return cnttrie;
    }
    
public:
	void init(){
        cnttrie = root = 0; value[root] = 0;
        memset(child[root], -1, sizeof(child[root]));
    }
    void insert(char *s,int val){
        int x = root;
        for (int i = 0; s[i]; i++){
            int d = s[i] - 'a';
            if (child[x][d] == -1){
                child[x][d] = newnode();
            }
            x = child[x][d];
        }
        value[x] += val;
    }
    int search(char *s){
        int sum = 0, x = root;
        for (int i = 0; s[i]; i++){
            int d = s[i] - 'a';
            if (child[x][d] == -1){
                break;
            }
            x = child[x][d];
            sum += value[x];
        }
        return sum;
    }
}trie;

class KMP{//KMP匹配的板子
private:
	static const int maxn = 300010;
    int next[maxn];
    void getnext(string s, int len){
        memset(next, 0, sizeof(next));
        int i = 0, j = -1; next[0] = -1;
        while (i < len){
            if (j == -1 || s[i] == s[j]){
                next[++i] = ++j;
            }else{
                j = next[j];
            }
        }
    }
public:
    int search(string s, char *str){
        int ret = 0, j = 0;
		int lens = s.size(), lenstr = strlen(str);
        getnext(s, s.size());
        for (int i = 0; i < lenstr; i++){
            while (j > 0 && s[j] != str[i]){
                j = next[j];
            }
            if (s[j] == str[i]){
                j++;
            }
            if (j == lens){
                ret++; j = next[j];
            }
        }
        return ret;
    }
}kmp;

string lib[50];
char str[maxn];
int cnt, cntx[50];

int main(){
	int T = 1; //cin >> T;
    int t, m;
	int len, val;
    while (T--){
    	cin >> m;
        trie.init();
		cnt = 0; memset(cntx, 0, sizeof(cntx));
        for (int i = 1; i <= m; i++){
            scanf("%d%s", &t, str);
            len = strlen(str);
            if (t == 1 || t == 2){
                val = (t == 1 ? 1 : -1);//字符串权值，插入为1，删除为-1
                if (len <= 1000){//模式串长度<=1000，插入trie
                    trie.insert(str, val);
                }else{//长度>1000,单独扔到一边
                    lib[cnt] = string(str);
                    cntx[cnt++] = val;
                }
            }else{
                long long ans = 0;
                for (int i = 0; i < len; i++){//对所有后缀在trie上查找
                    ans += trie.search(str + i);
                }
                for (int i = 0; i < cnt; i++){//对所有单独的模式串KMP
                    if (lib[i].length() > len){ continue; }
                    ans += kmp.search(lib[i], str)*cntx[i];
                }
                printf("%lld\n", ans);
                fflush(stdout);
            }
        }
    }
    return 0;
}

  • 关于时间复杂度，大概是因为这里以 1000 为标准线分类的设计比较巧妙，能很好的控制 trie 上操作和 KMP 的复杂度都不会很高。

  • 空间复杂度： O ⁡ ( 26 m ) \operatorname O(26m) O(26m)

Solution 3 （二进制分组 &AC 自动机）

这个解法是最常规的，其他题解介绍的也差不多了。大致思想就是因为 AC 自动机比较难支持在线的修改查询，那样每次都要重新构造 fail 指针，复杂度会很大。所以考虑维护不超过 log ⁡ m \log m logm 个 AC 自动机。第 i i i 个自动机储存 2 i 2^i 2i 个模式串，如下：

8 , 4 , 1 8,4,1 8,4,1

插入一个新模式串，就新建一组 AC 自动机。

8 , 4 , 1 , 1 8,4,1,1 8,4,1,1

然后只要前一个自动机大小与当前新自动机相等，就不断向前暴力合并。

8 , 4 , 2 8,4,2 8,4,2

如果再插入:

8 , 4 , 2 , 1 8,4,2,1 8,4,2,1

8 , 4 , 2 , 1 , 1 → 8 , 4 , 2 , 2 → 8 , 4 , 4 → 8 , 8 → 16 8,4,2,1,1\rightarrow 8,4,2,2\rightarrow 8,4,4\rightarrow 8,8 \rightarrow 16 8,4,2,1,1→8,4,2,2→8,4,4→8,8→16

至于合并的方式，对每个 AC 自动机维护一个 vector 容器存里面所有的模式串，然后只要前面可以合并，就将其中所有模式串拿出来向前合并即可。每次合并结束只需要对最后一个被合并的 AC 自动机重新构建 fail 指针。

删除操作：可以视为插入了一个权值为 -1 的字符串，同样用新建自动机向前合并的方式。

查询操作：遍历所有 AC 自动机，进行匹配，答案为匹配个数总和。

可以看出一个模式串最多被向前合并 log ⁡ m \log m logm 次，且最多存在 log ⁡ m \log m logm 组 AC 自动机。

  • 时间复杂度： O ⁡ ( m log ⁡ m ) \operatorname O(m\log m) O(mlogm)

  • 空间复杂度： O ( 26 m ) O(26m) O(26m)

一些细节 （血的教训）：

  1. 如果每个 AC 自动机都是用数组的形式，那么空间复杂度是 O ⁡ ( 26 m log ⁡ m ) \operatorname O(26m\log m) O(26mlogm)，是会 MLE 的。所以这里要用动态开点的 AC 自动机，用 vector 存储数据。
  2. 合并的过程要注意保证每个字符串只被拷贝一次，否则复杂度没法控制。
  3. 因为本题数据较强，AC 自动机部分的代码一定要控制常数。
  4. AC 自动机查询的函数中，不能暴力跳 fail 指针，负责会被第 27 组数据卡掉。要注意在构建 fail 指针的过程中，预处理一个点以及它 fail 指针后面的所有点权值总和，这样能避免跳 fail，保证每个点查询过程中只被遍历一次。

Code

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define mp make_pair
#define F first
#define S second
using namespace std;
int m,pr;
struct AC//AC自动机结构体
{
	int trienum;
	vector<int> cnt,tot,son[30],fail;//动态开点数组
	vector<pair<string,int> > v; //储存内部所有字符串及其权值的 vector
	void init()//初始化
	{
		v.clear();
		cnt.clear(),fail.clear(),tot.clear();
		trienum=0;
		cnt.pb(0),fail.pb(0),tot.pb(0);
		for(int i=0;i<26;i++)
		{
			son[i].clear();
			son[i].pb(0);
		}
	}
	void ins(string t,int x)//插入
	{
		v.pb(mp(t,x));
		int p=0;
		for(int i=0;i<(int)t.size();i++)
		{
			if (son[t[i]-'a'][p]<=0)
			{
				for(int j=0;j<26;j++)
					son[j].pb(0);
				cnt.pb(0),fail.pb(0),tot.pb(0);
				son[t[i]-'a'][p]=++trienum;
			}
			p=son[t[i]-'a'][p];
		}
		cnt[p]+=x;
	}
	void build()//bfs构建fail指针
	{
		tot.clear();
		tot.resize(trienum+1,0);
		queue<int> q;
		for(int i=0;i<26;i++)
			if (son[i][0]>0)
			{
				q.push(son[i][0]);
				tot[son[i][0]]=cnt[son[i][0]];
			}
		while(!q.empty())
		{
			int u=q.front();
			q.pop();
			for(int i=0;i<26;i++)
				if (son[i][u]>0)
				{
					fail[son[i][u]]=abs(son[i][fail[u]]);
					tot[son[i][u]]=cnt[son[i][u]]+tot[fail[son[i][u]]];//cnt是单点权值，tot是这个点和fail指针之后的所有点权值总和
					q.push(son[i][u]);
				}
				else//这一步是构造trie图，能方便失配时一步到达fail指针的位置，但是这里用负数标记，表示实际上这个儿子是不存在的
					son[i][u]=-abs(son[i][fail[u]]);
		}
	}
	ll query(string t)//查询
	{
		int u=0;
		ll res=0ll;
		for(int i=0;i<(int)t.size();i++)
		{
			u=abs(son[t[i]-'a'][u]);
			res+=tot[u];//避免了跳fail的过程
		}
		return res;
	}
}ac[25];
int main()
{
	int tp;
	char s[300005];
	scanf("%d",&m);
	while(m--)
	{
		scanf("%d%s",&tp,s);
		if (tp<3)
		{
			int val=(tp==1?1:-1);//字符串权值，插入为1，删除为-1
			int cur=0,lst=pr;
			ac[pr].init();
			ac[pr].ins(s,val);
			while(pr&&(int)ac[pr-1].v.size()==(int)ac[pr].v.size()+cur)//向前合并
				cur+=(int)ac[pr--].v.size();
			for(int i=pr+1;i<=lst;i++)
				for(auto p:ac[i].v)
					ac[pr].ins(p.F,p.S);
			ac[pr++].build();
		}
		else
		{
			ll res=0ll;
			for(int i=0;i<pr;i++)
				res+=ac[i].query(s);
			printf("%lld\n",res);
			fflush(stdout);
		}
	}
	return 0;
}
FelFa_1414666
关注
专栏目录
Codeforces 710F String Set Queries AC自动机+二进制分组
beginend
07-05 499
题意 有一个字符串集合D，要求资辞m个操作： 1 str表示在D中加入字符串str 2 str表示在D中删除字符串str 3 str表示询问D中每个字符串在str中的出现次数的和 强制在线 m,∑|str|≤3∗105m,∑|str|≤3∗105m,\sum|str|\le3*10^5 分析 一开始想到一个在线建广义sam+lct的做法，后来羊告诉我说在线建广义sam的复杂度是不对...
JetPack-Compose - Flutter 动态UI?
Stay hungry, stay foolish!!
03-18 3723
一、Flutter-初遇 2018-06月左右入坑Flutter,于是拿出美团和痘印等好看的界面感受了一波Flutter UI和绘制等写了三天的Demo也感受到了Flutter强大,当时匆匆忙忙就写了相关Demo上传了Github。不知不觉Github很多Star很开心,接着决定进行录制基础教学视频,在B站也收到了很多感谢私信、技术交流,记得2018年素未谋面的大哥因为我的热心无缘无故送我2018款MacBook Pro-在他的再三坚持下。带着这份感动和感激我也开始写了很多提供初学者一起学习的文章和...
CF710F String Set Queries
weixin_34362991的博客
02-24 94
CF710FString Set Queries 支持字符串的插入和删除。。。SAM也干不了这个事 所以可以用cdq分治+AC自动机O(nlogn)解决 但是本题强制在线~~~ 我们还有一个工具，叫做二进制分组！ 所以，每组建立一个AC自动机，合并的时候，AC自动机合并。最后再build失配指针 随机删除？虽然不是栈序删除了，但是，统计数量具有贡献独立性，再对删除串建立一个A...
[CF710F]String Set Queries
abcyan1235的博客
08-13 251
codeforces description 维护一个字符串集合，支持加入一个串，删除一个串，查询集合中的串在给出串中出现了多少次。 强制在线。 sol 二进制分组。维护\(\log\)个\(\mbox{AC}\)自动机，每插入一个串后依次合并，并重建\(\mbox{fail}\)，保证每个大小的\(\mbox{AC}\)自动机只存在一个。 有删除操作？注意到这里的答案是具有可减性的，所...
cf710F. String Set Queries
weixin_30951389的博客
12-13 124
题解: 我们考虑到 对于一个AC自动机而言 建好fair指针后 不能再插入字符串并维护fair指针 所以我们考虑暴力的做法 在加入字符串的同时 并重新构造fair指针 这样的复杂度是接受不了的 因为对于一个字符串而言他会被操作n次 我们考虑到一个优化是说 对于第一个插入的字符串我们没必要一直在后面的操作中重构它 我们想到用2进制加法这样优化构造过程 类似的 对于每一次进位 考虑进位的这个位...
单片机与DSP中的ST推出STR710F微控制器系列新产品
12-10
ST近日推出32位高整合ARM-based STR710F微控制器系列新产品。新产品为要求高性能、低价位的应用提供了更广阔的选择空间；新款MCU降低了价格，提高了设计灵活度，从而方便制造商设计基于STR7的各种不同性能水平的产品...
device_lenovo_TB3_710F:设备目录，用于为Lenovo TAB3 Essential 710F构建自定义rom（仅wifi＆gps）
05-09
此存储库是我为该设备的自定义rom构建做出贡献的一种沙箱。 源是的CM-12.1分支时的工作源改性 构建步骤（在创建构建环境之后）： curl https://storage.googleapis.com/git-repo-downloads/repo > .bin/repo ...
ARM7开发板快速入门：STR710F功能解析与使用指南
"本文主要介绍了基于ARM7TDMI CPU核心的STR710F开发板，该开发板具有用户友好的特性，无需额外的烧录器，可通过USB接口直接下载和执行程序。开发板内含BootLoader，支持多种RTOS，如CPLinux、uCLinux和uCOS，并提供...
【CF 710F】String Set Queries
as2886089的博客
10-15 108
在校内OJ上A了，没有加强制在线的东西。。不放链接了。 这道题题意是维护一个字符串集合，支持三种操作： 1.加字符串 2.删字符串 3.查询集合中的所有字符串在给出的模板串中出现的次数 操作数\(m \le 3*10^5\)，输入字符串总长度\(maxL \le 4*10^6\) 对于查询想到了要用AC自动机。但是还要插入和删除，每次插入一个字符串都得重构fail指针，删除更不可做。 对...
【CF710F】String Set Queries（二进制分组，AC自动机）
weixin_30371875的博客
08-13 98
【CF710F】String Set Queries（二进制分组，AC自动机） 题面 洛谷 CF 翻译： 你有一个字符集合\(D\)，初始为空， 有三种操作： 往\(D\)中加入一个串；从\(D\)中删除一个串；给定一个串\(S\)，询问\(D\)中的串在\(S\)中总共出现了多少次。 题解 询问显然就是将\(S\)放在所有\(D\)构成的\(AC\)自动机上跑。 所以我们需要一种方法，可以动态的...
codeforces 710f String Set Queries ac自动机 二进制分组
make_it_for_good的博客
09-02 1309
题意：维护一个字符串集合，支持插入一个串，删除一个串，询问集合中的串在给出的串中出现多少次，一个串出现多次算多次。并且不会有两次插入的串相同。强制在线。考虑没有删除的情况，将插入串的个数二进制拆分，对于每2k2^k 个串维护一个ac自动机。 这样共有loglog个ac自动机 。插入时如果当前ac自动机中串的个数和上一个个数相同，那么合并两个自动机。每个字符串只会被合并loglog 次。有删除时同
【CF710F】String Set Queries
weixin_30362233的博客
07-31 86
题面 https://www.luogu.org/problem/CF710F 题解 删除的情况另开一个“可支持插入的$AC$自动机”，因为贡献可减。 支持插入的$AC$自动机$=$$AC$自动机$+$二进制分组。 #include<iostream> #include<cstdio> #include<cstdlib> #incl...
【Codeforces710F】String Set Queries （强制在线）AC自动机
Freopen的博客
01-02 350
这个强制在线AC自动机。。。。 AC自动机是不可以修改的。 但是可以做到重构，合并O(n)O(n)O(n) 那么就开两个AC自动机，sizesizesize分别为n,m（m&amp;lt;n）n,m（m&amp;lt;n）n,m（m&lt;n） 那么每次m&amp;gt;Sm&amp;gt;Sm&gt;S时就将自动机合并，每次往第二个自动机加串时就重构。 那么合并O(nS)O(\frac nS)O...
【Codeforces710F】String Set Queries 多解
Demon_Rieman的博客
04-25 243
题目大意 给NNN个操作。 1.插入一个串SSS。 2.删除一个串SSS 。 3.询问未被删除的串在SSS中出现的次数。 ∑∣S∣≤3e5\sum |S| \leq 3e5∑∣S∣≤3e5，强制在线。 Solution 此题有多种解法，这里例举说明几种。（设LLL为总长） Solution 1 如果不强制在线，那么ACACAC自动机，后缀自动机都可以做此问题。（对于删除可以再建一个专门的删除的串...
【Codeforces710F】String Set Queries （强制在线）AC自动机 + 二进制分组
weixin_30915275的博客
10-16 103
F. String Set Queries time limit per test：3 seconds memory limit per test：768 megabytes input：standard input output：standard output You should processmqueries over a setD...
CF710F-String Set Queries【AC自动机,二进制分组】
QuantAsk
01-26 201
正题 题目链接:https://www.luogu.com.cn/problem/CF710F 题目大意 TTT次操作 往集合中加入一个字符串 往集合中删除一个字符串 给出一个模式串求出现的集合里面的字符串个数 解题思路 删除的话改成加入一个权值为−1-1−1的字符串就是全都是加入操作了。 然后就可以像[SDOI2014]向量集一样的做法了，维护一个线段树，然后第iii次加入修改第iii个节点，然后回朔的时候，如果一个区间[l,r][l,r][l,r]加入了r−l+1r-l+1r−l+1个字符串（加
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值