HRC 003 T3 置换

题目链接

HRC 是啥

HZOI Regular Contest

前置知识

置换

轮换

\(60\space\text{pts}\) 解法

就像对于一个数，我们经常从素因子之积的角度看待它一样，在这道题中，我们从轮换的角度看待置换。

我们考虑一个轮换变成恒等变换所需次数：一个长度为 \(l\) 轮换，可以看做一个边数为 \(l\) 的环，置换乘法可以看做数字沿着边转一圈。假设某一条边的终点处的数字一开始为 \(k\)，那么这条边的起点的位置编号一定是 \(k\)。以轮换 \((3,1,2)\) 为例，边 \(3\rightarrow1\)（位置编号）为例，起点的位置编号为 \(3\)，终点一开始是 \(3\)。也就是说，一个数字从它开始的位置到达恒等变换的位置（位置编号也为这个数字），需要经过 \(l-1\) 条边，反映到幂次上，贡献为 \(l\)。

而对于整个置换，若变成恒等置换，则贡献为每个轮换长度的最小公倍数。答案即为每一种最小公倍数的平方与置换总数，即 \(n!\) 的商。

我们考虑统计出每一种最小公倍数的出现次数，设 \(dp_{i,j}\) 为将 \(i\) 个位置分配给若干个长度之最小公倍数为 \(j\) 的方案数。

先来考虑局部转移：将 \(dp_{i,j}\) 转移给 \(dp_{i+k\cdot s,\operatorname{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!\)，得到：

\[dp_{i+k\cdot s,\operatorname{lcm}(j,s)}=\sum{dp_{i,j}\frac{(i+k\cdot s)!}{s!^k i! k!}}
\]

同时看到，在整体的转移过程中，得到 \(dp_{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;
}

正解

我们发现由于 \(\operatorname{lcm}\) 结果很多，上面做法会超时，考虑如果某个大于 \(\sqrt{n}\) 的因子在 \(\operatorname{lcm}\) 中出现的次数大于 \(1\) 则这个长度必定大于等于这个因子的平方，也大于 \(n\)。因此，每种这样的因子最多只会出现一次。我们把剩下的因子结合起来，将每种 \(\operatorname{lcm}\) 转换为这几个因子的 \(\operatorname{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;
}