【高斯消元】

高斯消元模板：

终于找到一个正常的，包含无解自由元的博客：https://blog.csdn.net/gddswlz/article/details/9148547

https://www.cnblogs.com/iwtwiioi/p/4031709.html

//
//#include<stdio.h>
//#include<algorithm>
//#include<iostream>
//#include<string.h>
//#include<math.h>
//using namespace std;
//
//const int MAXN=50;
//
//
//
//int a[MAXN][MAXN];//增广矩阵
//int x[MAXN];//解集
//bool free_x[MAXN];//标记是否是不确定的变元
//
//
//
///*
//void Debug(void)
//{
// int i, j;
// for (i = 0; i < equ; i++)
// {
// for (j = 0; j < var + 1; j++)
// {
// cout << a[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
//}
//*/
//
//
//inline int gcd(int a,int b)
//{
// int t;
// while(b!=0)
// {
// t=b;
// b=a%b;
// a=t;
// }
// return a;
//}
//inline int lcm(int a,int b)
//{
// return a/gcd(a,b)*b;//先除后乘防溢出
//}
//
//// 高斯消元法解方程组(Gauss-Jordan elimination).(-2表示有浮点数解，但无整数解，
////-1表示无解，0表示唯一解，大于0表示无穷解，并返回自由变元的个数)
////有equ个方程，var个变元。增广矩阵行数为equ,分别为0到equ-1,列数为var+1,分别为0到var.
//int Gauss(int equ,int var)
//{
// int i,j,k;
// int max_r;// 当前这列绝对值最大的行.
// int col;//当前处理的列
// int ta,tb;
// int LCM;
// int temp;
// int free_x_num;
// int free_index;
//
// for(int i=0;i<=var;i++)
// {
// x[i]=0;
// free_x[i]=true;
// }
//
// //转换为阶梯阵.
// col=0; // 当前处理的列
// for(k = 0;k < equ && col < var;k++,col++)
// {// 枚举当前处理的行.
//// 找到该col列元素绝对值最大的那行与第k行交换.(为了在除法时减小误差)
// max_r=k;
// for(i=k+1;i<equ;i++)
// {
// if(abs(a[i][col])>abs(a[max_r][col])) max_r=i;
// }
// if(max_r!=k)
// {// 与第k行交换.
// for(j=k;j<var+1;j++) swap(a[k][j],a[max_r][j]);
// }
// if(a[k][col]==0)
// {// 说明该col列第k行以下全是0了，则处理当前行的下一列.
// k--;
// continue;
// }
// for(i=k+1;i<equ;i++)
// {// 枚举要删去的行.
// if(a[i][col]!=0)
// {
// LCM = lcm(abs(a[i][col]),abs(a[k][col]));
// ta = LCM/abs(a[i][col]);
// tb = LCM/abs(a[k][col]);
// if(a[i][col]*a[k][col]<0)tb=-tb;//异号的情况是相加
// for(j=col;j<var+1;j++)
// {
// a[i][j] = a[i][j]*ta-a[k][j]*tb;
// }
// }
// }
// }
//
// // Debug();
//
// // 1. 无解的情况: 化简的增广阵中存在(0, 0, ..., a)这样的行(a != 0).
// for (i = k; i < equ; i++)
// { // 对于无穷解来说，如果要判断哪些是自由变元，那么初等行变换中的交换就会影响，则要记录交换.
// if (a[i][col] != 0) return -1;
// }
// // 2. 无穷解的情况: 在var * (var + 1)的增广阵中出现(0, 0, ..., 0)这样的行，即说明没有形成严格的上三角阵.
// // 且出现的行数即为自由变元的个数.
// if (k < var)
// {
// // 首先，自由变元有var - k个，即不确定的变元至少有var - k个.
// for (i = k - 1; i >= 0; i--)
// {
// // 第i行一定不会是(0, 0, ..., 0)的情况，因为这样的行是在第k行到第equ行.
// // 同样，第i行一定不会是(0, 0, ..., a), a != 0的情况，这样的无解的.
// free_x_num = 0; // 用于判断该行中的不确定的变元的个数，如果超过1个，则无法求解，它们仍然为不确定的变元.
// for (j = 0; j < var; j++)
// {
// if (a[i][j] != 0 && free_x[j]) free_x_num++, free_index = j;
// }
// if (free_x_num > 1) continue; // 无法求解出确定的变元.
// // 说明就只有一个不确定的变元free_index，那么可以求解出该变元，且该变元是确定的.
// temp = a[i][var];
// for (j = 0; j < var; j++)
// {
// if (a[i][j] != 0 && j != free_index) temp -= a[i][j] * x[j];
// }
// x[free_index] = temp / a[i][free_index]; // 求出该变元.
// free_x[free_index] = 0; // 该变元是确定的.
// }
// return var - k; // 自由变元有var - k个.
// }
// // 3. 唯一解的情况: 在var * (var + 1)的增广阵中形成严格的上三角阵.
// // 计算出Xn-1, Xn-2 ... X0.
// for (i = var - 1; i >= 0; i--)
// {
// temp = a[i][var];
// for (j = i + 1; j < var; j++)
// {
// if (a[i][j] != 0) temp -= a[i][j] * x[j];
// }
// if (temp % a[i][i] != 0) return -2; // 说明有浮点数解，但无整数解.
// x[i] = temp / a[i][i];
// }
// return 0;
//}
//int main(void)
//{
//// freopen("in.txt", "r", stdin);
//// freopen("out.txt","w",stdout);
// int i, j;
// int equ,var;
// while (scanf("%d %d", &equ, &var) != EOF)
// {
// memset(a, 0, sizeof(a));
// for (i = 0; i < equ; i++)
// {
// for (j = 0; j < var + 1; j++)
// {
// scanf("%d", &a[i][j]);
// }
// }
//// Debug();
// int free_num = Gauss(equ,var);
// if (free_num == -1) printf("无解!\n");
// else if (free_num == -2) printf("有浮点数解，无整数解!\n");
// else if (free_num > 0)
// {
// printf("无穷多解! 自由变元个数为%d\n", free_num)

