组合数计算总结

一、 一般组合数计算

利用

的据算公式进行运算，简单明了。利用乘法与除法的同时运行，有效地降低溢出（除法能整除的保证：每i个数中必有一个是i的倍数）。只能对最后的结果进行取模，无法在运算时取模，虽然求取的时候转化为了ans* ans’ * ans’’……的形式，虽然连乘运算可以逐步取模，但如果对ans取模，将无法保证下一步的除法能整除，所以不可取。

时间复杂度：O(m)

mod的要求：无

有效范围：1<=n,m<=60

——————————————————————————————————

//一般方法求C（n，m）最后取模。C(62,28)溢出。有效范围1<n,m<=60
ll CNormal(int n, int m)
{
if ( m>n ) return 0;
ll ans = 1;
for (int i=1; i<=m; i++)
{
ans *= (n – m + i);
ans /= i;
}
return ans % mod;
}

Ps：ans *= (n – m + i)也可用ans *= (n – I + 1)，但前者更小

二、 杨辉三角计算组合数

利用杨辉三角与组合数之间的关系进行逐步求解组合数，弥补了中间结果无法取模的缺点，但时间复杂度高。可以逐步取模，无溢出。

时间复杂度：O(n*m)

mod的要求：无

有效范围：1<=n,m<=1000

——————————————————————————————————

//杨辉三角求C（n，m）
ll matrix[110][110]={0};
ll CMatrix(int n, int m)
{
if ( m>n ) return 0;
ll ans = 0;
matrix[1][0] = matrix[1][1] = 1;
for (int i=2; i<=n; i++)
{
int k = min(i, m);
for(int j=0; j<=k; j++)
{
if ( j==0 || j==i )	matrix[i][j] = 1;
else matrix[i][j] = (matrix[i-1][j] + matrix[i-1][j-1]) % mod;
}
}
return matrix
[m];
}

三、 利用乘法逆元求组合数

逆元定义：a*b=1，则称b为a的乘法逆元。

而在同一个mod下，可以使a的逆元为一个整数，a*b%mod ≡1，则b为a在mod下的乘法逆元。由此，可将 计算公式转化为全为乘法的式子，如此，便可以实现逐步取模。

由费马小定理知，p是质数，且Gcd(a,p)=1，那么a^(p-1) ≡ 1（modp），因此易知a*a^(p-2)= 1(mod p)，则，a^(p-1)即为a在p下的乘法逆元。

时间复杂度：O(m*log(m))

mod的要求：mod为素数，且m<mod或GCD(mod, m)=1

有效范围：1<=n,m<=10^6

——————————————————————————————————

//获得a在mod下的乘法逆元
ll GetInverse(ll a, ll mod)
{
ll ans = 1, n = mod - 2;
a %= mod;
while ( n )
{
if ( n&1 ){
ans = ans * a % mod;
}
n >>= 1;
a = a * a % mod;
}
return ans;
}

//逆元求C（n，m）%mod
ll C(ll n, ll m)
{
if ( m>n ) return 0;
ll ans = 1;
for (int i=1; i<=m; i++)
{
ll a = (n + i - m) % mod;
ll b = i % mod;
ans = ans * (a * GetInverse(b, mod) % mod) % mod;
}
return ans;
}

四、 分解因子求组合数


，利用同底数的指数的除法即指数相减的原理讲式子转化为乘法，从而实现逐步取模。即求出n!,(n-m)!,m!中的所有素数因子并计算。

时间复杂度：O(n)

mod的要求：无（可为合数）

有效范围：1<=n,m,p<=10^6

——————————————————————————————————

// 求素数表
int prime[1000000] = {0};
bool isPrime[1000000];
void getPrime(int maxn)
{
int n = 0;
memset(isPrime, true, sizeof(isPrime));
for (int i=2; i<=maxn; i++)
{
if ( isPrime[i] )
{
prime[n++] = i;
for (int j=i*2; j<=maxn; j+=i) isPrime[j] = false;
}
}
}

