组合数的求法及逆元

最新推荐文章于 2025-01-09 14:56:16 发布
原创 最新推荐文章于 2025-01-09 14:56:16 发布 · 352 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博主整理了网上两篇文章，分别涉及OI中组合数的若干求法与CRT，以及逆元相关内容。
逆元求组合数
weixin_40149887的博客
04-09 3053
题目 给一个歌单固定长度为K 有两种歌：X首长度为A，Y首长度为B的歌，A!=B 问有几种组合搭配 如： 输入 K = 5，A = 2 X = 3 B = 3 Y = 3 输出 9 由于结果比较大，因此输出结果取1000000007的余数。 思路 腾讯春招实习笔试题……用自己的方法瞎做最后发现除数那里的取余不知道怎么取。 问了yz大佬，给我一篇博客，大概是“逆元...
组合数计算方法(递推公式、乘法逆元)
qq_44805233的博客
05-31 677
组合数的公式定义：C(n,m) = n!)，从n个里边选m个。
逆元与组合数
呆头呆脑没有烦恼
07-15 548
线性逆元打表 inv[i]inv[i]inv[i]为模PPP（P需要是质数）意义下iii的逆元，那么有inv[i]=(P−Pi)×inv[Pinv[i]=(P−Pi)×inv[Pinv[i]=(P-\frac{P}{i})×inv[P%i]i]i]%PPP。 写成代码如下。 ll inv[N]; inv[0] = 1; inv[1] = 1; for(int i = 2; i < N;...
组合数逆元
weixin_30651273的博客
10-19 156
费马小定理： 　　在p是素数的情况下 a^p≡a(modp),对式子变形得：a^(p-1)≡1(modp)，那么a的逆元inv[a] = a^(p-2)。 组合数C（m,n） = m! / (n! * (m-n)!),当C（m,n）特别大的时候，需要对p取余，若p是素数，那么可以利用费马小定理快速求逆元。 C(m,n) % p = (m! / (n! * (m-n)!))%p = (m...
数论（组合数求法+Lucas定理+线性求逆元
08-01
数论
求组合数 ：DP、逆元+快速幂
qq_40586164的博客
08-30 454
要求：求 Cmn%pC_{m}^n \% pCmn​%p ，p为素数（经典p=1e9+7） 方法一：DP C[n][m]=CnmC_{n}^mCnm​ 公式Cnm=Cn−1m−1+Cn−1mC_{n}^m=C_{n-1}^ {m-1}+C_{n-1}^{m}Cnm​=Cn−1m−1​+Cn−1m​ 证明：班级中有n个人，选出m个人开除，有两种选法： 班长不开除，从剩下的人中开除m个人 开除班长，从剩下的人中开除m-1个人 const int MOD = 1e9 + 7; int C[1005][1005
竞赛入门-计数问题：求组合数、乘法逆元
qq_20543667的博客
01-09 938
对于排列的第一个位置，可以是2到n之间的任意一个数字，有（n-1）种选择，对于第2位，1可以选择放在第2位，问题变成了求。简单说就是一个数a与另一个数b在某种操作下结果为1，则b就是a的逆元，a×b=1，那么b就是a的乘法逆元。对于任意一个合法的括号串，第一个括号一定是左括号（ ，那么可以先去找与第一个括号匹配的右括号）在哪里，以。3.给定长度为n的01串，0表示（ ，1表示 ），一个合法的括号串为010010，表示为。为例，匹配的右括号在第二个符号的位置，左边部分的待匹配串长度-2，用。
组合数学- 组合数取模- 逆元与递推打表.rar
09-16
首先，让我们了解一下组合数，也被称为二项式系数，通常用C(n, k)或nCk表示，表示从n个不同元素中不重复地选取k个元素的方法数。它满足以下性质： 1. 对称性：C(n, k) = C(n, n-k) 2. Pascal's Rule（帕斯卡定律）...
如何求组合数（逆元）
weixin_30689307的博客
06-07 153
#include <iostream> //组合数 #include <cstdio> #include <cstring> using namespace std; const long long mod=1e9+7; long long jc[1000000],ny[1000000]; //jc[i]表示i的阶乘 ny[i...
组合数+逆元
梅子酒的博客
06-12 397
小圆前辈的暴力枚举 这个题是学校校赛学长出的一道题：小圆前辈的暴力枚举 然后不得不说要称赞吐槽 一下题目的名字，好一个暴力枚举，好一个不就是暴力枚举一下吗！ 由于显示问题，下面将所有的乘号用x替换 题目大意：(NxM)的矩阵，任意放入K个棋子（K=0,1,2,3…N*M)求其中有多少种情况可以做到每行每列只有一枚棋子，结果对998244353取模。暴力复杂度O(2^nm)（1<=N，M<=1000）建议暴力枚举 首先我们可以知道，在一个NxM的矩阵中符合要求的放下N个棋子方法种数ans=N！(N
逆元法求组合数
coder370的博客
01-30 463
##### 费小马定律 若a 与 p互质且p为质数时 ，a^(p-1)^== 1%p ;
组合数(逆元)
lpls1
02-16 575
组合数公式:C(n,m)=n!/((n-m)!*m!)（m≤n） 组合数性质1:C(n,m)= C(n,n-m) 组合数性质2:C(n,m)=C(n-1,m-1)+C(n-1,m) 代码用组合数公式求C(n,m)%mod.设((n-m)!*m!)逆元为x,则C(n,m)%mod=n!*x%mod. public class Main { static InputReader sc=new Inp...
组合数+逆元 (方法整理)
weixin_30832405的博客
09-20 687
一.逆元(inv) 当求解公式：(a/b)%m 时，因b可能会过大，会出现爆精度的情况，所以需变除法为乘法： 设c是b的逆元，则有b*c≡1(mod m)；则(a/b)%m = (a/b)*1%m = (a/b)*b*c%m = a*c(mod m); 即a/b的模等于a*b的逆元的模,逆元就是这样应用的； 二.求逆元的方法: 　　1.扩展欧几里得算法 　　2.费马小定理inv(a)=...
组合数——逆元
远赴山河万里的博客
04-13 248
题目链接：传送门（点我） #include<iostream> using namespace std; typedef unsigned long long ll; int n , m , p; ll calc(int a , int b) { ll ans = 1; for(int i = a ;i <= b ; i ++)ans = (ans * i) % p; return ans; } ll ny(ll num) { int a = num , b = p - 2;
求逆元 求组合数
冰
07-30 3071
求一个数的模p（一般为质数）的逆元，
组合数逆元求法
rwrsgg的博客
07-16 370
// 线性求组合数逆元 #include <iostream> #include <cstring> using namespace std; const int pi = 17; int f[10000]; int inv[10000]; void Init() //线性求逆元 { f[0]=f[1] = 1; inv[1] = 1; for(int i =2;i<10000;i++) { f[i] = f[i-1]*i%pi; inv[i] = (p
组合数学--逆元求组合数
CHAI_NIAOJINJE的博客
07-08 478
逆元求解 公式大概就是这么个公式。具体的实现代码如下： #include<iostream> #include<cstdio> #include <stdio.h> #include<algorithm> #include<cstring> #include<cmath> #include<cstdlib> #include<queue> #include<map> #include<vect
线性逆元求组合数
最新发布
05-11
<think>好的，我现在需要解决用户的问题：如何用线性逆元高效计算组合数，并给出算法实现。首先，我需要回顾一下用户提供的引用内容，看看有哪些已有的信息可以利用。 根据引用[2]和引用[4]，用户提到了两种求逆元的方法：费马小定理和线性算法。用户特别关注的是线性逆元的应用，所以重点应该放在线性逆元方法上。引用[4]中的代码使用了费马小定理来计算阶乘的逆元，而用户现在想用线性逆元的方法，也就是引用[2]中的第二种方法。 首先，我需要理清组合数的计算公式。组合数C(n, m)的公式是n!/(m!*(n-m)!))。在模运算中，除法需要转换为乘以逆元。因此，组合数取模可以表示为：C(n,m) % p = (n! * inv(m!) * inv((n-m)!)) % p，其中inv表示逆元。 接下来，线性逆元的计算方法。引用[2]中的线性算法部分给出了一个预处理逆元数组的方法，预处理每个数的逆元。代码示例中的ny数组是通过递推公式计算的：ny[i] = (p - p/i) * ny[p%i] % p。这里的ny[i]是i的逆元。这种方法可以在O(n)的时间内预处理出1到n的逆元。 但这里有个问题，组合数计算中需要的是阶乘的逆元，而不是单个数的逆元。所以，可能需要分两步处理：首先预处理出每个数的逆元，然后计算阶乘的逆元。例如，先预处理inv[1...n]，然后阶乘的逆元可以通过递推得到，比如infact[i] = infact[i-1] * inv[i] % p。这样，阶乘的逆元可以通过线性时间计算出来。 再看引用[3]，其中提到了一种同时计算阶乘和逆元的方法，使用了一个递推式。可能这种方法可以更高效地同时处理阶乘及其逆元。但用户现在希望用线性逆元的方法，也就是先预处理每个数的逆元，再计算阶乘的逆元。 所以，步骤大致如下： 1. 预处理逆元数组inv，其中inv[i]是i在模p下的逆元，使用线性递推方法。 2. 计算阶乘数组fact，其中fact[i] = i! % p。 3. 计算阶乘的逆元数组infact，其中infact[i] = (i!)^{-1} % p。这可以通过infact[i] = infact[i-1] * inv[i] % p来计算。 4. 组合数C(n,m)的计算公式即为 fact[n] * infact[m] % p * infact[n-m] % p。 现在需要验证这个过程是否正确。例如，假设已经计算了fact数组和infact数组，那么组合数的计算是否正确。是的，因为每个阶乘的逆元已经预先计算好了，相乘即可得到分母部分的逆元。 接下来要考虑的是实现中的细节，比如数组的大小，预处理的范围。如果n和m的最大值较大，比如1e5或者更高，需要确保数组足够大。例如，在引用[4]的代码中，预处理了N=1e5+10的阶乘和阶乘逆元。用户的问题中可能需要类似的预处理。 那么具体的实现步骤： 预处理部分： - 初始化fact[0...maxN]和infact[0...maxN]，以及inv[1...maxN]。 - fact[0] = 1，然后fact[i] = fact[i-1] * i % p。 - 预处理inv数组，使用线性递推：inv[1] = 1，然后对于i>=2，inv[i] = (p - p/i) * inv[p % i] % p。 - 计算infact数组：infact[0] = 1，然后infact[i] = infact[i-1] * inv[i] % p。 这样，当需要计算C(n,m)时，只要n和m不超过maxN，就可以直接通过fact[n] * infact[m] % p * infact[n-m] % p得到结果。 需要注意的是，这种方法的时间复杂度是O(maxN)，对于多次查询组合数的情况非常高效，因为预处理后每次查询都是O(1)时间。 现在需要检查是否存在可能的错误。例如，当p不是质数时，线性逆元的方法是否有效？根据线性递推的条件，p必须是质数才能确保每个数都有逆元吗？其实，线性逆元方法要求i和p互质，所以当p是质数时，1到p-1的数都与p互质，此时可以正确计算逆元。如果p不是质数，可能某些i没有逆元，导致预处理失败。因此，该方法适用于p为质数的情况。 用户提供的引用中，例如引用[2]中的费马小定理部分提到p为素数且a和p互质。所以，这里可能需要假设p是一个足够大的质数，这样预处理才能正确进行。 因此，在实现中，需要确保p是质数，并且在预处理时处理到足够大的maxN，以满足后续查询的n和m的范围。 现在，编写代码的大致结构： 首先预处理inv数组，然后fact和infact数组。例如： const int maxN = 1e5 + 10; int fact[maxN], infact[maxN], inv[maxN]; int p; // 模数，假设为质数 void preprocess() { fact[0] = infact[0] = 1; inv[1] = 1; for (int i = 2; i < maxN; ++i) inv[i] = (p - p / i) * inv[p % i] % p; for (int i = 1; i < maxN; ++i) { fact[i] = fact[i-1] * i % p; infact[i] = infact[i-1] * inv[i] % p; } } 然后，计算组合数时： int C(int n, int m) { if (m < 0 || m > n) return 0; return fact[n] * infact[m] % p * infact[n - m] % p; } 但需要确保n和m都不超过maxN-1，否则数组会越界。如果n可能很大，比如达到1e5，则需要预先设置maxN足够大。或者，如果n的范围不确定，可能需要动态处理，但预处理通常适用于已知最大范围的情况。 测试一下是否正确。例如，当p=1e9+7，计算C(5,2)=10。按照上述步骤： fact[5] = 120，infact[2] = 2的阶乘逆元的逆元。假设inv[2]=500000004（因为2*500000004 mod 1e9+7=1），infact[2] = infact[1] * inv[2] → infact[1]是1的逆元的乘积。可能过程需要更仔细的计算。 或者，可能直接通过阶乘的逆元来计算。例如，fact[5]=120，infact[2]= (2!)^{-1} = (2)^{-1} * (1)^{-1} → 但按照infact的计算方法，infact[i] = infact[i-1] * inv[i]，所以infact[2] = infact[1] * inv[2}。而infact[1} = inv[1}=1。所以infact[2}=1 * inv[2}。inv[2}是500000004。因此，infact[2}=500000004。同理，infact[3}=infact[2} * inv[3}，以此类推。 所以，当计算C(5,2)时，fact[5] * infact[2} * infact[3}。即120 * 500000004 * 333333336 % 1e9+7。计算这个值： 500000004 * 333333336 = (1/2) * (1/3) = 1/6，所以乘以120得到20。但正确的结果是10。这说明哪里出错了？ 哦，这里可能哪里弄错了。例如，C(5,2)=10。但根据上述计算，结果得到的是20？ 可能我的计算有误。让我们详细计算： 假设p=1e9+7，此时： fact[5] = 120 infact[2}= (2!)^{-1} = inv[1] * inv[2} = 1 * inv[2} = 500000004 infact[3}= (3!)^{-1} = infact[2} * inv[3} → inv[3}=333333336，所以 infact[3}=500000004 * 333333336 mod p = 500000004 * 333333336 = (1/2) * (1/3) = 1/6 → 因此，infact[3}=166666668. 所以，组合数C(5,2) = 120 * 500000004 * 166666668 % p. 计算这三个数的乘积： 500000004 * 166666668 = ? 先计算500000004 × 166666668： 500000004 * 166666668 = (5e8 +4) * (1.66666668e8) 这可能需要模运算中的计算，但直接计算的话： 500000004 × 166666668 = ? 但是模1e9+7的话，这些数都是它们在该模下的逆元。例如，500000004是2的逆元，166666668是6的逆元。所以，2的逆元乘以6的逆元等于 (2*6)的逆元=12的逆元。但 120 × (2的逆元) × (6的逆元) = 120 × (12的逆元) = 120 /12 =10。所以结果正确。因此，上述方法是正确的。 这说明算法是正确的。 接下来，需要根据这个思路编写代码。例如，引用的代码中，用户提供的引用[4]使用了费马小定理来预处理阶乘的逆元，而用户现在希望用线性逆元的方法，所以需要修改这部分代码，将infact的预处理改为使用线性逆元数组。 因此，正确的代码结构应该是： 预处理inv数组，然后预处理fact和infact数组。例如： #include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; // 假设最大处理到1e5 int fact[N], infact[N], inv[N]; int p; void preprocess() { fact[0] = infact[0] = 1; inv[1] = 1; for (int i = 2; i < N; ++i) { inv[i] = (p - p / i) * 1LL * inv[p % i] % p; } for (int i = 1; i < N; ++i) { fact[i] = fact[i - 1] * 1LL * i % p; infact[i] = infact[i - 1] * 1LL * inv[i] % p; } } int C(int n, int m) { if (m < 0 || m > n) return 0; return fact[n] * 1LL * infact[m] % p * infact[n - m] % p; } int main() { // 示例：假设p是质数，比如1e9+7 p = 1e9 + 7; preprocess(); int n, m; cin >> n >> m; cout << C(n, m) << endl; return 0; } 这样，预处理部分使用线性逆元的方法来计算inv数组，然后用inv数组来递推计算infact数组。这样就避免了使用费马小定理的快速幂方法，从而提高了预处理的速度，尤其是在需要处理大范围的情况下，线性方法更高效。 需要注意的是，这种方法的时间复杂度为O(N)，适用于多次查询的情况。同时，需要确保N足够大以覆盖所有可能的n和m值。 用户的问题已经得到了解决，现在需要生成相关问题。根据用户的问题和回答，相关问题可能包括线性逆元的原理、组合数计算的其他方法、或者如何处理更大的n和m的情况等。</think>### 线性逆元求组合数算法实现 #### 核心步骤 1. **预处理线性逆元数组**：使用递推公式$inv[i] = (p - \lfloor p/i \rfloor) \cdot inv[p\%i] \% p$，时间复杂度$O(n)$ 2. **计算阶乘数组**：$fact[i] = fact[i-1] \times i \% p$ 3. **计算阶乘逆元数组**：$infact[i] = infact[i-1] \times inv[i] \% p$ 4. **组合数计算**：$C(n,m) = fact[n] \times infact[m] \times infact[n-m] \% p$ #### 算法模板 ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 10; int fact[MAXN], infact[MAXN], inv[MAXN], mod; void preprocess() { // 初始化边界条件 fact[0] = infact[0] = 1; inv[1] = 1; // 线性求逆元 for (int i = 2; i < MAXN; ++i) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod; // 计算阶乘及其逆元 for (int i = 1; i < MAXN; ++i) { fact[i] = 1LL * fact[i-1] * i % mod; infact[i] = 1LL * infact[i-1] * inv[i] % mod; } } int comb(int n, int m) { if (m < 0 || m > n) return 0; return 1LL * fact[n] * infact[m] % mod * infact[n - m] % mod; } ``` #### 复杂度分析 - **时间复杂度**：预处理$O(n)$，单次查询$O(1)$ - **空间复杂度**：$O(n)$ - **适用条件**：模数$p$为质数且$n,m < MAXN$[^2][^4] #### 应用示例 当$p=10^9+7$时，计算$C(10000,5000)$： 1. 预处理阶乘数组和逆元数组 2. 直接调用comb(10000, 5000)即可得到结果 3. 计算结果满足：$C(n,m) \equiv \frac{n!}{m!(n-m)!} \mod p$[^1][^3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值