【 Lucas定理 】 组合数取模

最新推荐文章于 2021-11-29 23:51:30 发布
最新推荐文章于 2021-11-29 23:51:30 发布
阅读量564 收藏
点赞数
分类专栏： 模板 数论

转自：ACdreamers



组合数取模在ACM竞赛中是一个很重要的问题，很多选手因为数据太大而束手无策，今天就来详细讲解它。

 

组合数取模就是求的值，当然根据，和的取值范围不同，采取的方法也不一样。

 

接下来，我们来学习一些常见的取值情况

 

（1）和

 

     这个问题比较简单，组合数的计算可以靠杨辉三角，那么由于和的范围小，直接两层循环即可。

 

（2）和，并且是素数

 

     这个问题有个叫做Lucas的定理，定理描述是，如果

 

     

 

     那么得到

 

     

   

     这样然后分别求，采用逆元计算即可。

 

 

题目：http://acm.fzu.edu.cn/problem.php?pid=2020

 

题意：求，其中，并且是素数。

 

代码：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <string.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6. typedef long long LL;  
  7.   
  8. LL n,m,p;  
  9.   
  10. LL quick_mod(LL a, LL b)  
  11. {  
  12.     LL ans = 1;  
  13.     a %= p;  
  14.     while(b)  
  15.     {  
  16.         if(b & 1)  
  17.         {  
  18.             ans = ans * a % p;  
  19.             b--;  
  20.         }  
  21.         b >>= 1;  
  22.         a = a * a % p;  
  23.     }  
  24.     return ans;  
  25. }  
  26.   
  27. LL C(LL n, LL m)  
  28. {  
  29.     if(m > n) return 0;  
  30.     LL ans = 1;  
  31.     for(int i=1; i<=m; i++)  
  32.     {  
  33.         LL a = (n + i - m) % p;  
  34.         LL b = i % p;  
  35.         ans = ans * (a * quick_mod(b, p-2) % p) % p;  
  36.     }  
  37.     return ans;  
  38. }  
  39.   
  40. LL Lucas(LL n, LL m)  
  41. {  
  42.     if(m == 0) return 1;  
  43.     return C(n % p, m % p) * Lucas(n / p, m / p) % p;  
  44. }  
  45.   
  46. int main()  
  47. {  
  48.     int T;  
  49.     scanf("%d", &T);  
  50.     while(T--)  
  51.     {  
  52.         scanf("%I64d%I64d%I64d", &n, &m, &p);  
  53.         printf("%I64d\n", Lucas(n,m));  
  54.     }  
  55.     return 0;  
  56. }  


由于上题的比较大，所以组合数只能一个一个计算，如果的范围小点，那么就可以进行阶乘预处理计算了。

 

（3）和，并且可能为合数

 

    这样的话先采取暴力分解，然后快速幂即可。

 

题目：http://acm.nefu.edu.cn/JudgeOnline/problemshow.php?problem_id=628

 

代码：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <string.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6. typedef long long LL;  
  7. const int N = 200005;  
  8.   
  9. bool prime[N];  
  10. int p[N];  
  11. int cnt;  
  12.   
  13. void isprime()  
  14. {  
  15.     cnt = 0;  
  16.     memset(prime,true,sizeof(prime));  
  17.     for(int i=2; i<N; i++)  
  18.     {  
  19.         if(prime[i])  
  20.         {  
  21.             p[cnt++] = i;  
  22.             for(int j=i+i; j<N; j+=i)  
  23.                 prime[j] = false;  
  24.         }  
  25.     }  
  26. }  
  27.   
  28. LL quick_mod(LL a,LL b,LL m)  
  29. {  
  30.     LL ans = 1;  
  31.     a %= m;  
  32.     while(b)  
  33.     {  
  34.         if(b & 1)  
  35.         {  
  36.             ans = ans * a % m;  
  37.             b--;  
  38.         }  
  39.         b >>= 1;  
  40.         a = a * a % m;  
  41.     }  
  42.     return ans;  
  43. }  
  44.   
  45. LL Work(LL n,LL p)  
  46. {  
  47.     LL ans = 0;  
  48.     while(n)  
  49.     {  
  50.         ans += n / p;  
  51.         n /= p;  
  52.     }  
  53.     return ans;  
  54. }  
  55.   
  56. LL Solve(LL n,LL m,LL P)  
  57. {  
  58.     LL ans = 1;  
  59.     for(int i=0; i<cnt && p[i]<=n; i++)  
  60.     {  
  61.         LL x = Work(n, p[i]);  
  62.         LL y = Work(n - m, p[i]);  
  63.         LL z = Work(m, p[i]);  
  64.         x -= (y + z);  
  65.         ans *= quick_mod(p[i],x,P);  
  66.         ans %= P;  
  67.     }  
  68.     return ans;  
  69. }  
  70.   
  71. int main()  
  72. {  
  73.     int T;  
  74.     isprime();  
  75.     cin>>T;  
  76.     while(T--)  
  77.     {  
  78.         LL n,m,P;  
  79.         cin>>n>>m>>P;  
  80.         n += m - 2;  
  81.         m--;  
  82.         cout<<Solve(n,m,P)<<endl;  
  83.     }  
  84.     return 0;  
  85. }  


 

