数学 _ 高斯消元 and 线性基
高斯消元
时间复杂度：\(O(n3)\)
定义：
通过初等行变换 把 增广矩阵 化为 阶梯型矩阵 并回代 得到方程的解
作用：
适用于求解 包含n 个方程，n 个未知数的多元线性方程组
过程
例如该方程组
\[\left\{\begin{matrix}
a_{11}*x_{1}+a_{12}*x_{2}+……+a_{1n}*x_{n}=b_{1}
& & & & \\
a_{21}*x_{1}+a_{22}*x_{2}+……+a_{2n}*x_{n}=b_{2}
& & & & \\
……
& & & & \\
a_{n1}*x_{1}+a_{n2}*x_{2}+……+a_{nn}*x_{n}=b_{n}
& & & &
\end{matrix}\right.\]
增广矩阵为
\[\begin{pmatrix}a_{11} &a_{12} & \cdots &a_{1n} & b_1 \\ a_{21}&a_{22} & \cdots &a_{2n} & b_2 \\ \vdots & \vdots & \vdots & \vdots& \vdots \\ a_{n1} & a_{n2} & \cdots &a_{nn} & b_n \\ \end{pmatrix} \]
接下来的所有操作都用该增广矩阵，代替原方程组
高斯消元
前置知识：初等行（列）变换
- 把某一行乘一个非0的数
(方程的两边同时乘上一个非0数不改变方程的解)- 交换某两行
(交换两个方程的位置)- 把某行的若干倍加到另一行上去
（把一个方程的若干倍加到另一个方程上去）
其实可以看到，初等行变换就是我们手解方程组的几个操作，只不过将他变成了矩阵的形式。
算法步骤
- 枚举每一列c，
-
- 找到当前列绝对值最大的一行
找最大的一行精度会更准
- 找到当前列绝对值最大的一行
-
- 用初等行变换(2) 把这一行换到最上面（未确定阶梯型的行，并不是第一行）
-
-用初等行变换(1) 将该行的第一个数变成 11 （其余所有的数字依次跟着变化）
-
- 用初等行变换(3) 将下面所有行的当且列的值变成 0
运用初等行变换，可以把增广矩阵变为阶梯型矩阵：
\[\begin{pmatrix}a_{11} &a_{12} & \cdots &a_{1n} & b_1 \\ &a_{21}&a_{2(i+1)}&a_{2n} & b_2 \\ &&&\vdots& \vdots \\ &&&a_{nn} & b_n \\\ \end{pmatrix}
\]
解的判断
如果发现：
-
存在矛盾方程：消元后系数全为0，常数项不为0，此时无解
-
多解：当消元完毕后，发现有多行系数、常数项均为 0，此时多解。
有几行为全为 0，就有几个自由元，即变量的值可以任取，有无数种情况可以满足给出的方程组 -
如果是一个标准的上三角矩阵，就是只有唯一解。
很明显，我们只要从阶梯型矩阵的下到上回代:
对于每一行减去下面行乘上某个数，就可以得到一个\(x_i\)的解
直到第一层即可得到方程的解。
算法步骤
就是模拟高斯消元的过程
解释代码：
const int N = 110;
const double eps = 1e-6;
int n;
double a[N][N];
int gauss()
{
int c, r;// c 代表 列 col ， r 代表 行 row
for (c = 0, r = 0; c < n; c ++ )
{
int t = r;// 先找到当前这一列，绝对值最大的一个数字所在的行号
for (int i = r; i < n; i ++ )
if (fabs(a[i][c]) > fabs(a[t][c]))
t = i;
if (fabs(a[t][c]) < eps) continue;// 如果当前这一列的最大数都是 0 ，那么所有数都是 0，就没必要去算了，因为它的约束方程，可能在上面几行
for (int i = c; i < n + 1; i ++ ) swap(a[t][i], a[r][i]);//// 把当前这一行，换到最上面（不是第一行，是第 r 行）去
for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];// 把当前这一行的第一个数，变成 1， 方程两边同时除以 第一个数，必须要到着算，不然第一个数直接变1，系数就被篡改，后面的数字没法算
for (int i = r + 1; i < n; i ++ )// 把当前列下面的所有数，全部消成 0
if (fabs(a[i][c]) > eps)// 如果非0 再操作，已经是 0就没必要操作了
for (int j = n; j >= c; j -- )// 从后往前，当前行的每个数字，都减去对应列 * 行首非0的数字，这样就能保证第一个数字是 a[i][0] -= 1*a[i][0];
a[i][j] -= a[r][j] * a[i][c];
r ++ ;// 这一行的工作做完，换下一行
}
if (r < n)// 说明剩下方程的个数是小于 n 的，说明不是唯一解，判断是无解还是无穷多解
{// 因为已经是阶梯型，所以 r ~ n-1 的值应该都为 0
for (int i = r; i < n; i ++ )//
if (fabs(a[i][n]) > eps)// a[i][n] 代表 b_i ,即 左边=0，右边=b_i,0 != b_i, 所以无解。
return 2;
return 1;// 否则， 0 = 0，就是r ~ n-1的方程都是多余方程
}
// 唯一解 ↓，从下往上回代，得到方程的解
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];//因为只要得到解，所以只用对 b_i 进行操作，中间的值，可以不用操作，因为不用输出
return 0;
}
模板代码
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 110;
const double eps = 1e-8;
int n;
double a[N][N];
int gauss()
{
int c, r; // c:列 r:行
for (r = 0, c = 0; c < n; c++)
{
int k = r;
for (int i = r; i < n; i++)
{
if (abs(a[i][c]) > abs(a[k][c]))
k = i;
}
if (abs(a[k][c]) < eps)
continue;
for (int i = c; i <= n; i++)
swap(a[k][i], a[r][i]);
for (int i = n; i >= c; i--)
a[r][i] /= a[r][c];
for (int i = r + 1; i < n; i++)
{
if (abs(a[i][c]) > eps)
{
for (int j = n; j >= c; j--)
{
a[i][j] -= a[r][j] * a[i][c];
}
}
}
r++;
}
if (r < n)
{
for (int i = r; i < n; i++)
if (abs(a[i][n]) > eps)
return 2; // 无解
return 1; // 有无穷多组解
}
for (int i = n - 1; i >= 0; i--)
for (int j = i + 1; j < n; j++)
a[i][n] -= a[i][j] * a[j][n];
return 0; // 有唯一解
}
void solve()
{
cin >> n;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n + 1; j++)
{
scanf("%lf", &a[i][j]);
}
}
int flag = gauss();
if (flag == 2)
puts("No solution");
else if (flag == 1)
puts("Infinite group solutions");
else
{
for (int i = 0; i < n; i++)
{
if (abs(a[i][n]) < eps)
a[i][n] = 0;
printf("%.2lf\n", a[i][n]);
}
}
}
int main()
{
int t = 1;
// scanf("%d", &t);
while (t--)
{
solve();
}
return 0;
}
高斯消元解 异或线性方程组
异或线性方程组示例如下：
M[1][1]x[1] ^ M[1][2]x[2] ^ … ^ M[1][n]x[n] = B[1]
M[2][1]x[1] ^ M[2][2]x[2] ^ … ^ M[2][n]x[n] = B[2]
…
M[n][1]x[1] ^ M[n][2]x[2] ^ … ^ M[n][n]x[n] = B[n]
其中 ^ 表示异或(XOR)，M[i][j] 表示第 i 个式子中 x[j] 的系数，B[i] 是第 i 个方程右端的常数，取值均为 0 或 1。
核心思想: 异或<=>不进位的加法
因此可以使用高斯消元。
因为取值只有0和1，所以异或方程组可以少写一些步骤
代码
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 110;
int n;
int a[N][N];
int gauss()
{
int c, r; // c:列 r:行
for (r = 0, c = 0; c < n; c++)
{
int k = r;
for (int i = r; i < n; i++)
{
if (a[i][c])
{
k = i;
break;
}
}
if (!a[k][c])
continue;
for (int i = c; i <= n; i++)
swap(a[r][i], a[k][i]);
for (int i = r + 1; i < n; i++)
{
if (a[i][c])
for (int j = c; j <= n; j++)
a[i][j] ^= a[r][j];
}
r++;
}
if (r < n)
{
for (int i = r; i < n; i++)
if (a[i][n])
return 2; // 无解
return 1; // 有无穷多组解
}
for (int i = n - 1; i >= 0; i--)
for (int j = i + 1; j < n; j++)
a[i][n] ^= a[i][j] * a[j][n];
return 0; // 有唯一解
}
void solve()
{
cin >> n;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n + 1; j++)
{
scanf("%d", &a[i][j]);
}
}
int flag = gauss();
if (flag == 2)
puts("No solution");
else if (flag == 1)
puts("Multiple sets of solutions");
else
{
for (int i = 0; i < n; i++)
printf("%d\n", a[i][n]);
}
}
int main()
{
int t = 1;
// scanf("%d", &t);
while (t--)
{
solve();
}
return 0;
}
线性基
基本概念
线性空间：
线性空间是一个向量集合，并且关于一下两个运算封闭：
- 向量加法：\(a+b\) a，b均是向量
- 标量乘法：\(k×a\) k是常数，a是向量
如果一个向量可以被若干个向量通过向量乘法以及向量加法表示，那么就称这个向量可以被这几个向量线性表出。
给若干个向量\(a_1,a_2.....a_k\)。显然\(a_1,a_2.....a_k\)所能表出的所有向量所构成的集合构成一个线性空间，\(a_1,a_2.....a_k\)被称作生成子集。
线性相关&线性无关
任意在向量空间中选出若干个向量，如果某个向量可以被其他向量所表示，那么这些向量线性相关。否则线性无关。
线性空间的基底（基）
线性无关的生成子集被称作基，其实也就是极大线性无关子集。
线性空间的维数：
一个线性空间的所有基包含的向量个数相等，成为维数。
有几个很显然有几个性质：
- 线性基可以推出线性空间
- 线性基可以代替线性空间
也就是说：如果我们能够找到线性空间的基，就能用基代替线性空间做操作。
线性几个不显然的性质：
-
数列的任意数字都能通过线性基中的一些数字异或出来。
-
线性基只能异或出数列中的数或数列中的数能异或出来的东西。
求线性基
因为初等行变换只进行 向量加法和标量乘法 因此可以通过高斯消元求线性基。
应用
没用我学这东西干嘛
快速查询一堆数可以异或出来的最大/最小值
好文章：https://www.acwing.com/solution/content/35986/
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 100010;
int n;
LL a[N];
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i ++ ) scanf("%lld", &a[i]);
int k = 0;
for (int i = 62; i >= 0; i -- )
{
for (int j = k; j < n; j ++ )
if (a[j] >> i & 1)
{
swap(a[j], a[k]);
break;
}
if (!(a[k] >> i & 1)) continue;
for (int j = 0; j < n; j ++ )
if (j != k && (a[j] >> i & 1))
a[j] ^= a[k];
k ++ ;
if (k == n) break;
}
LL res = 0;
for (int i = 0; i < k; i ++ ) res ^= a[i];
printf("%lld\n", res);
return 0;
}
快速查询一堆数可以异或出来的第k大值
题意：
给定你由 N 个整数构成的整数序列，你可以从中选取一些（至少一个）进行异或（xor）运算，从而得到很多不同的结果。
请问，所有能得到的不同的结果中第 k 小的结果是多少。
思路：
高斯消元找到一组线性无关组,消出对角矩阵。
如果线性基线性无关，则可以组成0
则对于k二进制拆分,哪位线性基是1，直接异或起来求和就是答案。
如果线性基线性相关，
则对于k-1二进制拆分,哪位线性基是1，直接异或起来求和就是答案。
代码：
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 10010;
LL a[N];
int main()
{
int T;
scanf("%d", &T);
for (int C = 1; C <= T; C ++ )
{
printf("Case #%d:\n", C);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i ++ ) scanf("%lld", &a[i]);
int k = 0;
for (int i = 62; i >= 0; i -- )
{
for (int j = k; j < n; j ++ )
if (a[j] >> i & 1)
{
swap(a[j], a[k]);
break;
}
if (!(a[k] >> i & 1)) continue;
for (int j = 0; j < n; j ++ )
if (j != k && (a[j] >> i & 1))
a[j] ^= a[k];
k ++ ;
if (k == n) break;
}
reverse(a, a + k);
int m;
scanf("%d", &m);
while (m -- )
{
LL x;
scanf("%lld", &x);
if (k < n) x -- ;
if (x >= (1ll << k)) puts("-1");
else
{
LL res = 0;
for (int i = 0; i < k; i ++ )
if (x >> i & 1)
res ^= a[i];
printf("%lld\n", res);
}
}
}
return 0;
}
