线性方程组与矩阵

定义

线性方程组指的是形如

的方程组。其中我们肯定很熟悉二元一次方程组的解法，而这也属于线性方程组。

其中数字 $b_i$ 叫做第 $i$ 个方程的常数项。特别的，如果所有 $b_i=0$，那么则称这个方程组是齐次的。这个方程组就是上个方程组相对应的齐次方程组，或称上个方程组的诱导组。而未知数的系数正好可以排成一个长方形的表。

叫做一个 $m\times n$ 的矩阵。如果 $n=m$，则称作是 $n$ 阶方阵。可以用 $(a_{i,j})$ 或大写字母（通常用 $A$）简示。第 $i$ 行，第 $j$ 列的元素是 $a_{i,j}$，读作 $a-i-j$（zfy 注）。自然地，我们使用 $(a_{i1},a_{i2},\cdots,a_{in})$ 表示上面矩阵的第 $i$ 行。而对于某一列，我们使用中括号，即 $[a_{1j},a_{2j},\cdots,a_{mj}]$，来表示。当矩阵是一个方阵时，我们称元素 $a_{11},a_{22},\cdots,a_{nn}$ 组成了该矩阵的主对角线。如果除了主对角线，其他元素都是 $0$，那么则称该方阵为对角矩阵，有时记作：

当一个对角矩阵满足 $a_{11}=a_{22}=\cdots=a_{nn}=k$，那么就称该方阵为纯量矩阵，记作 $\operatorname{diag}_n(k)$。$\operatorname{diag}_n(1)$ 称作单位矩阵，通常记作 $E_{n}$，当矩阵阶数确定时可简记为 $E$。（个人常把它记为 $I$）

同时，我们定义最开始的方程组的增广矩阵为 $(a_{i,j}|b_j)$。即在上面那个矩阵后面加一列 $[b_1,b_2,\cdots,b_m]$ 来表示常系数。为清楚起见，我们用竖线将 $a,b$ 两部分分开。

假如我们用数字 $y_i$ 代表未知数 $x_i$，原方程组的所有式子全部变为恒等式，那么就称 $n$ 个数组成的有序组 $y_{1},y_{2},\cdots,y_{n}$ 为原方程组的一个解，而 $y_i$ 称为解的第 $i$ 个分量。这时也称有序组 $y_1,y_2,\cdots,y_n$ 满足原方程组的每一个方程。没有任何解的方程组叫做不相容的，有解的方程组叫做相容的，如果只有唯一解，就叫做确定的，解的个数多于一个的方程组叫做不定的。

前置推论

解这个方程之前，我们先来学习几个前置推论。

假设我们有一个与最开始的方程组未知数个数和方程个数相同的线性方程组，称作方程组 $(1)$。如果 $(1')$ 是 $(1)$ 中除 $i,k$ 之外的所有方程不变，而第 $i,k$ 个方程交换位置，则称 $(1')$ 是由 $(1)$ 经过 I 型初等变换 得到的。

如果 $(1)$ 中除第 $i$ 个之外的所有方程保持不变，而第 $i$ 个方程变为：

