acm-(好题、哈希技巧)2020 China Collegiate Programming Contest Qinhuangdao Site J. Jewel Splitting

最新推荐文章于 2022-03-23 15:43:08 发布
最新推荐文章于 2022-03-23 15:43:08 发布
阅读量461 收藏 1
点赞数 1
文章标签： acm竞赛 算法 好题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30361651/article/details/110135908
版权

题面
传送门
本题让求一个字符串在不同划分下的排列数，具体来说，给定一个 d , d = 1 , 2 , 3 , . . , n d,d=1,2,3,..,n d,d=1,2,3,..,n，将字符串划分为 d d d个长度相同的部分，剩下一个长度为 n % d n\%d n%d的子串，然后求出这 d d d个长度相同部分的不同排列方案数，假设这个答案是 a n s d ans_d ansd​，则我们需要求出 A N S = ∑ i = 1 n a n s i ANS=\sum_{i=1}^nans_{i} ANS=∑i=1n​ansi​。

考虑如何求解 a n s d ans_d ansd​，假设 t = n % d t=n\%d t=n%d，那么我们枚举长度为 t t t的子串(即不参加排列的那多余的部分)出现的位置，由于 t t t子串的左边和右边的串长都必须是 d d d的整数倍，故其实 t t t只可能出现在固定的一些位置上。

先考虑 t t t子串在最左边的位置的时候的情况。这时候的分布情况大致如下图所示：
图一
我们先求出此时的排列方案数，根据组合数学的公式，假设 n / d 串 n/d串 n/d串中有 k k k种不同的串，对于第 i i i种串存在 c n t [ i ] cnt[i] cnt[i]个相同的串，那么总排列方案数为 ( ∑ i = 1 k c n t [ i ] ) ! c n t [ 1 ] ! c n t [ 2 ] ! . . . c n t [ k ] ! \frac{(\sum_{i=1}^kcnt[i])!}{cnt[1]!cnt[2]!...cnt[k]!} cnt[1]!cnt[2]!...cnt[k]!(∑i=1k​cnt[i])!​，于是用哈希表对不同类型的串做一个 1 ∼ k 1\sim k 1∼k的映射，这样就能得到每个 c n t cnt cnt的值，于是能够求出方案数了。

下面开始枚举 t t t，枚举不同位置的 t t t的过程可以看成是 t t t向右移动的过程，比如现在将 t t t向右移动到下一个位置，大概如下图所示：
图二
我们容易发现移动一步之后，只有两个 c n t cnt cnt的值会发生改变，于是我们不妨维护 f v = c n t [ 1 ] ! c n t [ 2 ] ! c n t [ 3 ] ! . . fv=cnt[1]!cnt[2]!cnt[3]!.. fv=cnt[1]!cnt[2]!cnt[3]!..的值，比如现在这一步移动之后，我们会改变 c n t [ 1 ] cnt[1] cnt[1]的值，使它减少 1 1 1，不过新加入的一个 n / d n/d n/d串(即最左边那个串)可能是之前没出现过的，根据哈希表来动态判断，根据不同的情况，增加一个 c n t cnt cnt或者对原有的 c n t cnt cnt加 1 1 1即可，同时维护 f v fv fv的值，于是每移动一步 t t t串我们都能 O ( 1 ) O(1) O(1)得到当前的排列方案数，当 t t t串移动到原串末端的时候，我们就得到了 a n s d ans_d ansd​的值。

