NOIP2024模拟赛13：拆开未来

NOIP2024模拟赛13：拆开未来

写在前面：进制哈希的P不要用998244353会被卡！用131。注意取模为负数的情况！

C-重复

• 一句话题意：给定字符串 $S$, 问 $S$ 的所有子串共有多少种“好的拆分方案”。对于一个字符串 $S$, 一个划分是好的当且仅当能把 $S$ 划分成 6 个非空子串 $a,b,c,d,e,f$, 满足 $a=b=e,c=f$ (一个字符串可能有多种划分方式)

• 标签：前缀和，思维，散列表(哈希)

• 简化一下就是要满足 $AABCAB$.

• 60分的暴力是对每一个区间枚举开头的 $A$ 和结尾的 $B$. (P.S.模数设 $998244353$ 会被卡！！！)

  const int N=5005;
  const ll P=131;
  ull h[N],p[N];
  char s[N];
  int n; ll ans=0;
  ull get(int l,int r){ return h[r]-h[l-1]*p[r-l+1]; }
  void solve(int l,int r){
  	int len=r-l+1;
  	F(i,1,len/3) for(int j=1;j<=len/2 && 3*i+2*j<len;++j){
  			ull A=get(l,l+i-1),B=get(l+i,l+2*i-1),C=get(l+2*i,l+2*i+j-1),E=get(r-i-j+1,r-j),F=get(r-j+1,r); 
  			if(A == B && B == E && C == F) ++ans;
  		}
  }
  signed main(){
  	freopen("c.in","r",stdin); freopen("c.out","w",stdout);
  	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
  	cin>>(s+1); n=strlen(s+1); p[0]=1;
  	F(i,1,n) h[i]=h[i-1]*P+s[i]-'0',p[i]=p[i-1]*P;
  	F(l,1,n) F(r,l+5,n) solve(l,r);
  	cout<<ans;
  	return 0;
  }
  

• 但正如邓老师所说，这种拆分方式是“不平衡的”，虽然我们可以用 $O(1)$ 的时间去检查剩下的位置，但我们却需要花 $O(N^2)$ 的时间枚举所有的首尾情况。

• 所以正解我们选择枚举 $AB$. 枚举 $A$ 的左端点 $i$ 和 $B$ 的右端点 $j$.

• 对于 $AA$, 在固定 $i$ 的情况下可以用前缀和处理所有贡献。

• 对于 $AB$ 和后面那个 $AB$ 的匹配, 把所有已经扫到过的 $AB$ 存进一个散列表并统计其个数($unorderedmap$ 会 T掉)

• 两者的贡献相乘即是单次的总贡献。

• 注意循环的初末条件，$C$ 不为空（详见代码）

#include<bits/stdc++.h>
#define F(i,l,r) for(int i(l);i<=r;++i)
#define G(i,r,l) for(int i(r);i>=l;--i)
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int N=5005,mod=1e7+9;
const ll P=131;
ll h[N],p[N];
char s[N];
int n,f[N][N]; 
ll ans=0;
ull get(int l,int r){ return h[r]-h[l-1]*p[r-l+1]; }
struct node{//AB的散列表 
	int first[mod],ne[N*N/2],cnt=0;
	ll val[N*N/2],dui[N*N/2];
	//注意:first的下标肯定小于mod,但由于顺延的原因,散列表的总大小完全可能大于mod , 所以空间开 N*N/2 而不是mod 
	inline void update(ll x){
		ll o = (x%mod+mod)%mod;//把要加入的数用取模得到一个映射 
		for(int i=first[o];i;i=ne[i]){
			if(dui[i]==x){
				val[i]++;
				return ;
			}//对于已存在的数,直接加个数(val) 
		}
		//对于不存在的数,顺次延后新开一个位置(完全同邻接表写法) 
		ne[++cnt]=first[o];
		first[o]=cnt;
		dui[cnt]=x;
		val[cnt]=1;
		return ;
	}
	inline ll fd(ll x){
		ll o = (x%mod+mod)%mod;
		for(int i=first[o];i;i=ne[i]){
			if(dui[i]==x) return val[i];
		}
		return 0;
	}
}mp;//散列表(充当unordered_map,但更快) 
signed main(){
	freopen("c.in","r",stdin); 
	freopen("c.out","w",stdout);
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	cin>>(s+1); n=strlen(s+1); p[0]=1;
	F(i,1,n) h[i]=h[i-1]*P+s[i]-'0'+37,p[i]=p[i-1]*P;//哈希 
	
	F(len,1,n){
		for(int i=len+1;i+len-1<=n;++i){
			int j=i+len-1;
			f[i][j]=(get(i-len,i-1)==get(i,j));
		}
	}
	F(i,1,n) F(j,i,n) f[i][j]+=f[i][j-1];//处理 A=A 的前缀和 
	
	//枚举AB 
	for(int j = n-2; j >= 1; j--) { //B的右端点,由于是用AB更新散列表,长度至少要留2,所以 j 从 n-2 开始 
		//首先是统计答案 
		for(int i = 2; i < j; i++) {//A的左端点,因为要满足 AAB,所以i从2开始 
			int rp = min(2 * i - 2, j - 1);
			//因为A对称,所以A的长度最大为i-1,所以AA的右端点最大为  2*(i-1)
			//同时不能超过 B 的右端点 
			ans += 1ll * f[i][rp] * mp.fd(get(i, j));//AA的方案数 * AB 的方案数 = AAB的方案数
		}
		//接着是更新散列表 
		for(int i = j + 2; i <= n; i++) {
			mp.update(get(j + 1, i));//因为下一次的j统计答案时,至少要给C留1的位置,所以起点为 j+1. 
		}
	}
	cout<<ans<<"\n";
	return 0; 
}