// for (i = 0; i < var; i++)
// {
// if (free_x[i]) printf("x%d 是不确定的\n", i + 1);
// else printf("x%d: %d\n", i + 1, x[i]);
// }
// }
// else
// {
// for (i = 0; i < var; i++)
// {
// printf("x%d: %d\n", i + 1, x[i]);
// }
// }
// printf("\n");
// }

///此处是=更新以下

有道题是对自由元无所谓的，也就是多个解

所以我们可以

对这些自由元系数赋值1，求出值

// int free = Gauss(n*m,n*m); //有多解时
// if(free>0){
// for(int i = 0;i < free;i++){
// for(int j = 0;j < n*m;j++){
// if(j == n*m-free+i) a[n*m-free+i][j] = 1;
//
// }
// }
// int aa = Gauss(n*m,n*m);
// }

// return 0;
//}

#include<bits/stdc++.h>
#define N 105
using namespace std;
double a[N][N]; int n;
bool gauss(){
for(int i=1;i<=n;i++){
int k=i;
for(int j=i+1;j<=n;j++)
if(fabs(a[j][i])>fabs(a[k][i])) k=j;
if(fabs(a[k][i])<1e-8) return 0;//最大的都小于10^-8
for(int j=i;j<=n+1;j++) swap(a[i][j],a[k][j]);
double res=a[i][i];
for(int j=i;j<=n+1;j++) a[i][j]/=res;
for(int k=1;k<=n;k++)
if(k!=i){
double res=a[k][i];
for(int j=i;j<=n+1;j++) a[k][j]-=res*a[i][j];
}
}
return 1;
}
int main(){
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++)
printf("%0.2lf\n",a[i][n+1]);
else cout<<"No Solution";
return 0;

}

