计算n阶行列式

摘要

本文主要介绍如何用拉普拉斯展开计算计算n阶行列式的值。

行列式

行列式（Determinant）是数学中的一个函数，将一个 ${n\times n}$的矩阵 ${A}$映射到一个纯量，记作 ${\det(A)}或{|A|}$。 ——摘自维基百科

说白了就是一个 ${n\times n}$的特殊矩阵。
但是虽然它跟矩阵很像，但也是两种不同的东西。

行列式的值

一个 ${2\times 2}$的行列式，又被称为二阶行列式。
对于行列式：A= ${\begin{bmatrix}1&2\\3&4\end{bmatrix}}$。
其值为：A = ${1\times 4 - 2\times 3 = -2}$
${3\times 3}$的行列式，又被称为三阶行列式。
对于行列：B= ${\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix}}$。
其值为：
$|B|=1\cdot {\begin{vmatrix}5&6\\8&9\end{vmatrix}}-2\cdot {\begin{vmatrix}4&6\\7&9\end{vmatrix}}+3\cdot {\begin{vmatrix}4&5\\7&8\end{vmatrix}}$
       ${\displaystyle {}=1\cdot (-3)-2\cdot (-6)+3\cdot (-3)=0}$。

以上对于三阶行列式的计算方式是：拉普拉斯展开。

拉普拉斯展开

在数学中，拉普拉斯展开（或称拉普拉斯公式）是一个关于行列式的展开式。将一个 $n×n$的行列式进行拉普拉斯展开，即是将其表示成关于行列式的某一行（或某一列）的n个元素与其代数余子式乘积的和。

余子式

对于行列式：B= ${\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix}}$。

${\begin{bmatrix}5&6\\8&9\end{bmatrix}}$是其去掉第一行和第一列后的一个余子式。

${\begin{bmatrix}4&6\\7&9\end{bmatrix}}$是其去掉第一行和第二列后的一个余子式。

在n阶行列式中，把所在的第i行与第j列划去后，所留下来的n-1阶行列式为余子式。

代数余子式

在n阶行列式中，把元素 $a_{ij}$所在的第 $i$行和第 $j$列划去后，留下来的n-1阶行列式叫做元素 $a_{ij}$的余子式，记作 $M_{ij}$， $M_{ij}\times(-1)^{i+j}$记为 $A_{ij}$， $A_{ij}$叫做元素 $a_{ij}$的代数余子式

对于行列式：B = ${\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix}}$。

$a_{11} 的代数余子式为：-1^{(1+1)}\times{\begin{vmatrix}5&6\\8&9\end{vmatrix}}$

$a_{12} 的代数余子式为：-1^{(1+2)}\times{\begin{vmatrix}4&6\\7&9\end{vmatrix}}$

$a_{13} 的代数余子式为：-1^{(1+3)}\times{\begin{vmatrix}4&6\\7&9\end{vmatrix}}$

根据拉普拉斯展开，按第一行将行列式展开就得到：
$|B| = a_{11} \times A_{11} + a_{12}\times A_{12} + a_{13}\times A_{13}$

       $= 1\cdot {\begin{vmatrix}5&6\\8&9\end{vmatrix}}-2\cdot {\begin{vmatrix}4&6\\7&9\end{vmatrix}}+3\cdot {\begin{vmatrix}4&5\\7&8\end{vmatrix}}$

       ${=1\cdot (-3)-2\cdot (-6)+3\cdot (-3)=0}$。

代码实现:

计算n阶行列式的值的代码实现就是模拟拉普拉斯展开,假定以第一行展开， 不断的n阶行列式降阶， 直到n等于2时可以直接交叉计算，所以我们可以用递归的思路写。
比如一个5阶行列式，按第一行展开，将其转化为5个4阶行列式，然后将这5个4阶行列式转化为5*4个3阶，最后转化为2阶。

先给出一道模板题：
试题 算法提高 计算行列式

代码：

	import java.io.*;

public class Main{
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
	
	public static int Int(String s){return Integer.parseInt(s);}
	
	public static void copy(int[][]A, int[][] A1, int i, int len) throws IOException{
		for(int x = 1; x < len; x++)
			for(int y = 0, j = 0; j < len; j++)
				if(j != i) {
					A1[x-1][y++] = A[x][j];
				}
	}
	
	public static int F(int[][] A, int len)throws Exception{
		int res = 0;
		if(len == 1)return A[0][0];
		if(len == 2){
			return A[0][0]*A[1][1] - A[0][1]*A[1][0]; // 递归出口
		}
		else{ 
			int A1[][] = new int[10][10];
			for(int i = 0; i < len; i++){
				copy(A, A1, i, len);// 得到余子式
				res += Math.pow(-1, i) * A[0][i] * F(A1, len-1); //递归式
			}
		}
		return res;
	}
	
	public static void main(String[] args) throws Exception{
		int n;
		n = Integer.parseInt(in.readLine());
		
		int arr[][] = new int[10][10];

		for(int i = 0; i < n; i++){
			String[] s = in.readLine().split(" "); 
			for(int j = 0; j < n; j++){
				arr[i][j] = Int(s[j]);
			}
		}
		
		out.write(F(arr, n) + "\n");
		out.flush();
	}
}

以上代码中用了一个递归函数求解行列式的值，用一个copy函数求解余子式的值，代码很简单，不再多解释了。