组合数取模

最新推荐文章于 2021-11-29 23:51:30 发布
最新推荐文章于 2021-11-29 23:51:30 发布
阅读量375 收藏
点赞数 1
分类专栏： -------------------数论------------------ 组合数学 模版 文章标签： 数论 大组合数取模

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

 

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

 

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

 

（1）和

 

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

 

（2）和，并且是素数

 

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

 

     

 

     那么得到

 

     

   

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

 

 

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

 

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

 

代码：

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
typedef long long LL;  
  
LL n,m,p;  
  
LL quick_mod(LL a, LL b)  
{  
    LL ans = 1;  
    a %= p;  
    while(b)  
    {  
        if(b & 1)  
        {  
            ans = ans * a % p;  
            b--;  
        }  
        b >>= 1;  
        a = a * a % p;  
    }  
    return ans;  
}  
  
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) % p;  
        LL b = i % p;  
        ans = ans * (a * quick_mod(b, p-2) % p) % p;  
    }  
    return ans;  
}  
  
LL Lucas(LL n, LL m)  
{  
    if(m == 0) return 1;  
    return C(n % p, m % p) * Lucas(n / p, m / p) % p;  
}  
  
int main()  
{  
    int T;  
    scanf("%d", &T);  
    while(T--)  
    {  
        scanf("%I64d%I64d%I64d", &n, &m, &p);  
        printf("%I64d\n", Lucas(n,m));  
    }  
    return 0;  
}

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

 

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

 

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

 

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

 

代码：

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
typedef long long LL;  
  
LL n,m,p;  
  
LL quick_mod(LL a, LL b)  
{  
    LL ans = 1;  
    a %= p;  
    while(b)  
    {  
        if(b & 1)  
        {  
            ans = ans * a % p;  
            b--;  
        }  
        b >>= 1;  
        a = a * a % p;  
    }  
    return ans;  
}  
  
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) % p;  
        LL b = i % p;  
        ans = ans * (a * quick_mod(b, p-2) % p) % p;  
    }  
    return ans;  
}  
  
LL Lucas(LL n, LL m)  
{  
    if(m == 0) return 1;  
    return C(n % p, m % p) * Lucas(n / p, m / p) % p;  
}  
  
int main()  
{  
    int T;  
    scanf("%d", &T);  
    while(T--)  
    {  
        scanf("%I64d%I64d%I64d", &n, &m, &p);  
        printf("%I64d\n", Lucas(n,m));  
    }  
    return 0;  
}

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

 

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

 

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

 

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

 

代码：

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
typedef long long LL;  
const int N = 200005;  
  
bool prime[N];  
int p[N];  
int cnt;  
  
void isprime()  
{  
    cnt = 0;  
    memset(prime,true,sizeof(prime));  
    for(int i=2; i<N; i++)  
    {  
        if(prime[i])  
        {  
            p[cnt++] = i;  
            for(int j=i+i; j<N; j+=i)  
                prime[j] = false;  
        }  
    }  
}  
  
LL quick_mod(LL a,LL b,LL m)  
{  
    LL ans = 1;  
    a %= m;  
    while(b)  
    {  
        if(b & 1)  
        {  
            ans = ans * a % m;  
            b--;  
        }  
        b >>= 1;  
        a = a * a % m;  
    }  
    return ans;  
}  
  
LL Work(LL n,LL p)  
{  
    LL ans = 0;  
    while(n)  
    {  
        ans += n / p;  
        n /= p;  
    }  
    return ans;  
}  
  
LL Solve(LL n,LL m,LL P)  
{  
    LL ans = 1;  
    for(int i=0; i<cnt && p[i]<=n; i++)  
    {  
        LL x = Work(n, p[i]);  
        LL y = Work(n - m, p[i]);  
        LL z = Work(m, p[i]);  
        x -= (y + z);  
        ans *= quick_mod(p[i],x,P);  
        ans %= P;  
    }  
    return ans;  
}  
  
int main()  
{  
    int T;  
    isprime();  
    cin>>T;  
    while(T--)  
    {  
        LL n,m,P;  
        cin>>n>>m>>P;  
        n += m - 2;  
        m--;  
        cout<<Solve(n,m,P)<<endl;  
    }  
    return 0;  
}

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

 