无特殊：

接下来的两个代码中，matrix数组表示等号左边的值，ans数组表示等号右边的值，最终的解是ans数组
/*
无特殊情况高斯消元 并且答案乱记
高斯消元从来没有好好写过
今天来尝试一下
Debug:No
*/

typedef double matrix[50][50];

void reduce(matrix a,double ans[],int n)
{
int t;double p;
for(int i=0;i<n;i++)
{
t=i;
for(int j=i;j<n;j++)
if(fabs(a[j][i])>fabs(a[t][i]))t=j;
for(int j=i;j<n;j++)
{
p=a[i][j];a[i][j]=a[t][j];a[t][j]=p;
}
p=ans[i];ans[i]=ans[t];ans[t]=p;
for(int j=i+1;j<n;j++)
{
p=a[j][i]/a[i][i];
for(int k=i;k<n;k++)a[j][k]-=p*a[i][k];
ans[j]-=p*ans[i];
}
}
for(int i=n-1;i>=0;i--)
for(int j=n;j>i;j--)ans[i]-=ans[j]*a[i][j];
}

EXTENDED LIGHTS OUT

题意：给出一个全是01构成的，翻一个点会影响上下左右，问你怎么操作后可以得到全为0

状压dp可以做

不够我们这次用高斯校园

我们可以

M[0][0]x[0]^M[0][1]x[1]^…^M[0][N-1]x[N-1]=B[0]//B[0]是目前第一个鸽子的状态
M[1][0]x[0]^M[1][1]x[1]^…^M[1][N-1]x[N-1]=B[1]

另外说下，为什么我们将右端赋值每个点得原本状态，然后就可以求出全为0得按法呢。

有博客解释：但是不懂。

首先我们知道将右端每个解代入A矩阵每个格子状态，那么解出来就是在全为0得状态下，解出来得就是，

每个格子应该进行得改动才能变成A

你可以理解为一个原本状态+操作后=0等价于上面那样

因为我们知道一个状态和他被操做次数奇偶有关，所以直接异或，我们直接改动高斯消元模板的加号为^就行。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int a[35][35];
void gauss()
{
 int i, j, k;
 for(k=1; k<=30; k++)
   {
     if(a[k][k] == 0)
      {
        for(i=k+1; i<=30; i++)
         if(a[i][k])
          break;
        for(j=k; j<=31; j++)
         swap(a[i][j], a[k][j]);
      }
    for(i=1; i<=30; i++)
      if(a[i][k] && i!=k)
        for(j=k; j<=31; j++)
          a[i][j] ^= a[k][j];
   }
}
int main()
{
  int t, ca = 1;
  scanf("%d", &t);
  while(t--)
   {
     memset(a, 0, sizeof(a));
     for(int i=1; i<=30; i++)   // 之前一直把这个for循环放在while外面
      {                         // 结果上一次的结果影响了下一次
        a[i][i] = 1;
        if(i%6 != 0)
          a[i][i+1] = 1;
         if(i%6 != 1)
          a[i][i-1] = 1;
         if(i>6)
          a[i][i-6] = 1;
         if(i<25)
         a[i][i+6] = 1;
       }
     for(int i=1; i<=30; i++)
       scanf("%d", &a[i][31]);
     gauss();
     printf("PUZZLE #%d\n", ca++);
     for(int i=1; i<=30; i++)
      {
        printf("%d", a[i][31]);
        if(i%6 == 0)
          printf("\n");
        else
          printf(" ");
      }
   }
  return 0;
}
p2962 灯light