接下来看一些关于组合数取模的典型题目。

 

题目：http://acm.hdu.edu.cn/showproblem.php?pid=3944

 

分析：组合数取模的典型题目，用Lucas定理，注意要阶乘预处理，否则会TLE的。

 

 

题目：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4536

 

题意：给一个集合，一共个元素，从中选取个元素，选出的元素中没有相邻的元素的选法一共有多少种？

 

分析：典型的隔板法，最终答案就是。然后用Lucas定理处理即可。

 

 

题目：http://acm.hdu.edu.cn/showproblem.php?pid=4373

 

题意：个for循环嵌套，有两种形式，第一类从1开始到，第二类从上一层循环当前数开始到，第一层一定

     是第一种类型，求总的循环的次数对364875103取余的结果。

 

分析：首先可以看出，每一个第一类循环都是一个新的开始，与前面的状态无关，所以可以把个嵌套分为几个不

     同的部分，每一个部分由第一类循环开始，最终结果相乘即可。剩下的就是第二类循环的问题，假设一个

     层循环，最大到，分析一下得到如下结果

    

     （1）只有一层，则循环次数为

 

     （2）只有前两层，则循环次数为

 

         

 

     （3）只有前三层，则循环次数为

 

         

 

      由此得到结论：第的循环次数为

 

代码：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <string.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6. typedef long long LL;  
  7.   
  8. const int N = 25;  
  9. const int MOD1 = 97;  
  10. const int MOD2 = 3761599;  
  11. const int MOD = MOD1 * MOD2;  
  12.   
  13. int m,n,k;  
  14. int a[N];  
  15. LL fac1[MOD1+10];  
  16. LL fac2[MOD2+10];  
  17. LL inv1,inv2;  
  18.   
  19. LL quick_mod(LL a,LL b,LL m)  
  20. {  
  21.     LL ans = 1;  
  22.     a %= m;  
  23.     while(b)  
  24.     {  
  25.         if(b & 1)  
  26.         {  
  27.             ans = ans * a % m;  
  28.             b--;  
  29.         }  
  30.         b >>= 1;  
  31.         a = a * a % m;  
  32.     }  
  33.     return ans;  
  34. }  
  35.   
  36. LL C(LL n,LL m,LL p,LL fac[])  
  37. {  
  38.     if(n < m) return 0;  
  39.     return fac[n] * quick_mod(fac[m] * fac[n-m], p - 2, p) % p;  
  40. }  
  41.   
  42. LL Lucas(LL n,LL m,LL p,LL fac[])  
  43. {  
  44.     if(m == 0) return 1;  
  45.     return C(n % p, m % p, p, fac) * Lucas(n / p, m / p, p, fac);  
  46. }  
  47.   
  48. void Init()  
  49. {  
  50.     fac1[0] = fac2[0] = 1;  
  51.     for(int i=1; i<MOD1; i++)  
  52.         fac1[i] = (fac1[i-1] * i) % MOD1;  
  53.     for(int i=1; i<MOD2; i++)  
  54.         fac2[i] = (fac2[i-1] * i) % MOD2;  
  55.     inv1 = MOD2 * quick_mod(MOD2, MOD1-2, MOD1);  
  56.     inv2 = MOD1 * quick_mod(MOD1, MOD2-2, MOD2);  
  57. }  
  58.   
  59. int main()  
  60. {  
  61.     Init();  
  62.     int T, tt = 1;  
  63.     scanf("%d",&T);  
  64.     while(T--)  
  65.     {  
  66.         scanf("%d%d%d",&n,&m,&k);  
  67.         for(int i=0; i<k; i++)  
  68.             scanf("%d",&a[i]);  
  69.         a[k] = m;  
  70.         LL ans = 1;  
  71.         for(int i=0; i<k; i++)  
  72.         {  
  73.             LL m1 = Lucas(a[i+1] - a[i] + n - 1, a[i+1] - a[i], MOD1, fac1);  
  74.             LL m2 = Lucas(a[i+1] - a[i] + n - 1, a[i+1] - a[i], MOD2, fac2);  
  75.             LL mm = (m1 * inv1 + m2 * inv2) % MOD;  
  76.             ans = ans * mm % MOD;  
  77.         }  
  78.         printf("Case #%d: ",tt++);  
  79.         cout<<ans<<endl;  
  80.     }  
  81.     return 0;  
  82. }  


 