则称变换后的方程组 $(1')$ 是由 $(1)$ 经过 II 型初等变换 得到的。其中，$c$ 是一个常数。这个变换可以理解为行向量 $[a_i]$ 加上数乘 $c$ 后的行向量 $[a_k]$ 后得到的。

如果两个线性方程组同时是不相容的，或者同时是相容的且有相同的解，那么就称这两个线性方程组是等价的。两个等价的方程组 $(a)$ 和 $(b)$ 记作： $(a)\sim (b)$。注意到该等价满足自反性，即 $(a)\sim(a)$；还满足对称性，即 $(a)\sim(b)\leftrightarrow (b)\sim(a)$；也满足传递性，即 $(a)\sim(b),(b)\sim(c)\to (a)\sim(c)$。

通过上面的定义，我们可以证明等价性的充分条件了。

定理 $1$：如果一个线性方程组是由另一个线性方程组进行多次初等变换得到，则这两个方程组等价。

证明：

通过传递性可知，我们只需要证明方程组 $(1')$ 是由方程组 $(1)$ 经过初等变换得到，并且方程组 $(1')$ 与 $(1)$ 等价即可。

首先我们不难证明这两个初等变换是可逆的，即 I/II 型初等变换可以再变换一次变换回来。那么如果证明 $(1)$ 的所有解满足 $(1')$ 即可。

对于 I 型初等变换，我们不难发现交换方程式对于方程组没有本质改变，之前的解依然满足变换后的方程组。

对于 II 型初等变换，我们可以直接把那个改变了的式子拆出来然后将 $(1)$ 中的式子带入 $(1')$ 不难发现直接满足。

最后说明一个方程的不相容性代表另一个方程的不相容性，这个用反证法和上面过程差不多就证完了。

高斯消元

终于进入主题了。

高斯消元的思想就是通过施行一系列的初等变换，将给定的方程组转化为较简单的形式。

首先需要钦定在系数 $a_{i1}$ 中至少有一个不为 $0$。如果没有那么这个方法就退化了一阶。如果有我们就可以先使用 I 型初等变换把这个系数所对应的方程移动到第一个，然后使用 $m-1$ 次 II 型初等变换把其它方程中所有第 $1$ 列的系数全部变为 $0$。这时这个方法退化一阶，直接求解下一层，直到一层中只留下了一个方程为止。结束变换后的方程组是阶梯状的，于是我们把这种方程组称作是阶梯形的。

定理 $2$：任意线性方程组都等价于一个阶梯形的方程组。

这个结论可以直接由上面的推导证明。

定理 $2'$：任意矩阵可以由初等变换变化成阶梯形。

可以把任意矩阵当做是某线性方程组的增广矩阵。

求解这个阶梯形方程组就容易多了，但是还是有许多情况要讨论。

首先从相容性问题入手，如果这个阶梯形方程组包含一个 $0=b_t'$ 且 $b_t'\not =0$，那么这个方程组一定不相容。我们可以证明如果阶梯形方程组不包含这种方程就一定相容。因为这样的话有效行数 $t$ 小于等于未知数个数 $r$，而我们如果钦定其中的 $r-t$ 个未知数是自由变量的话，那么这些变量随意取的情况下，剩下的 $t$ 个未知变量如果组成严格阶梯形线性方程组，那么一定有唯一解，换句话说，如果 $r>t$，这个方程组相容但不确定，如果 $r=t$，这个方程组相容且确定，如果 $r<t$，这个方程组不相容。

对于相容但不确定的线性方程组，我们可以倒序求解每个值，如果遇到一个消元完之后还有两个及其以上参数的方程，那么就把这个靠后的几个未知数随机赋值（懒人可以直接赋成 $0$），然后继续倒序求解。

讲了这么多数学推导，读者应该都了解高斯消元的主题过程及其正确性了，那么，我们来讲讲 OI 中如何高斯消元。

最简单的实现是直接按上面的模拟，除法就直接使用 double 就行了。

玄学的是，每次找最大的值拿来消元精度会更高。如果有取模要求就取逆元就行了。

更加优美的一个实现方法是，每次直接暴力把这列除其本身外的所有数全部消至 $0$，这样剩下的矩阵就是一个类对角矩阵，这样更方便于求解每个未知数的值。

模板：P3389

#include<bits/stdc++.h>
using namespace std;
#define db long double
const db eps=1e-8;
db a[105][105];
int n;
bool gauss(){
	for(int i=1;i<=n;i++){
		int maxpos=i;
		for(int j=i+1;j<=n;j++)if(fabs(a[j][i])>fabs(a[maxpos][i]))maxpos=j;//若不加fabs，最大值有可能为0，寄 
		if(maxpos!=i)swap(a[i],a[maxpos]);
		if(fabs(a[i][i])<eps)return 0;
		for(int j=1;j<=n;j++){
			if(j^i){
				db p=a[j][i]/a[i][i];
				for(int k=i;k<=n+1;k++)a[j][k]-=p*a[i][k];
			}
		}
	}
	return 1;
}
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n+1;j++){
			cin>>a[i][j];
		}
	}
	if(gauss()){
		for(int i=1;i<=n;i++)cout<<fixed<<setprecision(2)<<a[i][n+1]/a[i][i]<<"\n";
	}else cout<<"No Solution\n";
	return 0;
} 

这道题数据较弱，实际上上面的代码并不完善。因为有些时候我们需要判断这个方程是无穷解还是无解，所以如果出现这一列全为 $0$，但是下一行移到的位置及其以下都是 $0$，并且原一列相应位置不为 $0$，那么就错过了一列可消元的一列，从而造成答案有误。

因此我们维护可消元行的上下限就行了。如果出现了 真正的全 0 列，那么再记录为无解 / 无穷解，并维护上下限。

最后我们用我们之前推出来无解的条件（即存在 $0=b_i,b_i\not=0$）判断即可。

对应模板：P2455

