排列+逆序数+奇偶排列+n阶行列式+代数余子式+伴随矩阵
排列+逆序数+奇偶排列+n阶行列式+代数余子式+伴随矩阵
一、排列
1、定义
$n$个自然数$(1,2,3,4,5, ... ,n)$按一定次序排成一个$\color{red}{无重复数字}$的$\color{red}{有序数组}$称为一个$\color{red}{n级排列}$，记为$i_{1}i_{2}i_{3}...i_{n}$。显然，n级排列共有$n!$。其中，排列$1234...n$称为$\color{red}{自然排列}$。2、判断下列排列级别
\(3421是一个4级排列。\)
\(25431是一个5级排列。\)
3、列出n级排列的所有可能结果
\(写出所有的3级全排列：\)
\(123，132，213，231，312，321\)
\(3! = 3 \times 2 \times 1 = 6种排列。\)
\(所以n级全排列有 n! 种排列。\)
\(n! = n \times (n-1) \times ... \times 1\)
二、逆序及逆序数
1、定义
在一个$n$级排列$i_{1}i_{2}i_{3}...i_{n}$中，若一个较大的数排在一个较小的数的前面，则称这两个数构成一个$\color{red}{逆序}$。一个排列中逆序的总数，称为这个排列的$\color{red}{逆序数}$，记为\[\tau(i_{1}i_{2}...i_{n})
\]
2、逆序数的计算方法(向前看法)
\(3\space4\space2\space1\)的逆序数
\[第一步：4和3没有构成逆序
\]
\[第二步：2和3构成了逆序，+1
\]
\[第三步：2和4构成了逆序，+1
\]
\[第四步：1和3构成了逆序，+1
\]
\[第五步：1和4构成了逆序，+1
\]
\[第六步：1和2构成了逆序，+1
\]
所以，\(3\space4\space2\space1\)的逆序数：\(5\)
三、奇排列和偶排列
1、定义
逆序数为奇数的排列为$\color{red}{奇排列}$。逆序数为偶数或\(0\)的排列为\(\color{red}{偶排列}\)。
2、判断奇偶排列
\(3241\)是奇排列，因为\(\tau(3241)=5\)
\(1234\)是偶排列，因为\(\tau(1234)=0\)
四、n阶行列式
1、定义
有一方阵\(A\)，\(A\)的行列式符号\(|A|\)
\[|A| =
\begin{vmatrix}
a_{11}&a_{12}&{...}&a_{1n}\\
a_{21}&a_{22}&{...}&a_{2n}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
a_{n1}&a_{n2}&{...}&a_{nn}\\
\end{vmatrix}
\]
|A|称为\(n\)阶行列式，它代表代数和
\[|A| = \sum_{j_{1}j_{2}...j_{n}}(-1)^{\tau(j_{1}j_{2}...j_{n})}a_{1j_{1}}a_{2j_{2}}...a_{nj_{n}}
\]
\[其中和式的排列j_{1}j_{2}...j_{n}要取遍n级排列
\]
2、说明
(1) 在行列式中，项$a_{1j1}\space a_{2j2}\space a_{3j3}\space ...\space a_{njn}$是取不同行不同列的n个元素的乘积。(2) 项\(a_{1j1}\space a_{2j2}\space a_{3j3}\space ...\space a_{njn}\)之前的符号为\((-1)^{\tau(j_{1}j_{2}...j_{n})}\)，这里\(\tau(j_{1}j_{2}...j_{n})\)为\(\color{red}{逆序数}\)。
\(\space\) \(\space\) (2-1) 逆序数为奇数时，符号为负。
\(\space\) \(\space\) (2-2) 逆序数为偶数时，符号为正。
(3) n阶行列式共有n!项。
(4) 行列式是把一个方阵变成一个标量。
(5) 一阶行列式\(|a|\)就是它本身\(a\)。
3、行列式的计算案例(python)
有一个4 \(\times\) 4矩阵，记作\(A\),求 \(|A|\)。
\[A =
\begin{bmatrix}
1&2&3&4\\
0&0&1&2\\
1&2&0&1\\
3&1&0&2\\
\end{bmatrix}
\]
np.linalg.det(A)
-15.000000000000007
五、代数余子式
1、定义
- \(n\)阶行列式中，把\(a_{ij}\)所在的第\(i\)行和第\(j\)列划去，留下\(n-1\)阶的行列式叫做\(a_{ij}\)的\(\color{red}{余子式}\)，记作\(\color{red}{M_{ij}}\)。
\[A_{ij} = (-1)^{i+j}M_{ij}
\]
- 这里\(A_{ij}\)为\(a_{ij}\)的\(\color{red}{代数余子式}\)。
六、伴随矩阵
1、定义
有一方阵\(A\)
\[A =
\begin{bmatrix}
a_{11}&a_{12}&{...}&a_{1n}\\
a_{21}&a_{22}&{...}&a_{2n}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
a_{n1}&a_{n2}&{...}&a_{nn}\\
\end{bmatrix}
\]
如果\(A_{ij}\)是矩阵\(A\)中元素\(a_{ij}\)的\(\color{red}{代数余子式}\)，那么\(A^{*}\)即是\(A\)的伴随矩阵
\[A^{*} =
\begin{bmatrix}
A_{11}&A_{21}&{...}&A_{n1}\\
A_{12}&A_{22}&{...}&A_{n2}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
{.}&{.}&{}&{.}\\
A_{1n}&A_{2n}&{...}&A_{nn}\\
\end{bmatrix}
\]
2、计算案例
求A的伴随矩阵
\[A =
\begin{bmatrix}
1&2&3\\
2&2&1\\
3&4&3\\
\end{bmatrix}
\]
\[A^{*} =
\begin{bmatrix}
A_{11}&A_{21}&A_{31}\\
A_{12}&A_{22}&A_{32}\\
A_{13}&A_{23}&A_{33}\\
\end{bmatrix}
=
\begin{bmatrix}
\begin{vmatrix}
2&1\\
4&3\\
\end{vmatrix}&
\begin{vmatrix}
2&3\\
4&3\\
\end{vmatrix}&
\begin{vmatrix}
2&3\\
2&1\\
\end{vmatrix}\\
\begin{vmatrix}
2&1\\
3&3\\
\end{vmatrix}&\begin{vmatrix}
1&3\\
3&3\\
\end{vmatrix}&\begin{vmatrix}
1&3\\
2&1\\
\end{vmatrix}\\
\begin{vmatrix}
2&2\\
3&4\\
\end{vmatrix}&
\begin{vmatrix}
1&2\\
3&4\\
\end{vmatrix}&
\begin{vmatrix}
1&2\\
2&2\\
\end{vmatrix}\\
\end{bmatrix}
=
\begin{bmatrix}
(-1)^{2}\times{2}&(-1)^{3}\times{-6}&(-1)^{4}\times{-4}\\
(-1)^{3}\times{3}&(-1)^{4}\times{-6}&(-1)^{5}\times{-5}\\
(-1)^{4}\times{2}&(-1)^{5}\times{-2}&(-1)^{6}\times{-2}\\
\end{bmatrix}
=
\begin{bmatrix}
2&6&-4\\
-3&-6&5\\
2&2&-2\\
\end{bmatrix}
\]
3、性质
- 伴随矩阵性质
\[AA^{*}=A^{*}A=|A|I
\]
- 伴随矩阵与逆矩阵
\[AA^{-1}=I
\]
\[A\frac{A^{*}}{|A|}=I
\]
- 综上
\[A^{-1}=\frac{A^{*}}{|A|}
\]
七、python实现伴随矩阵的方法
def get_adjugate_matrix(A):
if A.shape[0] != A.shape[1]:
print("错误：请输入方阵！")
return
n = A.shape[0]
A_adj = []
for i in range(n):
for j in range(n):
# 创建row、col数组
row, col = [], []
for idx in range(n):
row.append(idx)
col.append(idx)
# 删除第i行第j列
row.remove(i)
col.remove(j)
# ----- 代数余子式 -----
# 获取当前余子式
M_ij = A[np.ix_(row,col)]
# 当前余子式求行列式
M_ij = np.linalg.det(M_ij)
# 当前行列式取正负
A_ij = ((-1)**(i+j)) * M_ij
A_adj.append(A_ij)
A_adj = np.array(A_adj).reshape(n,n).T
return A_adj
B = np.array([[1,2,3],[2,2,1],[3,4,3]])
adjugate_matrix_B = get_adjugate_matrix(B)
reverse_matrix_B = adjugate_matrix_B / np.linalg.det(B)
print("伴随矩阵\n", adjugate_matrix_B)
print("逆矩阵\n", reverse_matrix_B)
伴随矩阵
[[ 2. 6. -4.]
[-3. -6. 5.]
[ 2. 2. -2.]]
逆矩阵
[[ 1. 3. -2. ]
[-1.5 -3. 2.5]
[ 1. 1. -1. ]]