题目：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）只有前三层，则循环次数为

 

         

 

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



代码：

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
typedef long long LL;  
  
const int N = 25;  
const int MOD1 = 97;  
const int MOD2 = 3761599;  
const int MOD = MOD1 * MOD2;  
  
int m,n,k;  
int a[N];  
LL fac1[MOD1+10];  
LL fac2[MOD2+10];  
LL inv1,inv2;  
  
LL quick_mod(LL a,LL b,LL m)  
{  
    LL ans = 1;  
    a %= m;  
    while(b)  
    {  
        if(b & 1)  
        {  
            ans = ans * a % m;  
            b--;  
        }  
        b >>= 1;  
        a = a * a % m;  
    }  
    return ans;  
}  
  
LL C(LL n,LL m,LL p,LL fac[])  
{  
    if(n < m) return 0;  
    return fac[n] * quick_mod(fac[m] * fac[n-m], p - 2, p) % p;  
}  
  
LL Lucas(LL n,LL m,LL p,LL fac[])  
{  
    if(m == 0) return 1;  
    return C(n % p, m % p, p, fac) * Lucas(n / p, m / p, p, fac);  
}  
  
void Init()  
{  
    fac1[0] = fac2[0] = 1;  
    for(int i=1; i<MOD1; i++)  
        fac1[i] = (fac1[i-1] * i) % MOD1;  
    for(int i=1; i<MOD2; i++)  
        fac2[i] = (fac2[i-1] * i) % MOD2;  
    inv1 = MOD2 * quick_mod(MOD2, MOD1-2, MOD1);  
    inv2 = MOD1 * quick_mod(MOD1, MOD2-2, MOD2);  
}  
  
int main()  
{  
    Init();  
    int T, tt = 1;  
    scanf("%d",&T);  
    while(T--)  
    {  
        scanf("%d%d%d",&n,&m,&k);  
        for(int i=0; i<k; i++)  
            scanf("%d",&a[i]);  
        a[k] = m;  
        LL ans = 1;  
        for(int i=0; i<k; i++)  
        {  
            LL m1 = Lucas(a[i+1] - a[i] + n - 1, a[i+1] - a[i], MOD1, fac1);  
            LL m2 = Lucas(a[i+1] - a[i] + n - 1, a[i+1] - a[i], MOD2, fac2);  
            LL mm = (m1 * inv1 + m2 * inv2) % MOD;  
            ans = ans * mm % MOD;  
        }  
        printf("Case #%d: ",tt++);  
        cout<<ans<<endl;  
    }  
    return 0;  
}


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

 

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

 

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

          

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

 

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

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

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

 

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

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

 

代码：


#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
  
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        int cnt = 0;  
        while (n)  
        {  
            if (n & 1) cnt++;  
            n >>= 1;  
        }  
        printf("%d\n",1<<cnt);  
    }  
    return 0;  
}

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

 

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

 

     

 

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

 

     

 

     现在关键是求

    

     

 

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

 

     ，那么分别求，即

 

      

 

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

 

       

 

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

 

代码：


#include <iostream>  
#include <string.h>  
#include <stdio.h>  
  
using namespace std;  
typedef long long LL;  
  
const int P = 999911659;  
  
LL a[5] = {0, 0, 0, 0};  
LL m[5] = {2, 3, 4679, 35617};  
LL fac[5][36010];  
LL N, G;  
  
void Init()  
{  
    for(int i=0; i<4; i++)  
    {  
        fac[i][0] = 1;  
        for(int j=1; j<36010; j++)  
            fac[i][j] = fac[i][j-1] * j % m[i];  
    }  
}  
  
LL quick_mod(LL a,LL b,LL m)  
{  
    LL ans = 1;  
    a %= m;  
    while(b)  
    {  
        if(b & 1)  
        {  
            ans = ans * a % m;  
            b--;  
        }  
        b >>= 1;  
        a = a * a % m;  
    }  
    return ans;  
}  
  
LL C(LL n,LL k,int cur)  
{  
    LL p = m[cur];  
    if(k > n) return 0;  
    return fac[cur][n] * quick_mod(fac[cur][k] * fac[cur][n-k], p - 2, p) % p;  
}  
  