#include<bits/stdc++.h>
using namespace std;
#define db long double
const db eps=1e-10;
db a[105][105];
int n;
int gauss(){
	bool o=0;
	for(int i=1,r=1;i<=n&&r<=n;i++,r++){
		int maxpos=i;
		for(int j=i+1;j<=n;j++)if(fabs(a[j][r])>fabs(a[maxpos][r]))maxpos=j;//若不加fabs 最大值有可能为 0，寄 
		if(maxpos!=i)swap(a[i],a[maxpos]);
		if(fabs(a[i][r])<eps){
			o=1;
			i--;
			continue;
		}
		for(int j=1;j<=n;j++){
			if(j^i){
				db p=a[j][r]/a[i][r];
				for(int k=r;k<=n+1;k++)a[j][k]-=p*a[i][k];
			}
		}
	}
	if(!o)return 1;
	for(int i=1;i<=n;i++){
		o=0;
		for(int j=1;j<=n&&!o;j++)o=fabs(a[i][j])>eps;//,cout<<a[i][j]<<" ";
//		cout<<a[i][n+1];
//		cout<<"\n";
		if(!o&&fabs(a[i][n+1])>eps)return -1;
	}
	return 0;
}
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n+1;j++){
			cin>>a[i][j];
		}
	}
	int op=gauss();
	if(op==1){
		for(int i=1;i<=n;i++)cout<<"x"<<i<<"="<<fixed<<setprecision(2)<<(fabs(a[i][n+1]/a[i][i])<eps?0:a[i][n+1]/a[i][i])<<"\n";
	}else cout<<op;
	return 0;
} 

高斯消元的应用之后再说。

行列式定义

行列式（$\texttt{Determinant}$）是一个函数定义，取值是一个标量。

在《代数学引论》中定义为了 用于求解线性方程组的一般公式所需要的量。

对于一个 $n$ 阶方阵 $A$，其 $n$ 阶行列式写作 $\det(A)$ 或者 $|A|$，定义为：

其中我们定义 $p$ 是一个 $1\sim n$ 的任何一个排列（全排列）。而 $\tau(p)$ 指排列 $p$ 中的逆序对个数。

定义一个排列 $p$ 的奇偶性就是 $\tau(p)$ 的奇偶性，即当 $\tau(p)$ 为偶数时，排列 $p$ 是偶排列，当 $\tau(p)$ 为奇数时，排列 $p$ 是奇排列。此时有性质：对于一个 $n$ 阶排列的所有排列情况，奇排列和偶排列各占一半。

定义在排列 $p$ 交换其中的两个元素的操作（其他元素不变）叫对换。显然，一次对换会改变一个排列的奇偶性。任意一个排列可以通过若干次对换变成一个元素升序排列的自然排列，对换次数奇偶性与原排列的奇偶性相同。

行列式性质

下面给出几条可能会用到的性质：

性质 $1$：将矩阵的任意 $2$ 行 / 列交换，行列式取反。

这个相当于是把之前所有的用于行列式计算的排列全部进行一次对换，那么排列奇偶性和 $\tau(p)$ 奇偶性都取反，那么行列式的值也取反。

性质 $2$：进行一次矩阵转置，行列式不变。

矩阵转置指的是行列互换后的矩阵，对于方阵可以理解为对于主对角线对称一次。

显然，转置之后不影响所有的排列选择，故行列式不变。

之后对于所有对于行都满足的结论均可以用性质 $2$ 直接证明列的情况。

性质 $3$：行列式某行（列）的所有元素等比例变化（即都乘上一个数 $k$），则行列式也等比例变换。

把行列式式子拆成定义形式，把那个乘的 $k$ 提出来即可。

性质 $4$：如果行列式对应矩阵 $A$ 中有一行是由两个数加起来的，那么把两个数拆出来，剩余数不变的两个矩阵 $B$，$C$ 满足 $\det(A)=\det(B)+\det(C)$。

同样拆成定义式子，然后乘法分配律一下就证完了。

性质 $5$：如果行列式对应矩阵 $A$ 中有一行与另一行成比例，那么 $\det(A)=0$。

好像可以直接拆，但是好像需要较为复杂的计算。这里有一个较为巧妙的证明。