题目：http://acm.hdu.edu.cn/showproblem.php?pid=4349

 

题意：中有多少个奇数，其中。

 

分析：其实组合数判断奇偶性有一个优美的结论

          

            如果，那么为奇数，否则为偶数

 

            当然本题要判断的组合数很多，所以不能用上述结论，只能另辟蹊径。由于是判断奇偶性，那么就是判断

     是否为1，利用Lucas定理，先把和化为二进制，这样它们都是01序列了。我们又知道

     。这样中为0的地方对应的中的位置只有一种可能，那就是0。

 

      这样我们可以不用管中为0的地方，只考虑中为1的位置，可以看出，中为1的位置对应的中为0

      或1，其结果都是1，这样答案就是：1<<(二进制表示中1的个数)

 

代码：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <string.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6.   
  7. int main()  
  8. {  
  9.     int n;  
  10.     while(scanf("%d",&n)!=EOF)  
  11.     {  
  12.         int cnt = 0;  
  13.         while (n)  
  14.         {  
  15.             if (n & 1) cnt++;  
  16.             n >>= 1;  
  17.         }  
  18.         printf("%d\n",1<<cnt);  
  19.     }  
  20.     return 0;  
  21. }  

 

题目：http://61.187.179.132/JudgeOnline/problem.php?id=1951

 

题意：给定两个正整数和，其中，求下面表达式的值

 

     

 

分析：由于999911659是素数，用费马小定理降幂得到

 

     

 

     现在关键是求

    

     

 

     那么我们枚举分别计算，但是模的是合数，所以对999911658进行分解得到

 

     ，那么分别求，即

 

      

 

     然后进一步得到同余方程组为

 

       

 

     再通过中国剩余定理（CRT）可以求得最终答案。

 

