计算 nCr % p | 第二套 (卢卡斯定理)

本文将介绍如何使用卢卡斯定理来计算组合数 nCr 对 p 取模的值。卢卡斯定理是一个快速计算组合数对 p 取模的方法，可用于更大的 n 和 p 值。

什么是组合数？

组合数指从 n 个不同元素中选取 r 个元素的不同组合数量，记作 C(n,r) 或 nCr。

nCr 的计算公式为：

C(n,r) = n! / (r! * (n-r)!)

其中，n! 表示 n 的阶乘，即 n 的所有正整数因子的乘积。例如，5! = 5 * 4 * 3 * 2 * 1 = 120。

暴力求解

暴力求解 nCr 对 p 取模可以将 nCr 的计算公式分为三个步骤：

1. 计算 n!
2. 计算 r!
3. 计算 (n-r)!

最终结果为 C(n,r) % p = n! / (r! * (n-r)!) % p。

计算 n!、r! 和 (n-r)! 的最简单方法是使用 for 循环，并将每个因子与 p 取模。但这种方法的时间复杂度将随着 n 和 p 的值的增长而迅速增加。

使用卢卡斯定理

卢卡斯定理使用中国剩余定理（CRT）来计算 nCr 对 p 取模的值，但是它的主要优点是在处理大型 n 和 p 值时速度更快。

卢卡斯定理的关键在于将组合数 nCr 转化为多个小组合数的乘积。这可以通过将 n 和 r 转换为它们在 p 进制下的表示来完成。

例如，假设 n = 27、r = 16 和 p = 5。在这种情况下，n 和 r 可以分别表示为：

n = 1 * 5^2 + 0 * 5^1 + 2 * 5^0 r = 1 * 5^1 + 1 * 5^0

然后，通过将每个表示与 p 取模来获得 n′ 和 r′：

n′ = 2 * 5^0 = 2 r′ = 1 * 5^0 = 1

接下来，将 n 和 r 分别替换为 n' 和 r' 并应用下面的卢卡斯定理公式：

C(n,r) ≡ C(n′,r′) (mod p)

最后，计算 C(n',r') 对 p 取模的值就可以得到答案。

卢卡斯定理代码实现

以下是使用 Python 实现卢卡斯定理的示例代码，该代码将 nCr 对 p 取模的值计算为 C(n,r)%p：

def nCr(n, r, p):
    if (r > n):
        return 0
    if (r == 0 or r == n):
        return 1

    # 计算 n 和 r 在 p 进制下的表示
    n_p = []
    r_p = []
    while (n > 0):
        n_p.append(n % p)
        n = n // p
    while (r > 0):
        r_p.append(r % p)
        r = r // p

    # 计算 C(n',r') 对 p 取模的值
    if (len(n_p) > len(r_p)):
        r_p += [0] * (len(n_p) - len(r_p))
    elif (len(r_p) > len(n_p)):
        n_p += [0] * (len(r_p) - len(n_p))
    res = 1
    for i in range(len(n_p)):
        res *= calc_C(n_p[i], r_p[i], p)
        res %= p

    return res

def calc_C(n, r, p):
    if (r > n):
        return 0
    if (r == 0 or r == n):
        return 1
    inv = get_inverse(r, p)
    res = 1
    for i in range(r):
        res *= (n - i) % p
        res %= p
    for i in range(r):
        res *= inv[i] % p
        res %= p
    return res

def get_inverse(r, p):
    inv = [0] * r
    inv[0] = 1
    for i in range(1, r):
        inv[i] = (inv[p % i] * (p - int(p / i))) % p
    return inv

总结

在计算大量的组合数时，使用卢卡斯定理可以节省计算时间并降低时间复杂度。此外，卢卡斯定理还可以帮助解决一些其他问题，例如计算 Fibonacci 数列对 p 取模的值。