组合数

从个不同元素种取出个元素的所有不同组合的个数，叫做从个不同元素种取出个元素的组合数，用符号表示。1

基本公式

并且

性质

很好理解， 第一个式子可以看作选取之前没有选取的元素的方案就等于之前的方案，因为它们之间是一一对应的。 第二个式子可以看作把当前选取方案拆分成两部分，一部分含有特定元素，一部分不含特定元素，就能将当前方案数不重不漏地分好。

求和公式

证明：

当时，。 假设时成立，即 成立 当时， 所以等式对都成立。

求解方法

求

递推式求解

直接应用 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//Author: CodeBoy

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 2010,mod = 1e9+7;
int C[N][N];
void init(){
    for(int i=0;i<N;i++){
        for(int j=0;j<=i;j++){
            if(j==0) C[i][j] = 1;
            else{
                C[i][j] = (C[i-1][j-1]+C[i-1][j]) % mod;
            }
        }
    }
}
int main(){
    init();
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        cout<<C[a][b]<<endl;
    }
    return 0;
}

预处理阶乘及其逆元

原理: 因 为质数,所以逆元可用费马小定理求 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//Author: CodeBoy

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;
const int N = 100010, mod =1e9+7;
int fact[N],invfact[N];
ll qpow(ll a,int b,int p){ //因为a会被算平方所以要用ll否则可能会溢出
    ll res=1;
    while(b){
        if(b&1) res = res * a % p;
        b>>=1;
        a = a*a % p;
    }
    return res;
}

int main(){
    fact[0] = invfact[0] = 1;
    for(int i=1;i<N;i++){ //递推阶乘及逆元
        fact[i] = (ll)fact[i-1] * i % mod;
        invfact[i] = (ll)invfact[i-1] * qpow(i,mod - 2 ,mod) % mod;
    }
    int n;
    scanf("%d",&n);
    while(n--){
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",(ll)fact[a]%mod * invfact[b]%mod * invfact[a-b]%mod); //查表输出答案
    }
    return 0;
}

Lucas定理求模意义下组合数

Lucas 定理是同余理论中的一个很重要的定理，用于组合数取模。常常使用在问题的结果需要对某个数据取模， 很大，达到 以上，但是 在 以内。一般来说最好的效果实在 以内。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//Author: CodeBoy

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
int qpow(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;
}
LL C(LL a, LL b, int p)
{
    if(b > a) return 0;
    if(b > a - b) b = a - b;
    LL x = 1, y = 1;
    for(int i = 0; i < b; i++)
    {
        x = x * (a - i) % p;
        y = y * (i + 1) % p;
    }
    return x * qpow(y, p - 2, p) % p;
}
int lucas(LL a, LL b, int p)
{
    if (a < p && b < p) return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p; //递归求解, 多次使用 Lucas 定理加快速度
}
int main(){
    int n;
    cin >> n;

    while (n -- )
    {
        LL a, b;
        int p;
        cin >> a >> b >> p;
        cout << lucas(a+b, b, p) << endl;
    }
    return 0;
}

Lucas 定理的证明

2 考虑 的取值，注意到 ，分子的质因子分解中 次项恰为 ，因此只有当 或 的时候 的质因子分解中含有 ，因此 。进而我们可以得出

注意过程中没有用到费马小定理，因此这一推导不仅适用于整数，亦适用于多项式。因此我们可以考虑二项式 的结果

考虑二项式 ，那么 就是求其在 次项的取值。使用上述引理，我们可以得到

注意前者只有在 的倍数位置才有取值，而后者最高次项为 ，因此这两部分的卷积在任何一个位置只有最多一种方式贡献取值，即在前者部分取 的倍数次项，后者部分取剩余项，即 。

参考