HRC 003 T3 置换

题目链接

HRC 是啥

HZOI Regular Contest

前置知识

置换
轮换

$60\text{pts}$ 解法

就像对于一个数，我们经常从素因子之积的角度看待它一样，在这道题中，我们从轮换的角度看待置换。
我们考虑一个轮换变成恒等变换所需次数：一个长度为 $l$ 轮换，可以看做一个边数为 $l$ 的环，置换乘法可以看做数字沿着边转一圈。假设某一条边的终点处的数字一开始为 $k$，那么这条边的起点的位置编号一定是 $k$。以轮换 $(3,1,2)$ 为例，边 $3\to 1$（位置编号）为例，起点的位置编号为 $3$，终点一开始是 $3$。也就是说，一个数字从它开始的位置到达恒等变换的位置（位置编号也为这个数字），需要经过 $l-1$ 条边，反映到幂次上，贡献为 $l$。
而对于整个置换，若变成恒等置换，则贡献为每个轮换长度的最小公倍数。答案即为每一种最小公倍数的平方与置换总数，即 $n!$ 的商。
我们考虑统计出每一种最小公倍数的出现次数，设 $d{p}_{i,j}$ 为将 $i$ 个位置分配给若干个长度之最小公倍数为 $j$ 的方案数。
先来考虑局部转移：将 $d{p}_{i,j}$ 转移给 $d{p}_{i+k\cdot s,\mathrm{lcm}(j,s)}$，即在已经分配的 $i$ 个位置中再加入 $k$ 个长度为 $s$ 的轮换。对于位置的分配，可以转化为多重集 $\{i\cdot a_1,s\cdot a_2,\cdots ,s\cdot a_{k+1}\}$ 的排列数，即 $\frac{(i+k\cdot s)!}{{s!}^{k}i!}$。而对于编号的分配，也就是置换环的边“交错情况”的分配，考虑第一个点有 $(n-1)$ 种终点，第二个有 $(n-2)$ 种，以此类推，单个置换环有 $(s-1)!$ 种，共 $((s-1)!{)}^k$ 种。这一项与上一项合并得到 $\frac{(i+k\cdot s)!}{s^{k}i!}$。此外，由于每个置换环位置确定后内容也确定，需要消去几个置换环仅仅互换位置的情况，即除以 $k!$，得到：

$$d{p}_{i+k\cdot s,\mathrm{lcm}(j,s)}=\sum d{p}_{i,j}\frac{(i+k\cdot s)!}{s{!}^{k}i!k!}$$

同时看到，在整体的转移过程中，得到 $d{p}_{i,j}$ 时必有分子 $i!$，这必将在下一步被消去，留下的 $n!$ 也将在统计答案时因平均被消去，所以每次转移的系数被消为 $\frac{1}{s{!}^{k}k!}$ ，这样最后不必再除 $n!$。

部分分代码

#include<bits/stdc++.h>
using namespace std;
unordered_map<long long,long long> dp[300];
unordered_map<long long,bool> vis[300];
long long n,p,t[300],tmaxn[300],inv[100100],invt[300];
long long gcd(long long a,long long b){
	long long tem=0;
	for(;a;){
		tem=a;
		a=b%a;
		b=tem;
	}
	return b;
}
long long lcm(long long a,long long b){
	return a*b/gcd(a,b);
}
long long qpow(long long x,long long y){
	if(!y) return 1;
	long long tem=qpow(x,y>>1);
	if(y&1) return x*tem%p*tem%p;
	else return tem*tem%p;
}
long long finv(long long x){
	if(x<min(p,1ll*100100)) return inv[x];
	else return qpow(x,p-2);
}
void dfs(long long x,long long y){
	if(!x){
		if(y>=100100) printf("%lld\n",y);
		return;
	}
	for(int i=1;i<=x;++i){
		dfs(x-i,lcm(y,i));
	}
}
int main(){
	freopen("perm.in","r",stdin);
	freopen("perm.out","w",stdout);
	scanf("%lld%lld",&n,&p);
	inv[0]=1;
	inv[1]=1;
	for(int i=2;i<min(p,1ll*100100);++i){
		inv[i]=(p-p/i)*inv[p%i]%p;
	}
	t[0]=1;
	for(int i=1;i<=n;++i){
		t[i]=t[i-1]*i%p;
	}
	invt[n]=qpow(t[n],p-2);
	for(int i=n-1;i;--i){
		invt[i]=invt[i+1]*(i+1)%p;
	}
	invt[0]=1;
	long long ans=0;
	dp[0][1]=1;
	vis[0][1]=1;
	for(int s=1;s<=n;++s){
		for(int i=n;i>=0;--i){
			for(int k=(n-i)/s;k;--k){
				for(auto j:vis[i]){
					if(!dp[i][j.first]) continue;
					vis[i+k*s][lcm(j.first,s)]=1;
					long long tem=dp[i][j.first]*finv(qpow(s,k))%p*invt[k]%p;
					dp[i+k*s][lcm(j.first,s)]=(dp[i+k*s][lcm(j.first,s)]+tem)%p;
				}
			}
		}
	}
	for(auto i:vis[n]){
		ans=(ans+dp[n][i.first]*(i.first)%p*(i.first)%p)%p;
	}
	printf("%lld",ans);
	return 0;
}