题意：每个灯都有自己连接的其他的点，如果此点改变和他连接的点也会改变，1变0，0变1
现在全由都是0，试问最少操作几次将所有灯变为1，
这个其实和上面差不多，只不过可能出现自由元，也就是他什么值都可以，在本题也就是他0 1都可以、
所以我们不能单单高斯消元，对于这种自由元我们要进行dfs枚举，看他0还是1，更优
#include<bits/stdc++.h>
using namespace std;
#define maxn 100
#define sc(x) scanf("%lld",&x);
#define int long long
int A[maxn][maxn];
int x[maxn];
int ans=1000;
int n,m;
void guass()
{
for(int i=1; i<=n; i++)
{
int t=i;
if(!A[t][t])
{
for(int j=i+1; j<=n; j++)
{
if(A[j][i])
{
t=j;
break;
}
}
swap(A[i],A[t]);
}
for(int k=1; k<=n; k++)
{
if(A[k][i]&&k!=i)
{
for(int j=i; j<=n+1; j++)
{
A[k][j]^=A[i][j];///消元
}
}
}
}
}

void dfs(int i,int t)
{
if(t>ans)return;
if(i==0){
ans=min(t,ans);
return;
}
if(A[i][i]){///这里表示系数不为0，那么就是非自由元
x[i]=A[i][n+1];
for(int j=i+1;j<=n;j++)
if(A[i][j]){x[i]^=x[j];}///这里一开始犯晕了。。。一直在想好端端的都求出了答案不就i自由元没有而已嘛为什么还有再异或。。。然后后知后觉，自由元我们是不确定的，我们自由元开灯，那肯定会影响其他灯，所以我们得继续这个操作
if(x[i])dfs(i-1,t+1);
else dfs(i-1,t);
}
else{
x[i]=0;
dfs(i-1,t);
x[i]=1;
dfs(i-1,t+1);
}
}
signed main()
{
sc(n);sc(m);
int x,y;
while(m--){
sc(x);sc(y);
A[x][y]=A[y][x]=1;
}
for(int i=1;i<=n;i++)A[i][i]=A[i][n+1]=1;
guass();
for(int i=1;i<=n;i++)
printf("%d ",A[i][n+1]);
// dfs(n,0);
cout<<ans<<'\n';
}

Painter's Problem

painter problem与开关问题
painter problem 题意是给我们棋盘状态w，y组成
将棋盘全改为y需要至少多少步
首先套用高斯+无解判断+自由元dfs寻找最少步数。
开关问题则是
通用以下模板

#include<iostream>
#include<vector>
using namespace std;
#define L 38
int a[L][L],s[L],t[L];
int gauss(int n)
{
int ans=0,i=0,j=0,k=0,r=0;
for(i=1,j=1;i<=n && j<=n;j++)
{
k=i; //当前消元到第i行
while(k<=n && !a[k][j]) k++; //直到找到第j列的第一个是1的元素所在的行k
if(a[k][j]) //此处包含k>n的情况
{
for(r=1;r<=n+1;r++) //将第k行换到当前消元的行i
swap(a[i][r],a[k][r]);
for(r=1;r<=n;r++) //如果当前行的第j列为1，除了第i行外的其他n-1行进行消元
{
if(r!=i && a[r][j])
{
for(k=i;k<=n+1;k++)
a[r][k]=a[r][k]^a[i][k];
}
}
i++; //成功消元第i行，消元下面的行
}
}
for(j=i;j<=n;j++) //从第i行开始，如果有增广列不为0，则无解
{
if(a[j][n+1])
return -1;
}

return 1<<(n-i+1); //共有2^(n-i+1)种解
}

