本文介绍了组合数的四种情况：Ⅰ，数据较小时，考虑打表。Ⅱ数据范围较大时，利用费马小定理求出逆元，进而做预处理，进而打表求解。Ⅲ当a与b的值非常大时，用卢卡斯定理简化。Ⅳ，高精度问题，利用质因数与逆元来化除为乘。
能在1s中跑过的数据(大概1e8次)，可以考虑预处理之后打表。
Ⅰ
思路：贴一张
代码：
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2010,mod=1e9+7;
int n,t[N][N];
//先将所有可能的结果计算出来，复杂度控制在在4e7，能过
void init()
{
for(int i=0;i<N;i++)
for(int j=0;j<=i;j++)
//j=0时，只有一种情况
if(!j) t[i][j]=1;
//公式
else t[i][j]=(t[i-1][j]+t[i-1][j-1])%mod;//先取模，防止溢出
return;
}
int main()
{
init();
cin >> n;
while(n--)
{
int a,b;
cin >> a >> b;
cout << t[a][b] << endl;
}
return 0;
}Ⅱ
当数据范围较大时，直接预处理可能会爆，所以可以做优化
思路：
代码：
#include<iostream>
#include<cstring>
using namespace std;
//对于可能会爆int的乘积都要做预处理，将其强转为long long类型
typedef long long LL;
const int N=100010,mod=1e9+7;
int n;
int fact[N],infact[N];
//快速幂
int quick_mi(int a,int k,int p)
{
int res=1;
while(k)
{
if(k & 1) res=(LL)res*a%p;
k>>=1;
a=(LL)a*a%p;
}
return res;
}
int main()
{
//0!=1，1的逆元也是1
fact[0]=infact[0]=1;
//预处理
for(int i=1;i<N;i++)
{
//求当前数的阶乘
fact[i]=(LL)fact[i-1]*i%mod;
//求当前数阶乘的逆元=上一个数的阶乘×当前数的逆元，是一个递推的过程
infact[i]=(LL)infact[i-1]*quick_mi(i,mod-2,mod)%mod;
}
cin >> n;
for(int i=0;i<n;i++)
{
int x,y;
cin >> x >> y;
//三个数相乘必会爆int，所以要提前%上mod
cout << (LL)fact[x]*infact[x-y]%mod*infact[y]%mod << endl;
}
return 0;
}
Ⅲ
当排列组合的数a、b较大时，预处理必会爆int。这里采用lucas定理。
前者由于b % p，所以b小于p，同理a也小于p。那么对于a、b都小于p的排列组合，可以直接通过逆元法求出即上面的组合数Ⅱ。而后者则可以通过反复调用lucas定理，使得b/p与a/p都在可控范围内，进而利用逆元法进行求解。
证明过程且看这位友友超级透彻的题解：AcWing 887. 求组合数 III - AcWing。
代码：
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
int n;
int quick_mi(int a,int b,int p)
{
int res=1;
while (b)
{
if(b & 1) res=(LL)res * a % p;
a=(LL)a * a % p;
b >>= 1;
}
return res;
}
int formale(int a,int b,int p)
{
if (b > a) return 0;
int res=1;
LL x=1,y=1;
//排列组合的公式，并且与分子约去了(a-b)!
for(int i = a ,j = 1 ; j <= b ;j ++ ,i -- )
{
//求出a进行b次的乘积，因为a！与(a-b)!可以与a！约去(a-b)!，进而a！只剩下b次乘法
x=(LL)x * i %p;
//求出b的阶乘
y=(LL)y * j % p;
}
//求出a与b的排列组合。即 [(a)*(a-1)...*(a-b+1)]*(b!)的逆元
res=(LL)x * quick_mi(y,p-2,p) % p;
return res;
}
int lucass(LL a,LL b,int p)
{
//如果优化到了a < b那么即可直接调用排列组合公式进行求解。
if(a < p && b < p) return formale(a,b,p);
return (LL)formale(a % p ,b % p, p) * lucass(a / p, b / p, p) % p;
}
int main()
{
cin >> n;
while(n--)
{
LL a,b,p;
cin >> a >> b >> p;
cout << lucass(a,b,p) << endl;
}
return 0;
}
Ⅳ
高精度问题
在这里讲述一下求出每个质因子出现次数的意义在哪里。再求a和b的排列组合时，根据原始公式也就是a! / ((a-b)!*b!)那么，如果a的阶乘里含有质因子x的个数为19，(a-b)!含有质因子x的个数为8,b!里含有质因子x的个数为10，那么对于a! / ((a-b)!*b!)的结果，最后含有质因子x的个数也就为1（分母所含质因子x的个数减去分母所含质因子x的个数），同理我们可以通过质因子约数求出结果所含其它质因子的个数，那么将这所有质因子^个数 的乘积也就是排列组合的结果。
也就变高精度乘法与除法 为 高精度乘法，增加效率，简化代码。
那么质因子的个数该如何求去呢？我们不可能先将阶乘a的结果求出，然后再分解质因数，因为对于本题分子或者分母的阶乘必会爆int，那么我们可以通过分解来求，
举个例子：分解8！的阶乘的质因数
①：直接求，8！=40320=2^7*3^2*5^1*7^1,那么8！中质因子2的个数为7，3的个数为2，5个数为1，7的个数为1。
②：分解来求，先通过线性筛，筛出8以内的质数为2,3,5,7，那么8!以内2的个数为8/2+8/(2^2)+8/(2^3)+8/(2^4).....8/(2^k),上述乘法全部向下取整则有：4+2+1+0...+0=7，同理3的个数为8/(3^1)+8/(3^2)+....8/(3^k)=2+0+..+0=2,同理可以求得5的个数为1，7的个数为1。
复杂度：
上面①和②的求法时间复杂度分别是：①：求8的阶乘时间复杂度为O(n)，分解质因子的复杂度为O(n*sqrt(n))总体为O(n*sqrt(n))，是线性的；②线性筛的时间复杂度为O(n)，分解求质因子个数的时间复杂度为log(n)，那么总体为O(n)。空间复杂度：①∞，②<n
那么显而易见低于高精度而言应当采取分解来求，公式见这位大佬的总结：AcWing 888. 求组合数 IV(高精度-素数组合) - AcWing
代码：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=5010;
int primes[N],prime_sum[N],ans=0;
bool st[N];
//线性筛质数
void get_primes(int n)
{
for(int i=2; i <= n; i++)
{
if(!st[i]) primes[ans++]=i;
for(int j=0; primes[j] <= n / i; j++)
{
st[i * primes[j]] = true;
if(i % primes[j] == 0) break;
}
}
}
//公式
int get(int n,int p)
{
int ans=0;
while(n)//n==0时，后续的值全为0，则+0无意义
{
ans += n / p;
n /= p;
}
return ans;
}
//高精度乘法
vector<int> mul(vector<int> p,int q)
{
int t = 0;
vector<int> c;
//放入数组时，是从后向前放，那么再做乘法的时候即从前（个位）向后算
for(int i = 0; i < p.size(); i++)
{
t += p[i] * q;
c.push_back(t%10);
t /= 10;
}
while(t)
{
c.push_back(t % 10);
t /= 10;
}
//while(c.size > 1 && c.back() == 0) c.pop_back();去除前导零，当b=0时才需要这一步
return c;
}
int main()
{
int a,b;
cin >> a >> b;
get_primes(a);
for(int i = 0; i < ans; i ++ )
{
int p = primes[i];
//得到质数p的总个数
prime_sum[i] = get(a,p) - get(a-b,p) - get(b,p);
}
vector<int> p;
//先将1放进去，以便做乘法
p.push_back(1);
//枚举不同质数^个数 之间的乘积
for(int i = 0; primes[i] != 0; i ++ )
for(int j = 0; j < prime_sum[i]; j ++ ) //一个一个乘，简化代码
p = mul(p,primes[i]);
for(int i = p.size() - 1; i >= 0; i -- ) cout << p[i];
return 0;
}满足条件的01序列
代码：
最朴素版的思路与代码，300ms
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
//快速幂
int quick_mi(int a,int k,int p)
{
int res = 1;
while(k)
{
if(k & 1) res = (LL)res*a%p;
a = (LL) a*a%p;
k >>= 1;
}
return res;
}
int main()
{
int n;
cin >> n;
//求出分子的阶乘
int res = 1;
for(int i = 1; i <= 2*n; i ++) res = (LL)res*i%mod;
//求出分母的逆元-变除为乘
int cnt=1;
for(int i = 1; i <= n; i ++ ) cnt = (LL)cnt*quick_mi(i, mod-2, mod)%mod;
//除以（n+1）也要求出其逆元再乘，因为前面是不断取模的过程，所以直接除必然wa掉
cout << (LL)res%mod*cnt%mod*(LL)cnt%mod*quick_mi(n+1,mod-2,mod)%mod << endl;
return 0;
}思路优化，但时间不变，302ms
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
int quick_mi(int a,int k,int p)
{
int res = 1;
while(k)
{
if(k & 1) res = (LL)res*a%p;
a = (LL) a*a%p;
k >>= 1;
}
return res;
}
int main()
{
int n;
cin >> n;
int res = 1;
int a=2*n,b=n;
//边求阶乘的同时，边与分子的逆元相乘。遍历结束时即为分子与分母逆元的乘积
for(int i = a,j = 1; j <= b; j ++, i -- )
{
res=(LL)res * i % mod;
res=(LL)res * quick_mi(j, mod-2, mod) % mod;
}
cout << (LL)res*quick_mi(n+1,mod-2,mod)%mod << endl;
return 0;
}究极优化：16ms
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
int quick_mi(int a,int k,int p)
{
int res = 1;
while(k)
{
if(k & 1) res = (LL)res*a%p;
a = (LL) a*a%p;
k >>= 1;
}
return res;
}
int main()
{
int n;
cin >> n;
int a=2*n,b=n;
//先求出分子与分母的阶乘
int x=1,y=1;
for(int i = a,j = 1; j <= b; j ++, i -- )
{
x=(LL)x * i % mod;
y=(LL)y * j % mod;
}
//最后分母的阶乘，与分子阶乘的逆元相乘。
//三数相乘需要多次取模，以防爆int
cout << (LL)x * quick_mi(y,mod-2,mod) % mod * quick_mi(n+1,mod-2,mod)%mod << endl;
return 0;
}我们可以发现，第三个代码的快速幂只调用了一次，进而降低时间
扫一扫
512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