我们可以首先将这成比例的两行交换，根据性质 $1$，有 $\det(A)=-\det(A')$。

然后根据性质 $3$，我们可以消掉这个 $k$，得到 $\det(A_{\neg k})=-\det(A'_{\neg k})$，而我们有 $A_{\neg k}=A'_{\neg k}$，所以我们又有 $\det(A_{\neg k})=\det(A'_{\neg k})$，从而得到这个矩阵的行列式为 $0$，乘上 $k$ 得到 $\det(A)=0$。

性质 $6$：把一个矩阵的某一行乘上一个数加到另一行上，行列式不变。

这个其实已经非常显然了。性质 $4$ 和性质 $5$ 结合起来看就行了。

行列式求值

讲了这么多了，该开始讲行列式求值了。

首先我们为了简化行列式计算量，最好的方式就是添 $0$，因为 $0$ 可以让很多排列的贡献都变成 $0$。我们不由得想到高斯消元，因为高斯消元可以让一个矩阵变成阶梯矩阵，对于方阵，此时有贡献的只有主对角线上的元素积。

根据性质 $6$，高斯消元所涉及的 II 型初等变换对行列式的值没有影响。根据性质 $1$，高斯消元涉及的 I 型初等变换会对行列式的值取反。

那么直接模拟高斯消元的过程，记录一个正负性变量，每交换一次就改变一次这个变量就行了。最后直接计算主对角线元素积即可。如果中间出现了任何一列扫描到全 $0$，根据高斯消元的定理 $2'$，行列式的值就是 $0$。

但是行列式是一个整数值，不能使用 double 求，需要逆元。

恰巧，模数不一定是质数，那么我们就要使用另一种方式高斯消元了。

考虑我们的目的实际上是每次对于两行，将某一行一列的值通过两者互消的方式变为 $0$。

那么我们使用辗转相除法，这个方法保证除完一定有一个值为 $0$，并另一个值非 $0$。我们可以每次选取两个非 $0$ 行进行辗转相除法消元，然后把最后非 $0$ 行直接移到原主对角线上列的对应行（即第 $i$ 行）。这样我们能保证开始时第 $i$ 行一定有值，那么我们每次以第 $i$ 行值为除数，第 $i$ 行值为 $0$ 为终止条件进行辗转相除即可。这时我们一定能保证最后的非 $0$ 值一定在正在被枚举到的行上，将这两行交换即可。重复以上过程，就能达到高斯消元最后的阶梯矩阵形式。

这样乍一看复杂度不对啊，不是 $O(n^3\log V)$ 吗？但是我们每次消元目标是直接消成 $0$，那么要消成 $0$ 的数有 $O(n^2)$ 个，每一次消掉一个数的代价是 $O(\log V)$，所以求行列式的时间复杂度实际上是 $O(n^2\log V+n^3)$。

模板：P7112

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,mod;
int a[605][605];
int gauss(){
	int res=0,syb=1;
	for(int i=1;i<=n;i++){
		int maxpos=i;
		for(int j=i+1;j<=n;j++)if(a[j][i]>a[maxpos][i])maxpos=j;
		if(a[maxpos][i]==0)return 0;
		if(maxpos^i)swap(a[i],a[maxpos]),syb=-syb;
		for(int j=i+1;j<=n;j++){
			while(a[i][i]){
				int div=a[j][i]/a[i][i];
				for(int k=i;k<=n;k++)a[j][k]=(a[j][k]+(mod-(div*a[i][k])%mod))%mod;
				swap(a[j],a[i]);
				syb=-syb;
			}
			swap(a[j],a[i]);
			syb=-syb;
		}
	}
	res=syb;
	for(int i=1;i<=n;i++)res=res*a[i][i]%mod;
	return (res+mod)%mod;
}
signed main(){
	ios::sync_with_stdio(0);cin.tie(0),cout.tie(0);
	cin>>n>>mod;
	for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)cin>>a[i][j],a[i][j]%=mod;
	cout<<gauss();
	return 0;
}

行列式的应用同样后面再说。

向量空间

首先补一下前面跳过的知识：设 $X,Y$ 是任意两个集合。任取 $x\in X,y\in Y$，给定顺序的元素对 $(x,y)$，叫做一个有序对，这时两个有序对 $(x_1,y_1),(x_2,y_2)$ 相等当且仅当 $x_1=y_1$ 且 $x_2=y_2$。

全体有序对 $(x,y)$ 的集合

叫做两个集合 $X,Y$ 的笛卡尔积。

相应的，我们定义笛卡尔幂就是一个集合多次与自己作笛卡尔积后的结果。

那么我们设 $n$ 是一个固定的自然数，$\R$ 上长为 $n$ 的行向量空间指集合 $\R^n$（其元素称为行向量或简称向量），连同向量的加法运算以及纯量（实数）与向量的乘法运算。相信大家已经知道矩阵的各种运算了，此处由于向量等于说是一个 $1\times n$ 的矩阵，所以此处就不提向量的运算了，但是记住向量和矩阵都满足乘法分配律就行了。

除了长为 $n$ 的行向量空间外，也存在高为 $n$ 的列向量空间。列向量的表达形式在定义一节中已经提到。

设 $X_1,X_2,\cdots,X_k$ 是向量空间 $\R^n$ 中的向量，$\alpha_1,\alpha_2,\cdots,\alpha_k$ 是纯量，则向量 $X=\alpha_1X_1+\alpha_2X_2+\cdots+\alpha_kX_k$ 叫做向量 $X_i$ 的带有系数 $a_i$ 的线性组合。举个例子：

不难发现两个线性组合 $X,Y$ 如果所组合的向量一致就一定有 $\alpha X+\beta Y$ 也是线性组合。于是我们有结论，由给定向量组 $X_1,X_2,\cdots, X_k$ 的所有线性组合构成的集合 $V$ 具有性质：

特别的，零向量（全零向量）永远包含在 $V$ 中。

$V$ 通常用符号 $\langle X_1,X_2,\cdots,X_k \rangle$ 表示，并通常称为向量组 $X_1,X_2,\cdots,X_k$ 的线性包（或简称为包）。包是在该向量组上张成的（或生成的）。

定义单位行向量 $E_i$ 即为：

其满足在行向量空间 $\R^n$ 中满足 $\R^n=\langle E_i \rangle$。单位列向量同，不过通常以 $E^{(i)}$ 表示。

如果可以找到 $k$ 个不全为 $0$ 的数 $a_1,a_2,\cdots,a_k$ 能使空间 $\R^n$ 的向量组 $X_1,X_2,\cdots,X_k$ 满足

（右边是零向量），则称该向量组线性相关，并称上式为非平凡的。如果 $a_1X_1+a_2X_2+\cdots+a_kX_k=0\Rightarrow a_1=a_2=\cdots=a_k=0$，则该向量组线性无关。

设 $V$ 是 $\R^n$ 中的一个非零线性包，向量组 $X_1,X_2,\cdots,X_k\in V$ 称为 $V$ 的基，当且仅当该向量组线性无关，且其生成的线性包与 $V$ 重合，即 $\langle X_1,X_2,\cdots,X_k\rangle=V$。

从基和线性包的定义推出，每一个向量 $X\in V$ 都可以唯一地写成 $a_1X_1+a_2X_2+\cdots+a_kX_k=X$，系数 $a_1,a_2,\cdots,a_k\in \R$ 称作 $X$ 对于基 $X_1,X_2,\cdots,X_k$ 的坐标。

不难发现 $E_1,E_2,\cdots,E_n$ 就是 $\R^n$ 的一组基，特别的，我们称这组基为标准基，但这不是 $\R^n$ 空间中的唯一一组基，比如这组基全部乘上 $2$ 也是 $\R^n$ 空间的一组基。

引理：设 $V$ 是 $\R^n$ 中以 $X_1,X_2,\cdots,X_k$ 为基的线性包，而 $Y_1,Y_2,\cdots,Y_t\in V$ 并且线性无关，那么 $t\leq k$。

证明：拆出 $Y_i$ 的线性组合式，再列出线性无关性质式：

考虑使用反证法。设 $t>k$，将线性组合式带入上式，有

有线性方程组

由于 $t>k$，在讲高斯消元时有定理可以证明该方程有非全 $0$ 解，那么 $Y_i$ 向量组线性相关，矛盾。

定理 $1$：$\R^n$ 中的所有非零线性包 $V$ 都至少有一组有限基。

证明：首先，除零向量外的任意一个向量组成的向量组都是线性无关的。设我们现在已经找到了一个线性无关的向量组 $X_1,X_2,\cdots,X_k$。若 $\langle X_1,X_2,\cdots,X_k\rangle$ 不等于 $V$，那么就一定有 $X_{k+1}\in V$ 不是 $X_1,X_2,\cdots,X_k$ 的线性组合。根据线性组合的性质，$X_{k+1}$ 也不是 $X_1,X_2,\cdots,X_k$ 的任意一个子组合的线性组合。那么 $X_{k+1}$ 不能抵消任何一个原向量组的任何一个线性组合，那么 $X_1,X_2,\cdots,X_{k+1}$ 也是线性无关的。这样对于向量组的扩张是无穷的，直到 $\langle X_1,X_2,\cdots,X_{k'}\rangle$ 等于 $V$。我们称此时的线性无关组是极大的，此时这个向量组就是 $V$ 的一组有限基。

定理 $2$：$\R^n$ 中的任意非零线性包 $V$ 的所有基元素个数 $r$ 都相等，且 $r\leq n$。

证明：假如说 $V$ 存在两个不同的基，设元素个数分别是 $k_1,k_2$，那么根据引理，我们可以知道 $k_2\leq k_1$ 且 $k_1\leq k_2$，则有 $k_1=k_2$。而 $\R^n$ 的标准基长度为 $n$，所以其内元素个数一定小于等于最大基长度（标准基长度） $n$。

我们记 $r$ 是线性包 $V$ 的维数，记为 $\dim_{\R} V$ 或简记为 $\dim V$。其实 $r$ 就是极大线性无关子向量组的元素个数。

向量组的秩的定义就是对于一个向量组 $X_i$，其张成的线性包的最大维数。于是有：

当 $V=\{0\}$ 时（零线性包），有 $\dim V=0$。

定义线性包的和是：

特别地，当 $U\cap V=0$ 时，称这是线性包的直和。

一个矩阵的秩就是每行组成的行向量的向量组的秩。

矩阵运算

较为简单，乘法与加法就不讲了。

设 $V$ 的维数为 $n$，$V$ 的一组基为 $a_1,a_2,\cdots,a_n$，$T$ 是 $V$ 上的一个线性变换，则有：

化为矩阵就是 $T(a_1,a_2,\cdots,a_n)=(Ta_1,Ta_2,\cdots,Ta_n)=(a_1,a_2,\cdots,a_n)A$。

矩阵 $A$ 就是线性变换 $T$ 在这组基下的矩阵表现形式。

显然 $T$ 确定时，$(Ta_1,Ta_2,\cdots,Ta_n)$ 确定，所以 $T$ 能唯一确定一个 $A$。

所以有些时候 dp 和 ds 题是线性变换的时候就可以使用矩阵维护。

对矩阵乘法进行推广：

定义广义矩阵乘法是对于矩阵 $A,B$，形如：

的式子。我们将其称作是 $(\oplus,\otimes)$ 的矩阵乘法。

当 $(\oplus,\otimes)$ 满足以下条件时，该广义矩阵乘法满足结合律：

• $\oplus$ 具有交换律。
• $\otimes$ 具有交换律和结合律。
• $\otimes$ 对 $\oplus$ 有分配率，即 $(a\oplus b)\otimes c=(a\otimes c)\oplus (b\otimes c)$。

常见的矩阵乘法形式有 $(\pm,\max),(\pm,\min),(\operatorname{and},\operatorname{or})$。

矩阵求逆

定义一个矩阵 $A$ 的逆矩阵就是满足 $AA'=I$ 的矩阵，用 $A^{-1}$ 表示。

如何求一个矩阵的逆矩阵呢？

定义一个初等矩阵就是描述我们之前提到的高斯消元的两个初等变换。举个例子，对于 $n=4$，交换第 $2,3$ 行的 I 类初等变换对应的初等矩阵就是

对于 $n=4$，将第 $3$ 行乘上 $5$ 加到第 $1$ 行的初等矩阵是

假设初等矩阵我们用 $P_i$ 表示，那么如果我们能将原矩阵 $A$ 变换成 $I$，那么就有 $P_1P_2\cdots P_kA=I$，从而我们推出 $A^{-1}=P_1P_2\cdots P_k$。

那么由于每次变换相当于左乘一个初等矩阵。由于 $A^{-1}I=IA^{-1}$，所以我们可以把 $A$ 和 $I$ 拼到一起进行高斯消元，将原矩阵消成一个对角矩阵之后再除以对应系数从而消成单位矩阵，这时右侧就是矩阵求逆之后的结果。

判断矩阵是否可逆就直接消元时判断该矩阵能不能消成一个对角矩阵就行了。

在具体的实现中，我们可以每消完一行就除去当前行对应的值，可以省去一次求逆元的过程。

模板：P4783

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1e9+7;
int ksm(int a,int b){
	if(b==0)return 1;
	if(b==1)return a;
	return (b&1?a:1)*ksm(a*a%mod,b/2)%mod;
}
int a[401][801],n;
bool gauss(){
	for(int i=1;i<=n;i++){
		int maxpos=i;
		for(int j=i+1;j<=n;j++)if(a[j][i]>a[maxpos][i])maxpos=j;
		if(maxpos^i)swap(a[i],a[maxpos]);
		if(a[i][i]==0)return 1;
		int Ii=ksm(a[i][i],mod-2);
		for(int j=1;j<=n;j++){
			if(j^i){
				int p=a[j][i]*Ii%mod;
				for(int k=i;k<=n*2;k++){
					a[j][k]=(a[j][k]+mod-p*a[i][k]%mod)%mod;
				}
			}
		}
		for(int k=i;k<=n*2;k++)a[i][k]=a[i][k]*Ii%mod;
	}
	return 0;
}
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)cin>>a[i][j];
	for(int i=1;i<=n;i++)a[i][i+n]=1;
	if(gauss()){
		cout<<"No Solution";
		return 0;
	}
	for(int i=1;i<=n;i++){
		for(int j=n+1;j<=n*2;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<"\n";
	}
	return 0;
}

注意有些地方是 n*2 而不是 n。

线性基

普通的线性基就是我们之前在向量空间一节定义的基，这个基可以解决很多关于线性方程组的问题。

如何构造一组线性基？最简单的方法就是高斯消元出极大线性无关组。

线性基通常分为两类，如果向量定义在 $\Z_2^n$ 空间内，则该线性基称为异或线性基。如果向量定义在 $\R^n$ 空间内，则称该线性基为实数线性基。

异或线性基

我们已经了解了一种求异或线性基的方式：高斯消元。把原来的 $n$ 个数理解成一个 $n\times \log V$ 的矩阵，消成类对角矩阵之后，剩余有 $1$ 的位置就是一组极大线性无关组，而它求最大时的贡献就是所有 $1$ 的位置组成起来的数。那么我们就能解决最大最小和排名 $k$ 大问题，时间复杂度是 $O(n^2)$。

考虑优化。我们使用贪心来构造一组神秘的按位首组的基。这组基的性质就是可能不是从原来的数中抽取的极大线性无关组，但是构造出来的一定是一个上三角矩阵。这样就和高斯消元后的结果本质相同，询问时也贪心地填满是 $0$ 的位置就行了。插入时，我们可以直接从大到小枚举基内元素，如果枚举到一位有数，那么我们将目前数异或上当前位上的数来消位以继续枚举下一位，而如果枚举到一位没有数，那么直接将目前数插入到该位置上。时间复杂度是 $O(n\log V)$，通过询问的贪心可以知道正确性显然。

贪心法不能直接解决第 $k$ 大的问题，需要进行几步转化。我们已经知道贪心法构造出一组线性基的矩阵大小是 $\log V\times \log V$ 的。所以我们可以对这个矩阵进行暴力高斯消元消成对角矩阵，然后就能对 $k$ 进行二进制拆分，像高斯消元那样做了。时间复杂度 $O(n\log^2 V)$。

具体实现非常简单，这里给出两个版本的线性基。

模板：P3812

贪心版实现：

#include<bits/stdc++.h>
using namespace std;
#define int long long
struct lbase{
	int num[52];
	void ins(int p){
		for(int i=log2(p)+1;i>=0;i--){
			if(!(p>>i))continue;
			if(num[i])p^=num[i];
			else{
				num[i]=p;
				break;
			}
		}
		return;
	}
	int qu(){
		int res=0;
		for(int i=50;i>=0;i--){
			if((res>>i)&1)continue;
			res^=num[i];
		}
		return res;
	} 
}T;
int n,x;
signed main(){
	ios::sync_with_stdio(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>x,T.ins(x);
	cout<<T.qu();
	return 0;
} 

高斯消元版实现：

#include<bits/stdc++.h>
using namespace std;
#define int long long
int a[51],n;
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i];
	int yyy=0;
	for(int i=1,r=50;i<=n&&r>=0;yyy++,i++,r--){
		int j;
		for(j=i;j<=n;j++)if(a[j]&(1ll<<r))break;
		if(j<=n&&j^i)swap(a[j],a[i]);//注意j<=n这个条件易漏！ 
		if(!(a[i]&(1ll<<r))){yyy--;i--;continue;}
		for(j=1;j<=n;j++)if(j^i&&(a[j]&(1ll<<r)))a[j]^=a[i];
	}
	int ans=0;
	for(int i=1;i<=yyy;i++)ans^=a[i];
	cout<<ans;
	return 0;
}

实数线性基

对于实数线性基，我们就不能像之前一样贪心构造一组基了。考虑高斯消元，每次交换 $id$，我们就能构造出一组线性基。

模板：P3265 [JLOI2015] 装备购买

这道题是要求我们找到一个特定价值最小的一组基。根据基的求法，我们每次找到一个非 $0$ 且花费最小的物品来消元即可。为减小常数，我们还可以初始时按花费先排个序。时间复杂度 $O(n^2m)$。

#include<bits/stdc++.h>
using namespace std;
int rk[501],val[501],v[501];
int n,m;
long double ray[501][501];
long double* ra[501];
const long double eps=1e-5;
bool cmp(const int &a,const int &b){
	return val[a]<val[b];
}
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		rk[i]=i;
		for(int j=1;j<=m;j++)cin>>ray[i][j];
	}
	for(int i=1;i<=n;i++)cin>>val[i];
	sort(rk+1,rk+n+1,cmp);
	for(int i=1;i<=n;i++)v[i]=val[rk[i]],ra[i]=ray[rk[i]];
	int l=1;
	for(int i=1;i<=m&&l<=n;i++,l++){
		int pos;
		for(pos=l;pos<=n;pos++)if(fabs(ra[pos][i])>eps)break;
		if(pos>n){l--;continue;}
		for(int j=pos;j>=l+1;j--)swap(ra[j],ra[j-1]),swap(v[j],v[j-1]);
		for(int j=l+1;j<=n;j++){
			long double p=ra[j][i]/ra[l][i];
			for(int k=i;k<=m;k++)ra[j][k]-=ra[l][k]*p;
		}
	}
	cout<<l-1<<" ";
	int ans=0;
	for(int i=1;i<l;i++)ans+=v[i];
	cout<<ans;
	return 0;
} 