LL Lucas(LL n,LL k,int cur)  
{  
    LL p = m[cur];  
    if(k == 0)  return 1;  
    return C(n % p, k % p, cur) * Lucas(n / p, k / p, cur) % p;  
}  
  
void extend_Euclid(LL a, LL b, LL &x, LL &y)  
{  
    if(b == 0)  
    {  
        x = 1;  
        y = 0;  
        return;  
    }  
    extend_Euclid(b, a % b,x, y);  
    LL tmp = x;  
    x = y;  
    y = tmp - a / b * y;  
}  
  
LL RemindChina(LL a[],LL m[],int k)  
{  
    LL M = 1;  
    LL ans = 0;  
    for(int i=0; i<k; i++)  
        M *= m[i];  
    for(int i=0; i<k; i++)  
    {  
        LL x, y;  
        LL Mi = M / m[i];  
        extend_Euclid(Mi, m[i], x, y);  
        ans = (ans + Mi * x * a[i]) % M;  
    }  
    if(ans < 0)  
        ans += M;  
    return ans;  
}  
  
int main()  
{  
    Init();  
    while(cin>>N>>G)  
    {  
        a[0] = a[1] = 0;  
        a[2] = a[3] = 0;  
        if(G == P)  
        {  
            cout<<"0"<<endl;  
            continue;  
        }  
        G %= P;  
        for(int i=1; i*i <= N; i++)  
        {  
            if(N % i == 0)  
            {  
                LL x = i;  
                a[0] = (a[0] + Lucas(N, x, 0)) % m[0];  
                a[1] = (a[1] + Lucas(N, x, 1)) % m[1];  
                a[2] = (a[2] + Lucas(N, x, 2)) % m[2];  
                a[3] = (a[3] + Lucas(N, x, 3)) % m[3];  
                x = N / i;  
                if(i * i != N)  
                {  
                    a[0] = (a[0] + Lucas(N, x, 0)) % m[0];  
                    a[1] = (a[1] + Lucas(N, x, 1)) % m[1];  
                    a[2] = (a[2] + Lucas(N, x, 2)) % m[2];  
                    a[3] = (a[3] + Lucas(N, x, 3)) % m[3];  
                }  
            }  
        }  
        LL ans = quick_mod(G, RemindChina(a, m, 4), P);  
        cout<<ans<<endl;  
    }  
    return 0;  
}

题目：已知有如下表达式

 

     

 

      给定和，求。

 

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

 

     

  

     所以问题变为求的值。 



