标签：LC val int 题解 tree Tyler mul root Strings

题意

给你一个长度为\(n\)的序列\(s\)和一个长度为\(m\)的序列\(t\),现在你可以任意排列\(s\)中的元素.现在问你能组合出多少个本质不同的序列,使得字典序小于\(t\)

分析

发现最终的要求是字典序小于,所以我们可以从\(1\)号位置到\(\min(n,m)\)的位置迭代.假设我们现在迭代到的位置为\(j\),那么位置\(j\)要么放一个字典序小于\(t_j\)的字符,放了之后从\(j+1\)到\(\min(n,m)\)的位置都可以随便放.要么放一个字典序等于\(t_j\)的字符,然后因为我们可以确定放的是哪一个字符,就可以减去这个字符的影响然后继续从\(j+1\)开始统计答案.
以上是主要思路,但是我们发现如果我们暴力迭代并统计的话,我们设权值的最大值为\(c\),那么我们需要枚举用哪个字典序小于\(t_j\)的元素,然后统计答案,复杂度很显然接受不了.
考虑优化,首先考虑怎么优化统计答案的部分,我们设用\(v_1\)个\(1\),\(v_2\)个\(2\)...\(v_c\)个\(c\)来组成不同的序列,那么显然能组成的不同的序列个数为\(\frac{(v_1+v_2+...+v_c)!}{v_1!v_2!...v_c!}\),这玩意显然可以通过预处理处理出来.然后我们考虑迭代的时候,我们设\(s_k<t_j\),所以用\(s_k\)这个元素,那么它后边的就可以随便选,答案就是\(\frac{(v_1+v_2+...+v_c-1)!}{v_1!v_2!...(v_k-1)!...v_c!}\),而且由于对于每个字典序小于\(t_j\)的元素,我们都要统计一遍这个答案,所以我们可以设\(A_i=\frac{(v_1+v_2+...+v_c-1)!}{v_1!v_2!...(v_i-1)!...v_c!}\),那么对于某次迭代,只需要对这个数组求前缀和即可.
但是这样我们会发现一个问题,就是当我们选择了一个字典序等于\(t_j\)的元素时,这个元素会被去掉,我们之前统计的所有的\(A_i\)就需要重新被计算一遍,我们显然接受不了.考虑怎么快速解决这个问题.我们发现:假设我们用的元素的值为\(k\),那么对于所有的\(i\) \(\not=\) \(k,A_i=A_i\times\frac{v_i}{v_1+v_2+...+v_c-1}\),而对于\(k\),则有\(A_k=A_k\times\frac{v_k-1}{v_1+v_2+...+v_c-1}\).
分析到这里,我们发现以上两种操作就是对整个\(A\)数组进行区间乘法以及区间求和操作,可以用基本的线段树来实现这种操作然后统计答案即可.
有一点需要注意,当\(n<m\)时,如果前几个的字典序都选取了与\(t\)相等的,这样组成的序列字典序也是小于\(t\)的,所以需要特判。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
const int P=998244353;
int n,m,c;
int s[N],t[N];
int inv[N],fac[N],ninv[N];
int buck[N],add[N],tmp[N];
struct Tree{
	int mul,val;
	int size;
}tree[N<<2];

inline int ksm(int x,int y){
	int res=1;
	while(y){
		if(y&1)
			res=1ll*res*x%P;
		x=1ll*x*x%P;
		y>>=1;
	}
	return res%P;
}

#define LC (root<<1)
#define RC (root<<1|1)
void Build(int root,int start,int end){
	tree[root].size=end-start+1;
	tree[root].mul=1;
	if(start==end){
		tree[root].val=add[start];
		return;
	}
	int mid=(start+end)>>1;
	Build(LC,start,mid);
	Build(RC,mid+1,end);
	tree[root].val=(tree[LC].val+tree[RC].val)%P;
	return;
}
void pushdown(int root){
	if(tree[root].mul>1){
		tree[LC].mul=1ll*tree[root].mul*tree[LC].mul%P;
		tree[RC].mul=1ll*tree[root].mul*tree[RC].mul%P;
		tree[LC].val=1ll*tree[LC].val*tree[root].mul%P;
		tree[RC].val=1ll*tree[RC].val*tree[root].mul%P;
	}
	tree[root].mul=1;
	return;
}
void modify_group(int root,int qstart,int qend,int nstart,int nend,int off){
	if(qend<qstart)
		return;
	if(qstart>nend||qend<nstart)
		return;
	if(qstart<=nstart&&qend>=nend){
		tree[root].val=1ll*tree[root].val*off%P;
		tree[root].mul=1ll*tree[root].mul*off%P;
		return;
	}
	int mid=(nstart+nend)>>1;
	pushdown(root);
	modify_group(LC,qstart,qend,nstart,mid,off);
	modify_group(RC,qstart,qend,mid+1,nend,off);
	tree[root].val=(tree[LC].val+tree[RC].val)%P;
	return;
}
int query(int root,int qstart,int qend,int nstart,int nend){
	if(qend<qstart)
		return 0;
	if(qstart>nend||qend<nstart)
		return 0;
	if(qstart<=nstart&&qend>=nend)
		return tree[root].val%P;
	int mid=(nstart+nend)>>1;
	pushdown(root);
	return (query(LC,qstart,qend,nstart,mid)+query(RC,qstart,qend,mid+1,nend))%P;
}

int main(void){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%d",&s[i]);
	for(int i=1;i<=n;i++)
		c=max(c,s[i]);
	for(int i=1;i<=m;i++)
		scanf("%d",&t[i]);
	fac[1]=1;
	for(int i=2;i<=n;i++)
		fac[i]=1ll*fac[i-1]*i%P;
	inv[0]=ninv[0]=1;
	for(int i=1;i<=n;i++){
		inv[i]=ksm(fac[i],P-2)%P;
		ninv[i]=ksm(i,P-2)%P;
	}
	for(int i=1;i<=n;i++)
		buck[s[i]]++;
	int inih=0,inil=1;
	for(int i=1;i<=c;i++){
		inih=(inih+buck[i])%P;
		inil=1ll*inil*inv[buck[i]]%P;
	}
//	printf("%lld\n",1ll*fac[inih]*inil%P);
	for(int i=1;i<=c;i++){
		if(buck[i]<=0)
			continue;
		int bottom=1ll*inil*fac[buck[i]]%P*inv[buck[i]-1]%P;
		add[i]=1ll*fac[inih-1]*bottom%P;
//		printf("%d ",add[i]);
	}
	
	Build(1,1,c);
	int sum=inih;
	long long ans=0;
	
	if(m>n){
		for(int i=1;i<=c;i++)
			tmp[i]=buck[i];
		bool flag=1;
		for(int i=1;i<=n&&flag;i++){
			if(tmp[t[i]]>=1){
				tmp[t[i]]--;
			}
			else 
				flag=0;
		}
		if(flag)
			ans++;
	}
	
	for(int i=1;i<=min(n,m);i++){
		ans=(ans+query(1,1,t[i]-1,1,c))%P;
		if(buck[t[i]]==0)
			break;
		int dest=1ll*buck[t[i]]*ninv[sum-1]%P;
		int d2=1ll*(buck[t[i]]-1)*ninv[buck[t[i]]]%P;
		modify_group(1,1,c,1,c,dest);
		modify_group(1,t[i],t[i],1,c,d2);
		sum--;
		buck[t[i]]--;
	}
	printf("%lld\n",ans); 
	return 0;
}

标签：LC,val,int,题解,tree,Tyler,mul,root,Strings
来源： https://www.cnblogs.com/xishuixs/p/15984424.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。