线性基合并

高斯消元类型的线性基合并就是暴力重构两个基，复杂度 $O(m^3)$，如果是异或线性基的话可以压位，复杂度 $O(\log^2 V)$。

贪心的异或线性基合并就是把一个线性基里的元素插入到另一个里面，复杂度 $O(\log^2 V)$。

void join(const lbase &p){
    for(int i=50;i>=0;i--)ins(p[i]);
    return;
}

线性基求交

这个应该是线性基板块最难的部分了。

可能只有异或线性基支持这个操作。

参考自：Charlie-Vinnie 的博客

设 $A,B$ 是两组线性基，其生成空间为 $V_A,V_B$，那么这两个线性空间的交满足 $V_C=V_A\cap V_B$，那么则称 $C$ 是线性基 $A,B$ 的交。

根据异或线性基线性组合的性质，我们发现任意两个 $V_A\cap V_B$ 内的元素都满足其线性组合在 $V_A\cap V_B$ 空间内，所以 $V_C$ 是一个线性包。

设我们存在一个线性基 $W$，满足以下条件：

接下来我们证明 $W$ 就是线性基 $A$ 和 $B$ 的交。

不难发现我们可以证明 $V_W=V_A\cap V_B$。

假设存在 $u\in V_W,u\not\in V_A\cap V_B$，根据定义，$V_W$ 的基既在 $B$ 中又在 $V_A$ 中，那么其组合起来的空间 $V_W$ 一定同时属于 $V_A$ 和 $V_B$。矛盾。