UMR小豪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
组合数学- 组合数取模- 逆元与递推打表.rar
09-16
组合数学- 组合数取模- 逆元与递推打表.rar
组合数取模总结
Hang_ccccc的博客
12-07 2851
题目描述： 在ACM竞赛现在叫JB竞赛？中，经常会遇到组合数取模的题目；就我现在的水平而言，大概分为以下三类，以后遇到新的方法会在做补充； 第一种： n和m都较小 （&lt;1000）,在这个数据范围内，我们可以直接用杨辉三角O(n^2)的复杂度内预处理出所有的组合数，然后直接输出即可；典型例题就是给你一个二项式，例如: 这样子的题目，组合数我们可以O(n2)预处理出来（利用递推式子来处理）...
组合数求余数
qq_63010655的博客
11-29 625
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 318
参考博客： 大数量级组合数的快速计算方法,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为...
组合数学- 组合数取模.rar
09-16
"组合数取模"是组合数学中的一个重要概念，尤其是在处理大规模数据时，为了节省计算时间和空间，我们通常会对组合数进行模运算。 组合数，也称为二项式系数，表示从n个不同元素中不重复地选取k个元素的方法数，用...
组合数学- 组合数取模- 卢卡斯定理与扩展卢卡斯定理.rar
09-16
在处理大整数时，组合数取模是一个重要的计算问题，因为直接计算组合数可能会超过整数的表示范围。为了解决这个问题，卢卡斯定理和扩展卢卡斯定理被引入。 卢卡斯定理（Lucas' Theorem）是关于模意义下组合数的一种...
利用扩展欧几里得算法快速计算组合数取模
08-17
利用扩展欧几里得方法，进行快速的计算C（n,m）%P;
java生成字母数字组合的随机数示例 java生成随机数
09-04
通过`random.nextInt(2)`，我们可以得到0或1之间的随机整数，然后取模2（`% 2`）确保结果只可能是0或1。当结果为0时，表示我们要生成一个字母；反之，如果结果为1，那么生成一个数字。这里使用了条件语句（`if-else`...
组合数取模及Lucas定理
as7223979的博客
08-26 342
引入： 组合数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...
组合数取余
qq_41273152的博客
08-28 1267
组合数取余使用C++库函数利用杨辉恒等式利用逆元 即计算 Cnm%pC_n^m\%pCnm​%p . 当 n,mn, mn,m 比较大时，就可以爆掉long long的范围了（据大佬说大概 n=60n=60n=60 就会爆了）. 本蒟蒻就不验证了，相信大佬的 . 其实你算个阶乘就可以了 使用C++库函数 可以使用一个众所周知的数学定理 当 n,m≤50n,m\le50n,m≤50 时，使用C++库...
[组合数取模] 方法汇总
逆风的方向 更适合飞翔
11-11 2259
1.利用整数唯一分解定理，求(n+1-m) * (n+m)!  /  ( m! * (n+1)!  ) 任何正整数都有且只有一种方法写出其素因子幂相乘的形式。比如18= 2 * 3^2 A=(p1^k1)*(p2^k2)*(p3^k3)*(p4^k4)*......*(pn^kn)   pi为素数 还有把阶层看作一个数,比m! 怎样求m!里面素数2的指数呢？ cnt=0;   while(
tfrcw函数用法_2-数学.md · Weaverzhu/ACM模板库 - Gitee.com
weixin_39776239的博客
12-20 473
# 数学### 矩阵运算```cppstruct Mat {static const LL M = 2;LL v[M][M];Mat() { memset(v, 0, sizeof v); }void eye() { FOR (i, 0, M) v[i][i] = 1; }LL* operator [] (LL x) { return v[x]; }const LL* operator [] (L...
【数论系列】 大组合数取模问题
Hello World!
08-19 1507
大组合数取模问题的六种求解场景。
[组合数]求组合数的几种方法总结
mosquito_zm的博客
07-28 863
求C(n,m)%mod的方法总结 1.当n,m都很小的时候可以利用杨辉三角直接求。  C(n,m)=C(n-1,m)+C(n-1,m-1)； 2.利用乘法逆元。  乘法逆元：(a/b)%mod=a*(b^(mod-2)) mod为素数。  逆元可以利用扩展欧几里德或欧拉函数求得： 1).扩展欧几里德：b*x+p*y=1 有解，x就是所求 2).费马小定理：b^(p-1)=
求组合数（取模）的两种方法
热门推荐
月光森林
09-22 1万+
概述首先我们要知道什么是组合数。具体可以参考我之前的博客 “排列与组合”笔记 中，集合的组合的部分。这里复述如下： 令r为非负整数。我们把n个元素的集合S的r-组合理解为从S的n个元素中对r个元素的无序选择。换句话说，S的一个r-组合是S的一个子集，该子集由S的n个元素中的r个组成，即S的一个r-元素子集。由此，求解组合数即变成了求式子C(n, r) 的值。法一：Pascal公式打表由Pascal公
大整数求组合数取余（Lucas定理）
08-06 2433
【卢卡斯（Lucas）定理】 Lucas定理用来求C（a,b）mod p的值,其中p为素数。 数学表达式为： Lucas(a,b,q)=C(a%q,b%q)*Lucas(a/p,b/p,p); Lucas(a,0,q)=0; 通过这个定理就可以很方便的把大数的组合转化成小数。但其中还是要求C(a%q,b%q)%p，所以这里引入逆元来求。 【定义】若整数a,b,p
[学习笔记]组合数取模的几种求法
女装的你，如此好看！
11-02 1000
一、引入 给定 nnn ， mmm ， ppp ，求： (nm)&amp;VeryThinSpace;mod&amp;VeryThinSpace;p\binom nm\bmod p(mn​)modp 其中 (nm)\binom nm(mn​) 为组合数，表示 nnn 个元素中选出 mmm 个的方案数。 即： (nm)=n!m!×(n−m)!\binom nm=\frac{n!}{m!\times(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值