4.4 行列式按某行某列展开

醒过来摸鱼

已于 2023-05-19 14:29:19 修改

阅读量6.1k

点赞数 1

分类专栏：线性代数【更新中】文章标签：线性代数矩阵

于 2023-01-22 01:25:07 首次发布

本文链接：https://blog.csdn.net/m0_66201040/article/details/128747895

版权

线性代数【更新中】专栏收录该内容

71 篇文章 38 订阅

订阅专栏

文章目录

公式
python实现
Java实现
技巧

公式

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

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;
    }