painter 代码：
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
#define L 1000
int a[L][L],s[L],t[L],ANS,xx[L],N;
int gauss(int n)
{
int ans=0,i=0,j=0,k=0,r=0;
for(i=1,j=1;i<=n*n && j<=n*n;j++)
{
k=i; //当前消元到第i行
while(k<=n*n && !a[k][j]) k++; //直到找到第j列的第一个是1的元素所在的行k
if(a[k][j]) //此处包含k>n的情况
{
for(r=1;r<=n*n+1;r++) //将第k行换到当前消元的行i
swap(a[i][r],a[k][r]);
for(r=1;r<=n*n;r++) //如果当前行的第j列为1，除了第i行外的其他n-1行进行消元
{
if(r!=i && a[r][j])
{
for(k=i;k<=n*n+1;k++)
a[r][k]=a[r][k]^a[i][k];
}
}
i++; //成功消元第i行，消元下面的行
}
}
for(j=i;j<=n*n;j++) //从第i行开始，如果有增广列不为0，则无解
{
if(a[j][n*n+1])
return -1;
}

return 1; //共有2^(n-i+1)种解
}
void dfs(int x,int cnt){
if(cnt>=ANS) return ;//已经比目前的答案大了，没有必要再搜
if(x==0){
ANS=min(cnt,ANS);
return ;
}
if(a[x][x]!=0){
xx[x]=a[x][N*N+1];//num表示第x块砖染色不染色
for(int i=x+1;i<=N*N;i++){
if(a[x][i]!=0) xx[x]^=xx[i];//已经枚举过的x+1~N*N中某块砖如果可以对x产生影响且已染色，就让num改变一次
}

if(xx[x])
dfs(x-1,cnt+1);
else
dfs(x-1,cnt);
}
else{//枚举按或不按两种情况
xx[x]=0; dfs(x-1,cnt);
xx[x]=1; dfs(x-1,cnt+1);
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--){

memset(a,0,sizeof(a));
scanf("%d",&N);
for(int i=1;i<=N*N;i++){
a[i][i]=1;
if(i%N!=1) a[i][i-1]=1;
if(i%N!=0) a[i][i+1]=1;
if(i>=N+1) a[i][i-N]=1;
if(i<=N*(N-1)) a[i][i+N]=1;
}
for(int i=1;i<=N;i++){
char s[300];
scanf("%s",s+1);
for(int j=1;j<=N;j++){
if(s[j]=='w') a[(i-1)*N+j][N*N+1]=1;
}
}
if(gauss(N)==-1){
puts("inf");
continue;
}
ANS=1<<28;
dfs(N*N,0);
printf("%d\n",ANS);
}
return 0;
}

开关问题：
#include<iostream>
#include<vector>
using namespace std;
#define L 38
int a[L][L],s[L],t[L];
int gauss(int n)
{
int ans=0,i=0,j=0,k=0,r=0;
for(i=1,j=1;i<=n && j<=n;j++)
{
k=i; //当前消元到第i行
while(k<=n && !a[k][j]) k++; //直到找到第j列的第一个是1的元素所在的行k
if(a[k][j]) //此处包含k>n的情况
{
for(r=1;r<=n+1;r++) //将第k行换到当前消元的行i
swap(a[i][r],a[k][r]);
for(r=1;r<=n;r++) //如果当前行的第j列为1，除了第i行外的其他n-1行进行消元
{
if(r!=i && a[r][j])
{
for(k=i;k<=n+1;k++)
a[r][k]=a[r][k]^a[i][k];
}
}
i++; //成功消元第i行，消元下面的行
}
}
for(j=i;j<=n;j++) //从第i行开始，如果有增广列不为0，则无解
{
if(a[j][n+1])
return -1;
}

return 1<<(n-i+1); //共有2^(n-i+1)种解
}
int main()
{
int k,n,i=0,j=0,x,y;
cin>>k;
while(k--)
{
memset(a,0,sizeof(a));
cin>>n;
for(i=1;i<=n;i++)
cin>>s[i];
for(i=1;i<=n;i++)
{
cin>>t[i];
a[i][i]=1;
a[i][n+1]=s[i]^t[i];
}
while(true)
{
cin>>x>>y;
if((x+y)==0) break;
a[y][x]=1; //注意此处一定是a[y][x]
}
int ans=gauss(n);
if(ans==-1)
cout<<"Oh,it's impossible~!!"<<endl;
else
cout<<ans<<endl;
}
return 1;
}