代码：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <string.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6. typedef long long LL;  
  7.   
  8. const int P = 999911659;  
  9.   
  10. LL a[5] = {0, 0, 0, 0};  
  11. LL m[5] = {2, 3, 4679, 35617};  
  12. LL fac[5][36010];  
  13. LL N, G;  
  14.   
  15. void Init()  
  16. {  
  17.     for(int i=0; i<4; i++)  
  18.     {  
  19.         fac[i][0] = 1;  
  20.         for(int j=1; j<36010; j++)  
  21.             fac[i][j] = fac[i][j-1] * j % m[i];  
  22.     }  
  23. }  
  24.   
  25. LL quick_mod(LL a,LL b,LL m)  
  26. {  
  27.     LL ans = 1;  
  28.     a %= m;  
  29.     while(b)  
  30.     {  
  31.         if(b & 1)  
  32.         {  
  33.             ans = ans * a % m;  
  34.             b--;  
  35.         }  
  36.         b >>= 1;  
  37.         a = a * a % m;  
  38.     }  
  39.     return ans;  
  40. }  
  41.   
  42. LL C(LL n,LL k,int cur)  
  43. {  
  44.     LL p = m[cur];  
  45.     if(k > n) return 0;  
  46.     return fac[cur][n] * quick_mod(fac[cur][k] * fac[cur][n-k], p - 2, p) % p;  
  47. }  
  48.   
  49. LL Lucas(LL n,LL k,int cur)  
  50. {  
  51.     LL p = m[cur];  
  52.     if(k == 0)  return 1;  
  53.     return C(n % p, k % p, cur) * Lucas(n / p, k / p, cur) % p;  
  54. }  
  55.   
  56. void extend_Euclid(LL a, LL b, LL &x, LL &y)  
  57. {  
  58.     if(b == 0)  
  59.     {  
  60.         x = 1;  
  61.         y = 0;  
  62.         return;  
  63.     }  
  64.     extend_Euclid(b, a % b,x, y);  
  65.     LL tmp = x;  
  66.     x = y;  
  67.     y = tmp - a / b * y;  
  68. }  
  69.   
  70. LL RemindChina(LL a[],LL m[],int k)  
  71. {  
  72.     LL M = 1;  
  73.     LL ans = 0;  
  74.     for(int i=0; i<k; i++)  
  75.         M *= m[i];  
  76.     for(int i=0; i<k; i++)  
  77.     {  
  78.         LL x, y;  
  79.         LL Mi = M / m[i];  
  80.         extend_Euclid(Mi, m[i], x, y);  
  81.         ans = (ans + Mi * x * a[i]) % M;  
  82.     }  
  83.     if(ans < 0)  
  84.         ans += M;  
  85.     return ans;  
  86. }  
  87.   
  88. int main()  
  89. {  
  90.     Init();  
  91.     while(cin>>N>>G)  
  92.     {  
  93.         a[0] = a[1] = 0;  
  94.         a[2] = a[3] = 0;  
  95.         if(G == P)  
  96.         {  
  97.             cout<<"0"<<endl;  
  98.             continue;  
  99.         }  
  100.         G %= P;  
  101.         for(int i=1; i*i <= N; i++)  
  102.         {  
  103.             if(N % i == 0)  
  104.             {  
  105.                 LL x = i;  
  106.                 a[0] = (a[0] + Lucas(N, x, 0)) % m[0];  
  107.                 a[1] = (a[1] + Lucas(N, x, 1)) % m[1];  
  108.                 a[2] = (a[2] + Lucas(N, x, 2)) % m[2];  
  109.                 a[3] = (a[3] + Lucas(N, x, 3)) % m[3];  
  110.                 x = N / i;  
  111.                 if(i * i != N)  
  112.                 {  
  113.                     a[0] = (a[0] + Lucas(N, x, 0)) % m[0];  
  114.                     a[1] = (a[1] + Lucas(N, x, 1)) % m[1];  
  115.                     a[2] = (a[2] + Lucas(N, x, 2)) % m[2];  
  116.                     a[3] = (a[3] + Lucas(N, x, 3)) % m[3];  
  117.                 }  
  118.             }  
  119.         }  
  120.         LL ans = quick_mod(G, RemindChina(a, m, 4), P);  
  121.         cout<<ans<<endl;  
  122.     }  
  123.     return 0;  
  124. }  


 

题目：已知有如下表达式

 

     

 

      给定和，求。

 

分析：如果直接二项式展开，这样会很麻烦，而且不容易求出，本题有技巧。做如下变换

 

     

  

     所以问题变为求的值。    