不过本题还需要考虑方案的重复问题，在 t t t串移动的过程中，当前的所有串的分布情况可能再之前已经出现过了，也就是说，这这两种分布体现在 c n t cnt cnt上是一模一样的，故我们不需要计算此时的方案数，那如何判断当前 c n t cnt cnt的分布在之前出现过呢，我们考虑对整个 c n t cnt cnt的分布进行哈希，这里有两种哈希的方式，第一种是把 c n t cnt cnt数组看成一个字符串，那么按照字符串的哈希方式即可，注意一定要开双基数！！开双基数！！开双基数！！第二种方法则是利用异或来搞，能够降低时间消耗，而且不需要双基数(需要选择一个比较适合的基数，越大越好比较玄学)，这时候只需要一个基数即可，假设它是 b a s e base base，那么异或的哈希函数就是 ( c n t [ 1 ] ⋅ b a s e 1 )   x o r   ( c n t [ 2 ] ⋅ b a s e 2 )   x o r   ( c n t [ 3 ] ⋅ b a s e 3 ) . . . (cnt[1]\cdot base^1)\,xor\,(cnt[2]\cdot base^2)\,xor\,(cnt[3]\cdot base^3)... (cnt[1]⋅base1)xor(cnt[2]⋅base2)xor(cnt[3]⋅base3)...。

除了这个关于 c n t cnt cnt的分布的哈希表需要手写以外，我们还需要手写前面的映射哈希，以及字符串哈希，本题总共涉及三个哈希类型，是一道关于哈希表的练手好题。

这里给出两份代码，两份代码的主要区别在于 c n t cnt cnt的分布的哈希表的哈希方式不同，第一种是普通字符串哈希(采用双基数)，第二种是异或哈希(方法如前文所述)。

代码一：

char s[maxn];
int h1[maxn],h2[maxn],ib1[maxn],ib2[maxn],fac[maxn],fav[maxn],ANS=0;
const int p = 388211,b=19;
int hhs;
struct HASH{
	struct HAS{
		ll id=-1;
		int v=0;
	}h[p];
	vector<int>rec;
	void add(ll id,int v){
		int hs=id%p;
		while(~h[hs].id && (h[hs].id^id)){
			hs+=b;
			if(hs>=p)hs-=p;
		}
		if(h[hs].id==-1)rec.push_back(hs);
		hhs=hs;
		h[hs].id=id;
		h[hs].v=v;
	}
	void ad(int hs,ll id,int v){
		if(h[hs].id==-1)rec.push_back(hs);
		h[hs].v=v;
		h[hs].id=id;
	}
	int qry(ll id){
		int hs=id%p;
		while(~h[hs].id && (h[hs].id^id)){
			hs+=b;
			if(hs>=p)hs-=p;
		}
		hhs=hs;
		return (~h[hs].id)?h[hs].v:-1;
	}
	int qr(int hs){
		return h[hs].v;
	}
	void clear(){
		FOR(i,0,rec.size())h[rec[i]].id=-1;
		rec.clear();
	}
}has,hs;
 
