公式

行列式按某行某列展开，是另一种减少矩阵阶数的算法，将$n\times n$矩阵行列式计算减少到$(n-1)\times (n-1)$的矩阵，该算法按第$i$行展开的公式如下：
$$|A|=\sum _{j=1}^n{a}_{ij}{A}_{ij}$$
按第$j$列展开的公式如下：
$$|A|=\sum _{i=1}^n{a}_{ij}{A}_{ij}$$
其中$A_{ij}$是代数余子式cofactor。举个例子，以下矩阵的行列式按第一列展开：
$$\begin{gathered} \left|\begin{array}{cccc}1& -1& -2& -3\\ 3& -2& -1& -2\\ -5& 4& 3& 2\\ 6& 5& 4& 3\end{array}\right|= \\ 1\times \left|\begin{array}{ccc}-2& -1& -2\\ 4& 3& 2\\ 5& 4& 3\end{array}\right| \\ -3\times \left|\begin{array}{ccc}-1& -2& -3\\ 4& 3& 2\\ 5& 4& 3\end{array}\right| \\ -5\times \left|\begin{array}{ccc}-1& -2& -3\\ -2& -1& -2\\ 5& 4& 3\end{array}\right| \\ -6\times \left|\begin{array}{ccc}-1& -2& -3\\ -2& -1& -2\\ 4& 3& 2\end{array}\right| \\ =-122 \end{gathered}$$

python实现

    def cofactor_expansion(self, column=0):
        # 默认按第一列展开吧
        n = len(self.__vectors)
        if len(self.__vectors) == 2:
            return self.__vectors[0][0] * self.__vectors[1][1] - self.__vectors[0][1] * self.__vectors[1][0]
        result = 0
        for i in range(n):
            e = self.__vectors[column][i]
            result += e * self.cofactor(i, column)
        return result

Java实现

    /**
     * 余子式
     * @param line
     * @param column
     * @return
     */
    private T minor(int line, int column) {
        int n = this.array.length;
        T[][] arr = newArray(n - 1, n - 1);

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1; j++) {
                int col = j < column ? j : j + 1;
                int row = i < line ? i : i + 1;
                arr[i][j] = this.array[row][col];
            }
        }

        return createMatrix(arr).cofactor_expansion(0);
    }

    /**
     * 代数余子式
     * @param line
     * @param column
     * @return
     */
    private T cofactor(int line, int column) {
        final T minor = minor(line, column);
        return ((line + column) & 1) == 0 ? this.minor(line, column) : subtract(zeroValue(), minor);
    }

    private T determinant2x2() {
        final T a = multiply(this.array[0][0], this.array[1][1]);
        final T b = multiply(this.array[1][0], this.array[0][1]);
        return subtract(a, b);

    }

    public T cofactor_expansion(int line) {
        int n = this.array.length;
        if (n == 2) {
            return determinant2x2();
        }
        T sum = zeroValue();
        for (int i = 0; i < n; i++) {
            sum = add(sum, multiply(array[line][i], this.cofactor(line, i)));
        }
        return sum;
    }

技巧

在考研或期末考试时，如果遇到某一行或者某一列有很多0，可以采用这种方式减少运算量。如果没有那么多0，那么可以利用初等行变换变得某一列其余元素都是0.