假设存在 $u\not\in V_W,u\in V_A\cap V_B$，由于 $u\in V_B$，那么一定有 $b_i$ 的一个线性组合是 $u$，把这些 $b_i$ 分成两组，一组 $\in W$，另一组 $\in B-W$，而 $u\in V_A$，所以若 $B-W$ 的一组存在，那么可以得到 $V_{B-W}$ 中的一个元素异或上一个 $V_A$ 的线性组合的结果在 $V_A$ 中，因此推出 $V_{B-W}\cap V_A$ 是非零线性包，矛盾。

那么如何求 $W$ 呢？

考虑如果 $b_i\in\lang\{a_{1},a_2,\cdots,a_k,b_1,b_2,\cdots,b_{i-1}\}\rang$，那么 $b_i$ 一定有用。但是我们需要只留下属于 $V_A$ 的贡献，所以设 $b_i= \alpha\oplus \beta$，而 $\alpha \in V_A$，$\beta\in \lang b_1,b_2,\cdots,b_{i-1}\rang$。所以我们每次把 $b_i\oplus \beta$（即 $\alpha$）加入到 $W$ 中。

如果不属于，那么一定在遍历基中，出现未插入过的位数，那么就把那个当前数插入到这个位数之中。这里还是像插入那样每次拿基内元素去消首位。

现在我们最麻烦的地方就是考虑如何维护 $\beta$。考虑把维护 $\beta$ 转化成维护 $\alpha$。模拟插入的过程可以发现我们每次尝试异或一个数时都会有一部分可能异或到插入的 $b_i$，这个时候我们就需要更新这个位置的贡献。显然，这个位置存了 $b_i$ 和之前前面它异或过的东西的异或和，那么这个位置的贡献就是它前面异或过的东西的异或和。贡献的初值就是之前 $A$ 的线性基每一位上的值。

模板：UOJ698 [候选队互测2022] 枪打出头鸟