void init(int n){
	ANS=0;
	int bb1=1,bb2=1;
	FOR(i,1,n+1){
		ib1[i]=1ll*ib1[i-1]*ib1[1]%mod;
		ib2[i]=1ll*ib2[i-1]*ib2[1]%mod;
		h1[i]=sum(1ll*s[i]*bb1%mod,h1[i-1]);
		h2[i]=sum(1ll*s[i]*bb2%mod,h2[i-1]);
		bb1=1ll*bb1*b1%mod;
		bb2=1ll*bb2*b2%mod;
	}
}
ll shash(int l,int r){
	ll ans1=1ll*sub(h1[r],h1[l-1])*ib1[l-1]%mod;
	ll ans2=1ll*sub(h2[r],h2[l-1])*ib2[l-1]%mod;
	return ans1<<32ll|ans2;
}
int tot=0,mark[maxn],cnt[maxn],bs[maxn],bs2[maxn];
const int base = 7,base2 = 11;
void work(int n,int t,int d){
	ll id;int x,fv=1,xv=0,xv2=0;
	tot=0;
	for(register int i=t+1;i<=n;i+=d){
		id=shash(i,i+d-1);
		if(~(x=has.qry(id))){
			mark[i]=x;
		}else{
			mark[i]=++tot;
			has.ad(hhs,id,tot);
		}
		cnt[mark[i]]++;
	}
	FOR(i,1,tot+1)fv=1ll*fv*fav[cnt[i]]%mod,add(xv,1ll*cnt[i]*bs[i]%mod),add(xv2,1ll*cnt[i]*bs2[i]%mod);
	hs.add(1ll*xv<<32ll|xv2,1);
	int nd=n/d;
	add(ANS,1ll*fac[nd]*fv%mod);
	if(!t){
		hs.clear();
		has.clear();
		memset(cnt,0,sizeof(int)*(tot+3));
		return;
	}
	for(register int i=1;i+d-1<=n;i+=d){
		id=shash(i,i+d-1);
		if(~(x=has.qry(id))){
			mark[i]=x;
		}else{
			mark[i]=++tot;
			has.ad(hhs,id,tot);
		}
		if(mark[i]!=mark[i+t]){
			fv=1ll*fv*fac[cnt[mark[i]]]%mod*fac[cnt[mark[i+t]]]%mod;
			dec(xv,sum(1ll*cnt[mark[i]]*bs[mark[i]]%mod,1ll*cnt[mark[i+t]]*bs[mark[i+t]]%mod));
			dec(xv2,sum(1ll*cnt[mark[i]]*bs2[mark[i]]%mod,1ll*cnt[mark[i+t]]*bs2[mark[i+t]]%mod));
			cnt[mark[i]]++;
			cnt[mark[i+t]]--;
			fv=1ll*fv*fav[cnt[mark[i]]]%mod*fav[cnt[mark[i+t]]]%mod;
			add(xv,sum(1ll*cnt[mark[i]]*bs[mark[i]]%mod,1ll*cnt[mark[i+t]]*bs[mark[i+t]]%mod));
			add(xv2,sum(1ll*cnt[mark[i]]*bs2[mark[i]]%mod,1ll*cnt[mark[i+t]]*bs2[mark[i+t]]%mod));
			if(hs.qry(1ll*xv<<32ll|xv2)==-1){
				add(ANS,1ll*fac[nd]*fv%mod);
				hs.ad(hhs,1ll*xv<<32ll|xv2,1);
			}
		}
	}
	FOR(i,1,tot+1)cnt[i]=0;
	hs.clear();
	has.clear();
}
int main(){
	int kase=0;
	fac[0]=bs[0]=bs2[0]=1;
	FOR(i,1,maxn)fac[i]=1ll*fac[i-1]*i%mod,bs[i]=1ll*bs[i-1]*base%mod,bs2[i]=1ll*bs2[i-1]*base2%mod;
	fav[0]=1;fav[maxn-1]=qpow(fac[maxn-1],mod-2,mod);
	ROF(i,maxn-2,1)fav[i]=1ll*fav[i+1]*(i+1)%mod;
	ib1[0]=ib2[0]=1;ib1[1]=qpow(b1,mod-2,mod),ib2[1]=qpow(b2,mod-2,mod);
	int t=rd(),c=0;
	while(t--){
		int n=rds(s+1);
		++c;
		init(n);
		FOR(i,1,n+1){
			work(n,n%i,i);
		}
		printf("Case #%d: %d\n",++kase,ANS);
	}
}

代码二：

char s[maxn];
int h1[maxn],h2[maxn],ib1[maxn],ib2[maxn],fac[maxn],fav[maxn],ANS=0;
const int p = 388211,b=19;
int hhs;
struct HASH{
	struct HAS{
		ll id=-1;
		int v=0;
	}h[p];
	vector<int>rec;
	void add(ll id,int v){
		int hs=id%p;
		while(~h[hs].id && (h[hs].id^id)){
			hs+=b;
			if(hs>=p)hs-=p;
		}
		if(h[hs].id==-1)rec.push_back(hs);
		hhs=hs;
		h[hs].id=id;
		h[hs].v=v;
	}
	void ad(int hs,ll id,int v){
		if(h[hs].id==-1)rec.push_back(hs);
		h[hs].v=v;
		h[hs].id=id;
	}
	int qry(ll id){
		int hs=id%p;
		while(~h[hs].id && (h[hs].id^id)){
			hs+=b;
			if(hs>=p)hs-=p;
		}
		hhs=hs;
		return (~h[hs].id)?h[hs].v:-1;
	}
	int qr(int hs){
		return h[hs].v;
	}
	void clear(){
		FOR(i,0,rec.size())h[rec[i]].id=-1;
		rec.clear();
	}
}has,hs;
 
