首页 > 其他分享> > 【笔记】线性代数

【笔记】线性代数

2022-08-27 13:02:19 作者：互联网

矩阵乘法

首先给出矩阵乘法的代数意义：

结合一个具体的例子来理解：

设答案矩阵为 $ans$ 。根据公式：

$ans_{1,1}$ 是由 $a$ 矩阵的第一行与 $b$ 矩阵的第一列逐位相乘并求和得到的。

$ans_{1,2}$ 是由 $a$ 矩阵的第一行与 $b$ 矩阵的第二列逐位相乘并求和得到的。

$ans_{2,1}$ 是由 $a$ 矩阵的第二行与 $b$ 矩阵的第一列逐位相乘并求和得到的。

$ans_{2,2}$ 是由 $a$ 矩阵的第二行与 $b$ 矩阵的第二列逐位相乘并求和得到的。

由此，可以简单理解，矩阵乘法得出的结果，$ans_{i,j}$ 是由 $a$ 矩阵的第 $i$ 行与 $b$ 矩阵的第 $j$ 列逐位相乘并求和得到的。同时，也可以得知，一般情况下，要做矩阵乘法，$a$ 矩阵的列数应该和 $b$ 矩阵的行数相同。

根据这一结论，我们就可以写出矩阵乘法的代码：

struct node{
	ll p[105][105];
};
node X(node a,node b){
	node t;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			t.p[i][j]=0;
			for(int k=1;k<=n;k++){
				t.p[i][j]+=a.p[i][k]*b.p[k][j];
				t.p[i][j]%=mod;
			}
		}
	}
	return t;
}

矩阵快速幂

了解了矩阵乘法，就可以做矩阵快速幂了。

对于矩阵 $A$ ，$A^k$ 就表示 $k$ 个 $A$ 矩阵相乘。

先回顾一下快速幂。快速幂的做法是将指数每次折半。这样可以把效率提到 $log n$。

例如求 $a^{2n+1}$ 时，就可以转成 $a^{n}\times a^{n}\times a$。求$a^{2n}$ 时，就可以转成 $a^{n}\times a^{n}$。

根据这个思路，就有了快速幂板子：

P1226 【模板】快速幂||取余运算

ll fpow(ll a,ll p){
	ll ans=1;
	while(p){
		if(p&1) ans=ans*a%mod;
		a=a*a%mod;
		p>>=1;
	}	
	return ans;
}

~~至于光速幂，咱也不懂qwq~~
光速幂

回归正题，那么矩阵快速幂也同理。只要把普通快速幂中的乘法换成矩阵乘法就可以了。写成代码就是这样：

node fpow(node a,ll k){
	node ans=a,b=a;
	while(k){
		if(k&1) ans=X(b,ans);
		b=X(b,b);
		k>>=1;
	}	
	return ans;
}

需要注意的是，$k$ 的值在传入时，需要 $-1$ ，因为矩阵的一次幂就是本身，相当于已经乘过一次了。

结合矩阵乘法，我们就可以得到矩阵快速幂的完整板子：

P1962 斐波那契数列

十分巧妙地用了矩阵快速幂加速递推过程。具体可以看题解，这里不多赘述。

#include<bits/stdc++.h>
#define ll long long
#define mod 1000000007
using namespace std;
ll n;
struct node{
	ll p[15][15];
}a,ans;
node X(node a,node b){
	node t;
	for(int i=1;i<=2;i++){
		for(int j=1;j<=2;j++){
			t.p[i][j]=0;
			for(int k=1;k<=2;k++){
				t.p[i][j]+=a.p[i][k]*b.p[k][j];
				t.p[i][j]%=mod;
			}
		}
	}
	return t;
}
void fpow(ll k){
	while(k){
		if(k&1) ans=X(a,ans);
		a=X(a,a);
		k>>=1;
	}
}
int main(){
    scanf("%lld",&n);
    if(n<=2){
    	printf("1");
    	return 0;
	}
    a.p[1][1]=a.p[1][2]=a.p[2][1]=1;
    ans.p[1][1]=ans.p[1][2]=1;
    fpow(n-1);
    printf("%lld",ans.p[1][1]);
    return 0;
}

高斯消元

高斯消元法用于解线性方程组。

那么什么是线性方程组呢？

线性方程组就是有多个未知数，并且每个未知数的次数均为一次，这样多个未知数组成的方程组为线性方程组。或者我们也可以叫它多元一次方程组。

比如以下这个方程组：

数学老师教我们，多元一次方程组可以用加减消元法和代入消元法求解。