正解

我们发现由于 $\mathrm{lcm}$ 结果很多，上面做法会超时，考虑如果某个大于 $\sqrt{n}$ 的因子在 $\mathrm{lcm}$ 中出现的次数大于 $1$ 则这个长度必定大于等于这个因子的平方，也大于 $n$。因此，每种这样的因子最多只会出现一次。我们把剩下的因子结合起来，将每种 $\mathrm{lcm}$ 转换为这几个因子的 $\mathrm{lcm}$ 复合上其它因子的出现情况。每次将前者作为状态，将后者相同的同时转移，枚举复合上的前者，正常转移后将 $dp$ 的变化量乘上后者的平方(这样后面枚举的值会和前面复合)，统计答案时再复合上前者平方即可。

正解

#include<bits/stdc++.h>
using namespace std;
const long long pr[6]={2,3,5,7,11,13};
struct node{
	int pos,lft;
	friend bool operator < (node x,node y){
		return x.lft<y.lft;
	}
}data[300];
long long n,p,base[3000],bcnt,t[300],dp[300][9000],up[300][9000],maxn[300],inv[100100],invt[300];
long long gcd(long long a,long long b){
	long long tem=0;
	for(;a;){
		tem=a;
		a=b%a;
		b=tem;
	}
	return b;
}
inline long long lcm(long long a,long long b){
	return a*b/gcd(a,b);
}
long long qpow(long long x,long long y){
	if(!y)
	return 1;
	long long tem=qpow(x,y>>1);
	if(y&1) return x*tem%p*tem%p;
	else return tem*tem%p;
}
void dfs(int now,long long tim,long long sum){
	if(now==6){
		++bcnt;
		base[bcnt]=tim;
		return;
	}
	dfs(now+1,tim,sum);
	long long tem=1;
	for(;;){
		tem*=pr[now];
		if(sum+tem>n)
		break;
		dfs(now+1,tim*tem,sum+tem);
	}
}
int main(){
	freopen("perm.in","r",stdin);
	freopen("perm.out","w",stdout);
	scanf("%lld%lld",&n,&p);
	dfs(0,1,0);
	sort(base+1,base+bcnt+1);
	for(int i=1;i<=n;++i){
		data[i].pos=i;
		data[i].lft=i;
		for(int j=0;j<6;++j){
			for(;!(data[i].lft%pr[j]);){
				data[i].lft/=pr[j];
			}
		}
	}
	sort(data+1,data+n+1);
	inv[0]=1;
	inv[1]=1;
	for(int i=2;i<min(p,1ll*100100);++i){
		inv[i]=(p-p/i)*inv[p%i]%p;
	}
	long long ans=0;
	dp[0][1]=1;
	for(int lft=1,now=1;lft<=n;lft=now){
		for(int i=0;i<=n;++i){
			for(int j=1;j<=bcnt;++j){
				up[i][j]=dp[i][j];
			}
		}
		long long timr=data[lft].lft*data[lft].lft%p;
		for(;data[lft].lft==data[now].lft;++now){
			int s=data[now].pos;
			for(int j=bcnt;j;--j){
				int temlcm=lower_bound(base+1,base+bcnt+1,lcm(base[j],data[now].pos/data[now].lft))-base;
				if(temlcm>bcnt) continue;
				for(int i=n-s;i>=0;--i){
					if(!up[i][j]) continue;
					int temi=i+s;
					long long div=inv[s];
					for(int k=1;temi<=n;++k,temi+=s,div=div*inv[s]%p*inv[k]%p){
						up[temi][temlcm]=(up[temi][temlcm]+up[i][j]*div)%p;
					}
				}
			}
		}
		for(int i=0;i<=n;++i){
			for(int j=1;j<=bcnt;++j){
				dp[i][j]=(dp[i][j]+timr*(up[i][j]-dp[i][j]))%p;
			}
		}
	}
	for(int i=1;i<=bcnt;++i){
		ans=(ans+dp[n][i]*base[i]%p*base[i])%p;
	}
	ans=(ans+p)%p;
	printf("%lld",ans);
	return 0;
}