ucas定理

首先给出这个Lucas定理：

 

A、B是非负整数，p是质数。AB写成p进制：A=a[n]a[n-1]...a[0]，B=b[n]b[n-1]...b[0]。
则组合数C(A,B)与C(a[n],b[n])*C(a[n-1],b[n-1])*...*C(a[0],b[0])  modp同余

即：Lucas(n,m,p)=c(n%p,m%p)*Lucas(n/p,m/p,p) 

  Lucas(n,m,p)=C(n,m)%p(p是素数)

（补充：C(n,m)=C(n-1,m-1)+C(n-1,m)如果n,m的值不是很大，可以用迭代法打表）

这个定理的证明不是很简单，我一直想找个很好的张明，但是，没找到，昨天看到了一个解题报告，基本上可以说明白这个Lucas定理是怎么回事了，具体的是说：

以求解n! %p为例，把n分段，每p个一段，每一段求的结果是一样的。但是需要单独处理每一段的末尾p, 2p,...，把p提取出来，会发现剩下的数正好又是(n /p)!，相当于划归成了一个子问题，这样递归求解即可。

这个是单独处理n!的情况，当然C(n,m)就是n!/(m!*(n-m)!)，每一个阶乘都用上面的方法处理的话，就是Lucas定理了，注意这儿的p是素数是有必要的。

Lucas最大的数据处理能力是p在10^5左右，不能再大了，hdu3037就是10^5级别的！

对于大组合数取模，n,m不大于10^5的话，用逆元的方法，可以解决。对于n,m大于10^5的话，那么要求p<10^5，这样就是Lucas定理了，将n,m转化到10^5以内解。

然后再大的数据，我就不会了！

贴一个例题的代码，方便以后看。

hdu3037

将不大于m颗种子存放在n颗树中，问有多少种存法。

首先是不大于m颗种子，我没可以认为少于m的那些种子存放在了第n+1颗树上，这样的话，问题就转化成了将m颗种子存放在n+1颗树上的方案数。ok这个是组合数学里面的公式，亦即插板法，也就是X1+X2+X3+……+Xn+1= m;ok，答案是C(n+m,m);

然后就是上面说的Lucas定理解决大组合数问题了

 

[cpp]  view plain copy print ?

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4. 
   
5. using namespace std;  
6.   
7. #define N 100010  
8.   
9. long long mod_pow(int a,int n,int p)  
10. {  
11.     long long ret=1;  
12.     long long A=a;  
13.     while(n)  
14.     {  
15.         if (n & 1)  
16.             ret=(ret*A)%p;  
17.         A=(A*A)%p;  
18.         n>>=1;  
19.     }  
20.     return ret;  
21. }  
22.   
23. long long factorial[N];  
24.   
25. void init(long long p)  
26. {  
27.     factorial[0] = 1;  
28.     for(int i = 1;i <= p;i++)  
29.         factorial[i] = factorial[i-1]*i%p;  
30.     //for(int i = 0;i < p;i++)  
31.         //ni[i] = mod_pow(factorial[i],p-2,p);  
32. }  
33.   
34. long long Lucas(long long a,long long k,long long p) //求C(n,m)%p p最大为10^5。a,b可以很大！  
35. {  
36.     long long re = 1;  
37.     while(a && k)  
38.     {  
39.         long long aa = a%p;long long bb = k%p;  
40.         if(aa < bb) return 0; //这个是最后的改动！  
41.         re = re*factorial[aa]*mod_pow(factorial[bb]*factorial[aa-bb]%p,p-2,p)%p;//这儿的求逆不可先处理  
42.         a /= p;  
43.         k /= p;  
44.     }  
45.     return re;  
46. }  
47.   
48. int main()  
49. {  
50.     int t;  
51.     cin >> t;  
52.     while(t--)  
53.     {  
54.         long long n,m,p;  
55.         cin >> n >> m >> p;  
56.         init(p);  
57.         cout << Lucas(n+m,m,p) << "\n";  
58.     }  
59.     return 0;  
60. }  
61. 
    
    
    
    适用于大整数（10^9）的Lucas定理
    #include <cstdio> 

    #include <cstring> 

    #include <algorithm> 

    #include <cmath> 

    #include <iostream> 

    using namespace std;  

    typedef long long long long;  

    long long p,m,n;  

    long long Pow(long long a,long long b)   { 

        long long ans=1; 

        while(b){ 

            if(b&1){ 

                b--; 

                ans=(ans*a)%p;  

            }  

            else{  

                b/=2; 

                a=(a*a)%p; 

            }  

        } 

        return ans; 

    }  

    long long C(long long n,long long m){  

        if(n<m) 

            return 0;  

        long long ans=1; 

        for(inti=1;i<=m;i++){  

            ans=ans*(((n-m+i)%p)*Pow(i,p-2)%p)%p; 

        } 

        return ans; 

    }  

    long long Lucas(long long n,long long m){ 

        if(m==0) 

            return 1;  

        returnLucas(n/p,m/p)*C(n%p,m%p)%p;  

    }  

    int main(){  

        while(scanf("%lld%lld%lld",&n,&m,&p)!=EOF){ 

            printf("%lld\n",Lucas(n-m+1,m)); 

        } 

        return 0; 

    }