高斯消元法其实就是这样求解的。先进行加减消元，我们可以先求得一个未知数的值，然后可以逐层往回代（代入消元法），依次可以得到第 $2$ 个、第 $3$ 个未知数的值，最终解出方程组中各个未知数的值，结束算法。

那如何具体实现？

首先，提出各项系数并转化成一个矩阵。比如上面的方程就可以转化为：

$\begin{bmatrix} 2&1&-1&|&8\\-3&-1&2&|&11\\-2&1&2&|&-1\end{bmatrix}$

然后考虑我们做数学时一般解方程思路。我们往往是将系数绝对值最大的方程转移到被减的这一行，方便计算，也可以减小误差。

所以接下来要做的是将 $x$ 项系数绝对值最大的放到第一行。变化之后矩阵变成这样：

$\begin{bmatrix} -3&-1&2&|&11\\2&1&-1&|&8\\-2&1&2&|&-1\end{bmatrix}$

这一步代码实现非常简单，若当前解的是第 $i$ 个未知数，只要找出 $\max ${ $fabs(A_{j,i})$ } 即可。其中 $fabs$ 就是对浮点数取绝对值。设 $j=r$ 时取到最大，就将第 $r$ 行与第 $i$ 行逐项互换就可以了。代码：

r=i;
for(int j=i+1;j<n;j++){
	if(fabs(a[j][i])>fabs(a[r][i])) r=j;
}
if(r!=i) for(int j=0;j<=n;j++) swap(a[i][j],a[r][j]);

之后，对于下面的每一行（记为 $L_{k}$），我们可以求出一个比值 $f=A_{k,i}/A_{i,i}$ 。我们要将 $L_k$ 的每一项 $A_{k,j}$ 都减去 $ A_{i,j}\times f $，达到加减消元的目的（可以手算理解）。比如上面这个经处理的矩阵，经过第一次加减消元后会变成：

$\begin{bmatrix} -3&-1&2&|&11\\0&\frac{1}{3}&\frac{1}{3}&|&\frac{2}{3}\\0&\frac{5}{3}&\frac{2}{3}&|&\frac{13}{3}\end{bmatrix}$

相当于：

$L_2$ 变成了 $L_2-L_1\times(-\frac{2}{3})$

$L_3$ 变成了 $L_3-L_1\times\frac{2}{3}$

重复上面的步骤：

交换第 $2,3$ 行（因为$\frac{5}{3}>\frac{1}{3}$），得到：

$\begin{bmatrix} -3&-1&2&|&11\\0&\frac{5}{3}&\frac{2}{3}&|&\frac{13}{3}\\0&\frac{1}{3}&\frac{1}{3}&|&\frac{2}{3}\end{bmatrix}$

第二次加减消元，得到：

$\begin{bmatrix} -3&-1&2&|&11\\0&\frac{5}{3}&\frac{2}{3}&|&\frac{13}{3}\\0&0&\frac{1}{5}&|&-\frac{1}{5}\end{bmatrix}$

相当于：

$L_3$ 变成了 $L_3-L_2\times\frac{1}{5}$

贴上加减消元这整一部分的代码：

for(int i=0;i<n;i++){
	r=i;
	for(int j=i+1;j<n;j++){
		if(fabs(a[j][i])>fabs(a[r][i])) r=j;
	}
	if(r!=i) for(int j=0;j<=n;j++) swap(a[i][j],a[r][j]);
	for(int k=i+1;k<n;k++){
		double f=a[k][i]/a[i][i];
		for(int j=i;j<=n;j++) a[k][j]-=f*a[i][j];
	}
}

下一步就是进行回带了。

先手算：当前矩阵的第三行重新转回数学式子就是 $\frac{1}{5}z=-\frac{1}{5}$，所以易得 $z=A_{2,3}/A_{2,2}=-1$。然后把 $z=-1$ 带入第二行，可以得到 $\frac{5}{3}y+\frac{2}{3}\times(-1)=\frac{13}{3}$ 这时我们只要把 $\frac{13}{3}$ 减掉 $\frac{2}{3}\times(-1)$，也就是移项，再除以 $\frac{5}{3}$ 就能得到 $y$。以此类推。

所以我们就得到方法：先将等式右边减掉所有等式左边的已知项，再除以未知项系数就好了。具体可以根据代码理解：

for(int i=n-1;i>=0;i--){
	for(int j=i+1;j<=n;j++) a[i][n]-=a[j][n]*a[i][j];
	a[i][n]/=a[i][i];
}