void init(int n){
	ANS=0;
	int bb1=1,bb2=1;
	FOR(i,1,n+1){
		ib1[i]=1ll*ib1[i-1]*ib1[1]%mod;
		ib2[i]=1ll*ib2[i-1]*ib2[1]%mod;
		h1[i]=sum(1ll*s[i]*bb1%mod,h1[i-1]);
		h2[i]=sum(1ll*s[i]*bb2%mod,h2[i-1]);
		bb1=1ll*bb1*b1%mod;
		bb2=1ll*bb2*b2%mod;
	}
}
ll shash(int l,int r){
	ll ans1=1ll*sub(h1[r],h1[l-1])*ib1[l-1]%mod;
	ll ans2=1ll*sub(h2[r],h2[l-1])*ib2[l-1]%mod;
	return ans1<<32ll|ans2;
}
int tot=0,mark[maxn],cnt[maxn],bs[maxn],bs2[maxn];
const int base = 1e9+7,base2 = 19;
void work(int n,int t,int d){
	ll id,xv=0;int x,fv=1,xv2=0;
	tot=0;
	for(register int i=t+1;i<=n;i+=d){
		id=shash(i,i+d-1);
		if(~(x=has.qry(id))){
			mark[i]=x;
		}else{
			mark[i]=++tot;
			has.ad(hhs,id,tot);
		}
		cnt[mark[i]]++;
	}
	FOR(i,1,tot+1)fv=1ll*fv*fav[cnt[i]]%mod,xv^=1ll*cnt[i]*bs[i];
	hs.add(xv,1);
	int nd=n/d;
	add(ANS,1ll*fac[nd]*fv%mod);
	if(!t){
		hs.clear();
		has.clear();
		memset(cnt,0,sizeof(int)*(tot+3));
		return;
	}
	for(register int i=1;i+d-1<=n;i+=d){
		id=shash(i,i+d-1);
		if(~(x=has.qry(id))){
			mark[i]=x;
		}else{
			mark[i]=++tot;
			has.ad(hhs,id,tot);
		}
		if(mark[i]!=mark[i+t]){
			fv=1ll*fv*fac[cnt[mark[i]]]%mod*fac[cnt[mark[i+t]]]%mod;
			xv^=1ll*cnt[mark[i]]*bs[mark[i]]^1ll*cnt[mark[i+t]]*bs[mark[i+t]];
			cnt[mark[i]]++;
			cnt[mark[i+t]]--;
			fv=1ll*fv*fav[cnt[mark[i]]]%mod*fav[cnt[mark[i+t]]]%mod;
			xv^=1ll*cnt[mark[i]]*bs[mark[i]]^1ll*cnt[mark[i+t]]*bs[mark[i+t]];
			if(hs.qry(xv)==-1){
				add(ANS,1ll*fac[nd]*fv%mod);
				hs.ad(hhs,xv,1);
			}
		}
	}
	FOR(i,1,tot+1)cnt[i]=0;
	hs.clear();
	has.clear();
}
int main(){
	int kase=0;
	fac[0]=bs[0]=bs2[0]=1;
	FOR(i,1,maxn)fac[i]=1ll*fac[i-1]*i%mod,bs[i]=1ll*bs[i-1]*base%mod;
	fav[0]=1;fav[maxn-1]=qpow(fac[maxn-1],mod-2,mod);
	ROF(i,maxn-2,1)fav[i]=1ll*fav[i+1]*(i+1)%mod;
	ib1[0]=ib2[0]=1;ib1[1]=qpow(b1,mod-2,mod),ib2[1]=qpow(b2,mod-2,mod);
	int t=rd(),c=0;
	while(t--){
		int n=rds(s+1);
		++c;
		init(n);
		FOR(i,1,n+1){
			work(n,n%i,i);
		}
		printf("Case #%d: %d\n",++kase,ANS);
	}
}
&*^*&
关注
专栏目录
2020 China Collegiate Programming Contest Qinhuangdao Site
m0_49959202的博客
10-24 768
文章目录2020 China Collegiate Programming Contest Qinhuangdao SiteA.A Greeting from QinhuangdaoD.Exam ResultsE.Friendly GroupF.Good NumberJ.Kingdom's Power 2020 China Collegiate Programming Contest Qinhuangdao Site A.A Greeting from Qinhuangdao 题意： 组合数签到题 题解：
Acm解题技巧---Hash字符串
李dayday
05-14 716
Hash字符串写起了很简单 第一题 点这里（第四小题） 持续更新！！！
hdu 3727:Jewel（主席树入门题）
污miao汪的博客
02-06 314
hdu 3727:Jewel 很基础的主席树练习题目，
KMP+hash（好题，对next数组的理解加深）
小糊涂的博客
11-16 203
http://codeforces.com/problemset/problem/126/B-------》》》题目链接 题目大意： 给出一个字符串，找出一个子串既是它的前缀，也是它的后缀，还是一个非后缀也非前缀的子 题目分析： 本来挺简单的一个题，最开始想复杂了，还用了后缀数组，醉了。 这个题主要用的是kmp的next数组，首先我们要了解next数组的定义，next[i]...
Jewels（2021牛客多校第五场J）
国家一级划水运动员的博客
08-01 210
题目描述 输入描述 输出描述 输入样例 3 1 1 1 1 2 2 2 2 3 3 3 3 输出样例 62 样例说明 题目大意：时间从 t = 0 开始，每秒可以抢救任意一个坐标为（ x , y , z + t * v ）的宝物并花费 x ² + y ² + z ² + t ² v ² + 2 t v z 的力量，求抢救完所有的宝物需要花费的最小力量。 本题吃了没学过图论的亏， 比赛时用 pair 数对存入 z 的变化量后排序暴力枚举，虽然愉快的通过了样例但提交通过率 0%（泪目）。 正确做法
ACM-ICPC 历年竞赛 真题，各大赛区真题详解
04-24
ACM-International Collegiate Programming Contest（简称ACM-ICPC）是由美国计算机协会（Association for Computing Machinery）主办的一项全球性的编程竞赛，旨在培养大学生的算法设计、问题解决以及团队协作能力...
个人ACM-ICPC模板acm-icpc-master.zip
最新发布
02-05
标题中的“个人ACM-ICPC模板acm-icpc-master.zip”指的是一个与ACM国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的个人开发的模板项目。这个压缩包很可能是参赛者或者教练为了...
2020CCPC河南省赛正式赛.pdf
08-24
【ACM竞赛】是国际大学生程序设计竞赛（International Collegiate Programming Contest）的简称，是一项旨在展示大学生创新能力、团队合作精神和解决实际问题能力的国际性比赛。2020年河南省CCPC大赛属于ACM竞赛的...
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International Collegiate ...
浅谈哈希算法 ACM
AGNING的博客
08-16 661
前言 趁着还没忘记录一下吧???? 原文链接：点击我 在博客中浏览效果更佳哦 哈希能干些啥？ 学一个新算法首先一定要知道学这个能干些啥对吧，我们是为了用某个东西而去学这个东西而不是盲目目的的学，现在假如给你两段字符串让你去比较他们是否相同，如果暴力做法就是从头到尾扫一遍，都相同则相同，复杂度为O(N)，假如数据量非常大，而且字符串长度很大，现在题目就变成了给你n个字符串，现在又给你t个字符串问你每一个字符串是否在这n个字符串中，平常做法时间复杂度O(t*t个字符串每一个字符串长度*n)，若用哈希预处理时间
哈希和双哈希
Freopen的博客
11-03 730
哈希自然溢出 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;set&gt; #define LL long long #define maxn 10005 #define S 131 using namespace std; int n; char s[maxn]; set...
洛谷P3370 【模板】字符串哈希 题解（写了一个双哈希）
REXWind的博客
08-17 394
https://www.luogu.com.cn/problem/P3370 看了一下这题的题解，发现好像直接用单哈希就可以写。。 对每个字符串计算两个字符串哈希值，分别取不同的模数，做一对pair分别储存对两个模数的哈希值。之后只需要对这些pair进行排序，找有多少个不同的就可以了。 #include<iostream> #include<algorithm> using namespace std; int cansel_sync=(ios::sync_with_stdio(
如何动态的向数组中插入键值对_OI/ACM中的哈希表，一些哈希算法以及题目
weixin_39995774的博客
12-04 256
<如果你已经学习过哈希有关知识，也推荐看一下后面的补充知识及题目>问题引出：假设有一个集合 ，里面装满了形如 的键值对， 值是唯一的。现在想在尽可能短的时间内取出 对应的 的值，要怎么做比较好呢？假设集合中有 个不同的 ，那么当我们可以定义一个函数以 为自变量的函数 ，它能使得 等于某个 的整数，并且对于 。当计算 函数的代价是 的，通过开一个大小为 的 ...
LeetCode：哈希表（11道经典题目）
一起加油~
03-23 3672
力扣上关于哈希表的经典题目，并提供了对应的题解。主要是用C++和Python实现的。
2020秦皇岛CCPC
OZY的博客
10-23 567
我的情况 本人就读于一个不开设任何计算机课的专业（也就是和计算机一点关系都没有的专业） 凭借着摸鱼划水获得了学校一个参加这场比赛的资格 获得了之后继续摸鱼划水 也就是啥练习没做，裸奔上阵 但话说回来，你说我这跟计算机没啥关系的为啥要做题（雾 结果自然就是比赛的时候发现自己变得啥都不会，啥题都做不出来 凭借着队友的手速获得了Au 你说一个5h的比赛，我们怎么一个半小时就下班了？ 为了提升一下以后还可能有的比赛的游戏体验，现在来补一下题 I. Interstellar Hunter 就是问你在所拥有的向量中能否
哈希表题目汇总
Jiana_Feng的博客
06-01 1329
序言 哈希表题目汇总，好好干饭，好好努力，好好加油哦 题目一：检查数组中是否有有两个数相加 等于目标值 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 哈希表是 组成一个字典 将
哈希表入门题目总结(HDU 1280、1425、2027、3833、1496、2648 POJ 1200）
liwei的专栏
12-22 2535
今天做了一天的哈希表题目，虽然不是哈希算法，但是感觉先把这哈希表搞定了，再学哈希算法的时候会快一些，所以今天搞得现在都有点头痛了，看了一天的电脑…… 快要睡觉了，整理一下今天的成果。整理一下题目与思想，明天学哈希算法的时候应该会有些帮助。 先推荐一个哈希入门网站，还没做题之前，我把这网站关于哈希的都看了个遍，有些明白了才开始做题的：http://wenku.baidu.com/view/983
天梯赛训练 电话聊天狂人（25 分）
请赐教
03-10 1195
7-12电话聊天狂人（25分） 给定大量手机用户通话记录，找出其中通话次数最多的聊天狂人。 输入格式: 输入首先给出正整数N（≤10​5​​），为通话记录条数。随后N行，每行给出一条通话记录。简单起见，这里只列出拨出方和接收方的11位数字构成的手机号码，其中以空格分隔。 输出格式: 在一行中给出聊天狂人的手机号码及其通话次数，其间以空格分隔。如果这样的人不唯一，则输出狂人中最小的号码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值