组合数的计算方法（Combinatorial Number）

原创已于 2023-01-18 14:52:34 修改 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java

于 2023-01-18 14:04:47 首次发布

数据结构与算法同时被 2 个专栏收录

21 篇文章

订阅专栏

数学

3 篇文章

订阅专栏

文章介绍了计算组合数的四种方法，包括打表、阶乘无模、乘法逆元以及结合快速幂的优化方法，分别给出了它们的空间和时间复杂度，并强调了在大数模运算下如何高效计算组合数。

组合数：从 $n$ 个不同元素中取出 $m (m \leq n)$ 个元素的所有组合的个数，叫做从 $n$ 个不同元素中取出 $m$ 个元素的组合数。计算公式为：
$C(n,m)=n!/((n-m)!\times m!), \text{where}\ m\leq n$

性质1： $C (n, m) = C (n, n - m)$
性质2： $C (n, m) = C (n - 1, m - 1) + C (n - 1, m)$

第一种方法：打表

根据性质2直接构建一个 $n×nn\times n$ 的矩阵进行计算：

public class Template {
    static int mod = (int) 1e9 + 7;
    static int max = 110;
    static long[][] com = new long[max][max];

    public static void main(String[] args) {
        int n = 100, m = 30;
        for (int i = 0; i < max; i++) {
            com[i][0] = com[i][i] = 1;
            for (int j = 1; j < i; j++) {
                com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]) % mod;
            }
        }
        System.out.println(com[n][m]);
    }
}

空间复杂度： $O(n^2)$

预处理时间复杂度： $O(n^2)$ ，查询时间复杂度： $O (1)$

第二种方法：阶乘无模

根据组合的组合数的计算公式 $C(n,m)=n!/((n−m)!×m!)C(n,m)=n!/((n-m)!\times m!)$ 进行：

public class Template {
    static int mod = (int) 1e9 + 7;
    static int max = 110;
    static long[] fac = new long[max];

    public static void main(String[] args) {
        int n = 20, m = 10;
        fac[0] = 1;
        for (int i = 1; i < max; i++) {
            fac[i] = (fac[i - 1] * i);
        }
        System.out.println(fac[n] / fac[m] / fac[n - m]);
    }
}

空间复杂度： $O (n)$

预处理时间复杂度： $O (1)$ ，查询时间复杂度： $O (n)$

由于涉及除法，无法直接取模，所以引入乘法逆元。

第三种方法：乘法逆元

逆元：对于 $a$ 和 $p$ （ $a$ 和 $p$ 互素），若 $a∗b%p≡1a*b\%p\equiv1$ ，则称 $b$ 的最小正整数解为 $a$ 的逆元。

当求解 $(a/b)%p(a/b)\%p$ ，如果知道 $b%pb\%p$ 的逆元为 $c$ ，那么可以转化为 $(a/b)%p=a∗c%p=(a%p)(c%p)%p(a/b)\%p=a*c\%p=(a\%p)(c\%p)\%p$ 。暴力做法：

public class Template {
    static int mod = (int) 1e9 + 7;
    static int max = 110;
    static long[] fac = new long[max];
    static long[] inv = new long[max];

    public static void main(String[] args) {
        int n = 100, m = 30;
        inv[0] = fac[0] = 1;
        for (int i = 1; i < max; i++) {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = inv(fac[i]);
        }
        System.out.println(((fac[n] * inv[m]) % mod * inv[n - m]) % mod);
    }

    public static long inv(long a) {
        for (int x = 1; x < mod; x++) {
            if (a * x % mod == 1) return x;
        }
        return 0;
    }
}

空间复杂度： $O (n)$

预处理时间复杂度： $O (p)$ ，其中 $p = m o d$ ，查询时间复杂度： $O (1)$

第四种方法：乘法逆元+快速幂+阶乘

费马小定理：对于a和素数p，满足 $ap−1%p≡1a^{p-1}\%p\equiv 1$ 。

因为 $a^{p-1}=a^{p-2}*a$ ，所以有 $ap−2∗a%p≡1a^{p-2}*a\%p\equiv 1$ 。根据逆元的定义可知， $a^{p-2}$ 是 $a$ 的逆元。因此可以将求解逆元的问题转换为 $a^{p-2}$ 的快速幂问题。

public class Template {
    static int mod = (int) 1e9 + 7;
    static int max = 110;
    static long[] fac = new long[max];
    static long[] inv = new long[max];

    public static void main(String[] args) {
        int n = 100, m = 30;
        inv[0] = fac[0] = 1;
        for (int i = 1; i < max; i++) {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = inv(fac[i]);
        }
        System.out.println(((fac[n] * inv[m]) % mod * inv[n - m]) % mod);
    }

    public static long pow(long a, long b) {
        long ans = 1;
        while (b > 0) {
            if ((b & 1) == 1) ans = (ans * a) % mod;
            a = a * a % mod;
            b = b >> 1;
        }
        return ans;
    }

    public static long inv(long a) {
        return pow(a, mod - 2);
    }
}