//快速幂
long long myPow(long long a,long long b)
{
long long r=1, base=a % mod;
while ( b )
{
if ( b&1 ){
r *= base;
r %= mod;
}
base *= base;
base %= mod;
b >>= 1;
}

return r;
}

//获得n！中因子p的个数
ll getPNum(ll n, ll p)
{
ll ans = 0;
while ( n )
{
ans += n / p;
n /= p;
}
return ans;
}

//利用因子求C(n,m)
ll CFactor(ll n, ll m)
{
if ( m>n ) return 0;
ll ans = 1;
for (int i=0; prime[i]!=0 && prime[i]<=n; i++)
{
ll a = getPNum(n, prime[i]);
ll b = getPNum(m, prime[i]);
ll c = getPNum(n - m, prime[i]);
a -= (b + c);
ans *= myPow(prime[i], a);
ans %= mod;
}
return ans;
}

五、 Lucas定理*

Lucas定理：如果p为素数，且





那么


由此定理，再结合乘法逆元就可以实现在逐步取模的基础上将计算量大大减少，且可以保证所有的 ，即 与p互质，从而避免了乘法逆元不存在的特殊情况。此方法在p较小的时候能发挥很大的作用。

时间复杂度：

mod的要求：素数

有效范围：1<=n,m,p<=10^9

——————————————————————————————————

//利用lucas定理求C（n，m）
ll CLucas(ll n, ll m)
{
//if ( m==0 ) return 1;
//return C(n % mod, m % mod) * CLucas(n / mod, m / mod) % mod;

ll ans = 1;
while ( m )
{
ans = ans * C(n % mod, m % mod) % mod;
n /= mod;
m /= mod;
}
return ans;
}

半预处理型

由于Lucas定理保证了阶乘的数均小于p，所以可以讲所有的阶乘先预处理，优化C（n,m）

mod的要求：p<10^6，且为素数

有效范围：1<=n,m<=10^9

——————————————————————————————————

//半预处理
const ll MAXN = 100000;
ll fac[MAXN+100];
void init(int mod)
{
fac[0] = 1;
for (int i=1; i<mod; i++){
fac[i] = fac[i-1] * i % mod;
}
}

//半预处理逆元求C（n，m）%mod
ll C(ll n, ll m)
{
if ( m>n ) return 0;
return fac
* (GetInverse(fac[m]*fac[n-m], mod)) % mod;
}

全预处理型

若数据组数较多，且p较小（<10^4），则可以预处理所有可能的阶乘并进行计算

mod的要求：p<10^4，且为素数

有效范围：1<=n,m<=10^9

——————————————————————————————————

//阶乘预处理
int prime[10000+10] = {0};
bool isPrime[10000+10];
int inverse[10000][1250] = {0};
int fac[10000][1250] = {0};
void init(int maxn)
{
int n = 0;
memset(isPrime, true, sizeof(isPrime));
for (int i=2; i<maxn; i++)
{
if ( isPrime[i] )
{
prime[i] = n;
for (int j=i*2; j<maxn; j+=i) isPrime[j] = false;

//计算逆元
inverse[0]
= inverse[1]
= 1;
for (int j=2; j<i; j++)
{
inverse[j]
= (i - i/j) * inverse[i%j]
% i;
}

//预处理阶乘
fac[0]
= fac[1]
= 1;
for (int j=2; j<i; j++)
{
fac[j]
= j * fac[j-1]
% i;//普通阶乘
inverse[j]
= inverse[j]
* inverse[j-1]
% i;//逆元阶乘
}

n++;
}
}
}

//全预处理求C（n，m）%mod
ll C(int n, int m)
{
if ( m>n ) return 0;
int num = prime[i];
return (ll)fac
[num] * inverse[m][num] % i * inverse[n-m][num] % i;
}