[BZOJ2111][ZJOI2010]Perm 排列计数 && 数学_[zjoi2010]排列计数-优快云博客

本文链接：https://blog.youkuaiyun.com/shiyukun1998/article/details/44774359

本文介绍了一种利用二叉堆的特性进行动态规划的方法，通过递归分解问题并结合组合数学中的组合数计算，最终求解特定序列的计数问题。文中详细阐述了状态转移方程及如何通过卢卡斯定理处理模意义下的组合数计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通过长时间的盯着看我们可以看出这个序列的大小于关系类似于一个二叉堆那么我们可以由此dp统计方案

转移方程

son[i] = son[i<<1] + son[i<<1|1] + 1

d[i] = C(son[i]-1, son[i<<1]) * d[i<<1] * d[i<<1|1]

那么剩下的问题就是求组合数了由于n的阶乘可能是p的倍数那么我们的线性推逆元就会出现错误所以我们需要用卢卡斯定理把组合数的n和k 映射到p的模系中内容如下

C(n, k) = C(n/p, k/p) * C(n%p, k%p) % MOD

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define SF scanf
#define PF printf
#define ls (i << 1)
#define rs (i << 1 | 1)
using namespace std;
typedef long long LL;
const int MAXN = 1000000;
int n, MOD, son[MAXN*2+10];
LL fac[MAXN+10], inv[MAXN+10], d[MAXN*2+10];
LL pow_mod(LL x, int k) {
    LL ret = 1;
    while(k) {
        if(k & 1) ret = ret * x % MOD;
        x = x * x % MOD;
        k >>= 1;
    }
    return ret;
}
LL C(int n, int k) {
    if(k == 0) return 1;
    if(n < k) return 0;
    if(n < MOD && k < MOD) return fac[n] * inv[k] % MOD * inv[n-k] % MOD;
    else return C(n/MOD, k/MOD) * C(n % MOD, k % MOD) % MOD;
}
int main() {
    SF("%d%d", &n, &MOD);
    int m = min(n, MOD-1);
    fac[0] = 1;
    for(int i = 1; i <= m; i++) fac[i] = fac[i-1] * i % MOD;
    inv[m] = pow_mod(fac[m], MOD-2);
    for(int i = m-1; i >= 0; i--) inv[i] = inv[i+1] * (i+1) % MOD;
    for(int i = n; i >= 1; i--) {
        son[i] = son[ls] + son[rs] + 1;
        LL t = (ls > n ? 1 : d[ls]) * (rs > n ? 1 : d[rs]) % MOD;
        d[i] = t * C(son[i] - 1, son[ls]) % MOD;
    }
    cout << d[1];
}