最后，我们需要判断无解或不唯一解的情况。

仍然从数学上理解，我们知道，对于一次方程，当方程的所有未知数系数都为 $0$，但常数项不为 $0$ 时，方程无解。例如 $0x+0y+0z=114$ ，显然无解。

同样，对于一次方程，当方程的所有未知数系数都为 $0$，而常数项也为 $0$ 时，方程有无数解。例如 $0x+0y+0z=0$ 。

所以，转化到矩阵中，当存在一行 $L_x$ ，其 $A_{x,0}$ 到 $A_{x,n-1}$ 都为 $0$ 但 $A_{x,n} \ne 0$ 时，方程组无解。同样，当存在一行 $L_x$ ，其 $A_{x,0}$ 到 $A_{x,n-1}$ 都为 $0$ 且 $A_{x,n} = 0$ 时，方程组有无数解。（洛谷 P3389 只问是否有唯一解，所以两种情况可以合并讨论）。

下面是完整代码：

P3389 【模板】高斯消元法

#include<bits/stdc++.h>
using namespace std;
int n,r,fl;
double a[105][105];
void gauss(){
	for(int i=0;i<n;i++){
		r=i;
		for(int j=i+1;j<n;j++){
			if(fabs(a[j][i])>fabs(a[r][i])) r=j;
		}
		if(r!=i) for(int j=0;j<=n;j++) swap(a[i][j],a[r][j]);
		for(int k=i+1;k<n;k++){
			double f=a[k][i]/a[i][i];
			for(int j=i;j<=n;j++) a[k][j]-=f*a[i][j];
		}
	}
	for(int i=0;i<n;i++){
		int kk=0;
		for(int j=0;j<n;j++) if(a[i][j]!=0) kk=1;
		if(!kk){
			fl=1;
			return ;
		}
	}
	for(int i=n-1;i>=0;i--){
		for(int j=i+1;j<=n;j++) a[i][n]-=a[j][n]*a[i][j];
		a[i][n]/=a[i][i];
	}
}
int main() {
    scanf("%d",&n);
    for(int i=0;i<n;i++){
    	for(int j=0;j<=n;j++) scanf("%lf",&a[i][j]);
	}
	gauss();
	if(fl){
		printf("No Solution");
		return 0;
	}
	for(int i=0;i<n;i++) printf("%.2lf\n",a[i][n]);
    return 0;
}

线性基

对于一组数 $A_1$ ~ $A_n$ ，它们的线性基为 $P_1$ ~ $P_n$。其中 $P_i$ 表示二进制下出现 $1$ 的最高位在第 $i$ 位的数。

所以，线性基可以方便地求最大异或和。

先看线性基的构造方法。

比如说给定这样一组数构造线性基：$5,11,17,24$。

首先将每一个数转化为二进制：

$5->101$

$11->1011$

$17->10001$

$24->11000$

然后我们从依次最高位开始找。

如果最高位的 $1$ 在第 $i$ 位，并且当前的 $P_i=0$ 我们就把 $P_i$ 赋值为这个数。例如处理 $5$，就把 $P_2$ 赋值为 $5$。

如果当前的 $P_i \ne 0$ ，那就让当前的数 $\oplus=P_i$ ，也就是把所有与 $P_i$ 重复的 $1$ 抹掉并继续往后搜。
例如处理 $24$ ，此时 $P_4$ 已经是 $17$ 了，就把 $24 \oplus=17$ 得到 $9(1001)$。
又发现此时 $P_3$ 已经是 $11$ 了，就把 $9 \oplus=11$ 得到 $2(10)$ 。
此时 $P_1=0$，就把 $P_1$ 赋值为 $2$。

按照手算的过程，我们可以写出代码：

void make(ll a){
	for(int i=52;i>=0;i--){
		if(a>>(ll)i){
			if(!p[i]){
				p[i]=a;
				break;
			}
			else a^=p[i];
		}
	}
	return ;
}

再来看如何寻找答案：

简单手算一下，可以发现，求最大异或和是满足贪心的，且对顺序没有要求。

这里可以简单证明：因为异或是不进位运算，所以高位不受低位影响。举几个例子：

$10001 \oplus 1000 = 11001$ ，显然更优。
$10111 \oplus 1111 = 11000$ ，虽然低位变小，但高位更大了，所以结果还是更优。
$11000 \oplus 1111 = 10111$ ，虽然低位变大，但高位更小了，所以结果更劣。

所以，得出：只要将 $ans$ 对所有 $P_i$ 从高位到低位异或一遍，就可以得到最优答案。