ZONE画派
关注
专栏目录
组合数取模
CrazyForsaken的博客
03-23 408
对于组合数取模的问题，这里给出几种做法。 Cmn(modp)Cnm(modp)C^{m}_{n} (mod p) 对于 n, m 较小的时候，可以使用杨辉三角强行解。 当 n, m 较大的时候，且 p 是素数的时候可以用 Lucas定理。 Lucas定理： 若 n=nkpk+nk−1pk−1+...+n1p+n0n=nkpk+nk−1pk−1+...+n1p+n0n=n_kp^...
组合数取模方法总结（Lucas定理介绍）
Daioo 随笔
04-06 273
正文 1.当n,m都很小的时候可以利用杨辉三角直接求。 C(n,m)=C(n-1,m)+C(n-1,m-1)； 2、n和m较大，但是p为素数的时候 Lucas定理是用来求 c(n,m) mod p，p为素数的值。 C(n,m)%p=C(n/p,m/p)*C(n%p,m%p)%p 也就是Lucas(n,m)%p=Lucas(n/p,m/p)*C(n%p,m%p)%p 求上式的时候，Lucas递归出口...
组合数学- 组合数取模- 卢卡斯定理与扩展卢卡斯定理.rar
09-16
组合数学是数学的一个分支，主要研究有限集合中对象的组合性质。...通过阅读"组合数学- 组合数取模- 卢卡斯定理与扩展卢卡斯定理.pdf"，你可以深入学习这两个定理的详细证明、推导过程以及它们在实际问题中的应用。
HDU 5794 A Simple Chess Lucas大数组合数取模
JYZ's Blog
05-01 446
A Simple Chess Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Problem Description There is a n×m board, a chess want to go to the position  (n,m) f
Lucas定理应用分析——大组合数取模
AC_Gibson的专栏
05-29 1938
首先给出Lucas（卢卡斯）定理：     有非负整数A、B，和素数p，A、B写成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]) mod p同余。 即：Lucas(n,m,p)=C(n%p,m%p)×Lucas(n/p,m/p,p) ，
组合数取模及Lucas定理
as7223979的博客
08-26 379
引入： 组合数C(m,n)表示在m个不同的元素中取出n个元素（不要求有序），产生的方案数。定义式：C(m,n)=m!/(n!*(m-n)!)（并不会使用LaTex QAQ）。 根据题目中对组合数的需要，有不同的计算方法。 （1）在模k的意义下求出C(i,j)(1≤j≤i≤n)共n2（数量级）个组合数： 运用一个数学上的组合恒等式（OI中称之为杨辉三角）：C(m,n)=C(m-1...
组合数取模（费马小定理）
SPIDER的博客
11-18 507
费马小定理：      （p为质数）  我们由此可以推出： （m是质数） 所以a在mod m 意义下的逆元等价于a^m-2，这样我们就会求一个数的逆元了。 注意：费马小定理只能在a,m互质时使用! 这里我们会想可不可以直接带公式求解呢？ 因为涉及到除法的取模，所以要用到逆元求解，自然想到使用费马小定理来求一个数的逆元 思路  这样我们就可以快速的求出组合数取模后的结...
组合数求余数
qq_63010655的博客
11-29 667
Description C(n, 0) = C(n, n) = 1 对所有的n>0 C(n, k) = C(n − 1, k − 1) + C(n − 1, k) 对所有 0 < k < n. 求C(n, k)与2的余数。 Input 第一行输入一个整数t，代表有多少个数据。接下来的t行输入两个整数k，n(0 ≤ k ≤ n < 2^31, n > 0)。 Output C(n, k)与2的余数。 Samples inputCop.
组合数取模运算
weixin_30402343的博客
01-23 337
参考博客： 大数量级组合数的快速计算方法,log转化 　　组合数取模 　　组合数取模2 组合公式 c(n,m)=p(n,m)/m!=n!/((n-m)!*m!) c(n,m)=c(n,n-m) c(n,m)=c(n-1,m)+c(n-1,m-1) 欧拉定理 （<---自家博客） 欧拉定理,（也称费马-欧拉定理）是一个关于同余的性质。欧拉定理表明，若n,a为...
组合数取余
蒟蒻本蒻的博客
02-28 498
组合数C(n,m)%k的计算 方法一 递推公式 C(n,m)=C(n-1,m)+C(n-1,m-1) 一边计算一边取余 时间复杂度O(n2) 适用范围m,n<1000，k为自然数 #include<bits/stdc++.h> using namespace std; int c[1001][1001]; int main() { int n,m,k; scanf("%d%d%d",&n,&m,&k); for(int i=1;i<=n;i++
数论应用：组合数计算与Lucas定理解析
本文主要介绍了数论中的几个关键概念，包括组合数的计算、Lucas定理以及线性求逆元算法。这些是计算机科学，尤其是算法和密码学中的基础数学工具。 组合数，又称二项式系数，表示在n个不同元素中选择m个的方法数。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值