矩阵与高斯消元【矩阵乘法，高斯消元求线性方程组，求行列式】 全网最详，附例题与姊妹篇 一万三千字详解

已于 2022-07-16 23:11:30 修改
阅读量685 收藏 6
点赞数 2
分类专栏： 数论进阶 文章标签： 矩阵 线性代数
于 2022-07-16 23:09:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jisuanji2606414/article/details/125745369
版权

（详解）矩阵快速幂详解与常见转移矩阵的构造_秦小咩的博客-CSDN博客_矩阵快速幂转移矩阵

目录

矩阵乘法

矩阵快速幂 伪代码模板

例题一

例题2

例题三

例题四

高斯消元

整形高斯消元

浮点型高斯消元

例题

模数型高斯消元

 异或型高斯消元

例题

矩阵乘法

假设有n的地点，从地点i到地点j坐飞机有aij种选择，坐火车有bij种选择。求从地点i先坐飞机再转成火车到j的方案数

cij=\sum_{k=1}^{n} a _{ik} b_{kj}

矩阵乘法

假设 A=(aij),B=(bij)是两个n元矩阵，它们的乘积C=AB也是一个n元矩阵C=(cij),

满足cij=\sum_{k=1}^{n}a_{ik}b_{kj}

矩阵快速幂 伪代码模板

const int N=505;

void matpow()
{
    int ans[N][N];
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        ans[i][j]=(i==j);
    
    while(pow)
    {
        if(pow&1)
            matmul(ans,base,ans);
        matmul(base,base,base);
        
    }
    
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            a[i][j]=ans[i][j];
            
        }
            
    }
}

例题一

Magic Gems

\begin{pmatrix} f(n)\\ \\ \\ \\ \end{pmatrix}            \begin{pmatrix} 1 & 0 & 0 &... &1 \\ & & & & \\ & & & & \\ & & & & \\ & & & & \end{pmatrix} \begin{pmatrix} f(n-1)\\ f(n-2)\\ ...\\ f(n-m)\\ \end{pmatrix}

                        行                            列 

考虑继承

\begin{pmatrix} f(n)\\ f(n-1)\\ ...\\ f(n-m+1)\\ \end{pmatrix}=\begin{pmatrix} 1 & 0& 0&... &1 \\ 1& 0 &0 & ...&0 \\ 0& 1& 0 & ...&0 \\ 0& 0 & 0& ... & 0\\ 0& 0& 0& 1& 0 \end{pmatrix} =\begin{pmatrix} f(n-1)\\ f(n-2)\\ ..\\ f(n-m)\\ \end{pmatrix}

base矩阵是快速幂关键，继承也就有一定技巧性

设F[n]   = base* F[n-1]则

n-m=1时 n-1=m

F[n]=  base ^n-m * F(m)

其中F数组m行   base数组  m行*m列·

# include<cstdio>
# include<algorithm>
# include<iostream>
# include<map>
# include<cstring>
# include<set>
# include<algorithm>
# include<vector>
# include<queue>
# include<cstring>

using namespace  std;
# define mod  1000000007

typedef long long int ll;

ll f[110][110],base[110][110];
ll n,m;

void mul(ll a[110][110],ll b[110][110])
{
    ll c[110][110]= {0};

    for(int i=1; i<=m; i++)
    {
        for(int j=1; j<=m; j++)
        {
            for(int k=1; k<=m; k++)
            {
                c[i][j]=(c[i][j]+a[i][k]*b[k][j]%mod)%mod;
            }
        }
    }
    for(int i=1; i<=m; i++)
    {
        for(int j=1; j<=m; j++)
        {
            a[i][j]=c[i][j]%mod;

        }
    }
}
ll ans[110][110];

int main ()
{


   

    cin>>n>>m;

    base[1][1]=1;

    base[1][m]=1;

    for(int i=2; i<=m; i++)
    {
        base[i][i-1]=1;

    }

    f[1][1]=2;

    for(int i=2; i<=m; i++)
    {
        f[i][1]=1;

    }


    ll pow=n-m;
    
    if(pow<=0)
    {
        if(pow<0)
        cout<<1;
        else
            cout<<2;
        
        return  0;
    
    
    }

    for(int i=1; i<=m; i++)
    {
        ans[i][i]=1;
    }

    while(pow)
    {
        if(pow&1)
        mul(ans,base);

        pow>>=1;

        mul(base,base);

    }

    ll an=0;

    for(int i=1;i<=m;i++)
    {
        an=(an+ans[1][i]*f[i][1]%mod)%mod;

    }

    cout<<an;




    return 0;

}

例题2

方格填色

我们用1代表白色，0代表黑色。左右两格不能同时是白色  &运算之后，一定是0 ，两列不能全是黑也就是两列不能全是0

\begin{pmatrix} f(n,0)\\ f(n,1)\\ ...\\ f(n,st)\\ \end{pmatrix} = \bigl(\begin{smallmatrix} & & & & \\ & & & & \\ & & & & \\ & & & & \\ & & & & \end{smallmatrix}\bigr) *\begin{pmatrix} f(n-1,0)\\ f(n-1,1)\\ ....\\ f(n-1,st{}') \end{pmatrix}        其中base数组的转移规则为,i,j不能同时是0，且ij&运算之后不能是1

另外base数组的pow应该是n-1

# include<cstdio>
# include<algorithm>
# include<iostream>
# include<map>
# include<cstring>
# include<set>
# include<algorithm>
# include<vector>
# include<queue>
# include<cstring>

using namespace  std;
# define mod  1000000007

typedef long long int ll;

ll base[50][50],n,m;

ll f[50][50];
ll ans[50][50];

void cheng(ll a[50][50],ll b[50][50])
{
    ll temp[50][50]={0};

    for(int i=0;i<(1<<m);i++)
    {
        for(int j=0;j<(1<<m);j++)
        {
            for(int k=0;k<(1<<m);k++)
            {
                temp[i][j]=(temp[i][j]+a[i][k]*b[k][j]%mod)%mod;

            }
        }
    }

    for(int i=0;i<(1<<m);i++)
    {
        for(int j=0;j<(1<<m);j++)
        {
            a[i][j]=temp[i][j];

        }
    }
}
int main ()
{

    cin>>m>>n;

    for(int i=0;i<(1<<m);i++)
    {
        for(int j=0;j<(1<<m);j++)
        {
            if(i&j)
                continue;

            if(!i&&!j)
                continue;


            base[i][j]=1;

        }
    }

    ll pow=n-1;


    for(int i=0;i<(1<<m);i++)
    {
        ans[i][i]=1;


        f[i][1]=1;
    }


    while(pow)
    {
        if(pow&1)
        cheng(ans,base);


        pow>>=1;

        cheng(base,base);

    }


    ll an=0;


    for(int i=0;i<(1<<m);i++)
    {
        for(int j=0;j<(1<<m);j++)
        {
            an=(an+ans[i][j]*f[j][1]%mod)%mod;

        }
    }

    cout<<an;



    return 0;

}

例题三

Sasha and Array

首先，菲波那切数列的转移方程

\begin{pmatrix} f(n)\\ f(n-1)\end{pmatrix} = \begin{pmatrix} 1& 1\\ 1& 0 \end{pmatrix} * \begin{pmatrix} f(n-1)\\ f(n-2)\end{pmatrix}

在这里不得不提一个规律，那就是base数组的x次幂所得到的  base[1][1]正好是 f(x-1)

比如0次幂的单位矩阵   base[1][1]=1=f(1)

1次幂    base[1][1]=f(2)

2次幂  base[1][1]=f(3)

而本题的突破点就在这里。

每次进行的区间修改用线段树来实现，那么线段树的实际意义该如何定义？

首先看两项操作  对于[L,R]区间内的a[i]进行加 x,操作  

对于【L,R]区间内的斐波那契数列求和  

第一项操作对于第二项操作的影响在于   每次加x,相当于对f[i]对应的base矩阵进行了幂数+x,也就是乘上一个幂数为x的base矩阵

之后我们线段树的sum数组该如何定义？ 我们的lazy标记又该如何定义

首先我们是无法预处理出10^9那么大的斐波那契数列的，也就意味着我们sum数组不能是单纯的数字，应该是矩阵形式。

而sum数组就对应了 该区间base数组之和。 这样的合理性在于 [L,R]之间所有矩阵分别乘x个base矩阵,所得到的base[1][1]之和，与先把矩阵相加，再乘x个base矩阵所得结果相同

在返回答案时，只需要进行base[1][1]的求和即可

涉及重载运算符，代码细节多

# include<iostream>
# include<cstring>
# include<vector>
# include<math.h>

# include<algorithm>

using namespace std;

# define mod 1000000007
typedef long long int ll;

struct MAT
{

    ll mat[3][3]={0};  
    

    void init()
    {
        mat[1][1]=mat[2][2]=1;

        mat[1][2]=mat[2][1]=0;//这一行必须有，没有就会错,之所以会错，是因为init不仅要承担0矩阵初始化为0级幂矩阵的任务还承担的降幂的任务
        

    }

}sum[100000*4+10],lazy[100000*4+10];




MAT operator*(MAT a, MAT b)
{
    MAT c;

    memset(c.mat,0,sizeof(c.mat));

    for(int i=1;i<=2;i++)
    {
        for(int j=1;j<=2;j++)
        {
            for(int k=1;k<=2;k++)
            {
                c.mat[i][j]=(c.mat[i][j]+a.mat[i][k]*b.mat[k][j]%mod)%mod;

            }
        }
    }

    return c;




}

MAT operator+ (MAT a, MAT b)
{
    MAT c;

    memset(c.mat,0,sizeof(c.mat));


    for(int i=1;i<=2;i++)
    {
        for(int j=1;j<=2;j++)
        {
            c.mat[i][j]=(a.mat[i][j]+b.mat[i][j])%mod;

        }
    }

    return c;

}

MAT quickpow(ll pow)
{
    MAT c;

    c.init();

    MAT base;

    base.mat[1][1]=base.mat[1][2]=base.mat[2][1]=1;

    base.mat[2][2]=0;


    while(pow)
    {
        if(pow&1)
            c=c*base;

            pow>>=1;

            base=base*base;

    }
    return c;

}
void pushup(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];

}
void pushdown(int rt)  //懒标记的下传实际上是幂级的累加，幂级的累加靠乘法来实现
{

   sum[rt<<1]=sum[rt<<1]*lazy[rt];

   sum[rt<<1|1]=sum[rt<<1|1]*lazy[rt];


   lazy[rt<<1]=lazy[rt<<1]*lazy[rt];

   lazy[rt<<1|1]=lazy[rt<<1|1]*lazy[rt];

   lazy[rt].init();  //幂级归零

}

void build(int l,int r,int rt)
{
    sum[rt].init();

    lazy[rt].init();

    if(l==r)
    {
        ll x;

        cin>>x;

        sum[rt]=quickpow(x-1);   //f(x)为x-1次幂的base数组

        return ;


    }

    int mid=(l+r)>>1;

    build(l,mid,rt<<1);

    build(mid+1,r,rt<<1|1);

    pushup(rt);

}

void change(int L,int R,int l,int r,int rt,MAT x)  //把矩阵块累加到区间
{

    if(L<=l&&r<=R)
    {

        lazy[rt]=lazy[rt]*x;


        sum[rt]=sum[rt]*x;

        return;

    }

    pushdown(rt);

    int mid=(l+r)>>1;

    if(L<=mid)
    change(L,R,l,mid,rt<<1,x);

    if(R>mid)
        change(L,R,mid+1,r,rt<<1|1,x);


    pushup(rt);


}

ll getsum(int L,int R,int l,int r,int rt)
{

    if(L<=l&&r<=R)
    {

        return sum[rt].mat[1][1]%mod;


    }

    pushdown(rt);

    int mid=(l+r)>>1;


    ll ans=0;

    if(L<=mid)
        ans=(ans+getsum(L,R,l,mid,rt<<1))%mod;

    if(R>mid)
        ans=(ans+getsum(L,R,mid+1,r,rt<<1|1))%mod;


    return ans;


}
int main ()
{


       int n,m;

       cin>>n>>m;


       build(1,n,1);

       while(m--)
       {
           int a;

           cin>>a;

           if(a==1)
           {
               ll l,r,x;

               cin>>l>>r>>x;

               MAT y=quickpow(x);

               change(l,r,1,n,1,y);

           }
           else
           {
               int l,r;

               cin>>l>>r;

               cout<<getsum(l,r,1,n,1)<<'\n';

           }
       }


    return 0;

}

例题四

​​​​​​区间加区间sin和

根据公式

sin(x+a) = sina cosx + sinx cosa

cos (x+a) =cos a cos x +sinx sin a

且易发现，对一个区间每个数加a,再根据公式求sin 与先求sin之和再根据公式求sin结果相同

故可以利用线段树进行求解。懒标记是所加的a，懒标记的下传方式需要按照公式

# include<iostream>
# include<cstring>
# include<vector>
# include<math.h>
# include<algorithm>
using namespace std;
# define mod 1000000007
typedef long long int ll;

double sumsin[200000*4+10],sumcos[200000*4+10],lazy[200000*4+10];
/*

  sin(a+x)  = sina cosx + sinx cosa

  cos(a+x)  =cosa cosx -sina sinx


*/

void pushup(int rt)
{
    sumcos[rt]=sumcos[rt<<1]+sumcos[rt<<1|1];

    sumsin[rt]=sumsin[rt<<1]+sumsin[rt<<1|1];

}

void push(double la,int rt)
{
    double temsin=sumsin[rt];

    double temcos=sumcos[rt];

    sumsin[rt]=sin(la)*temcos+cos(la)*temsin;

    sumcos[rt]=temcos*cos(la)-sin(la)*temsin;


}
void pushdown(int rt)
{

    if(lazy[rt])  //进行下传
    {

        push(lazy[rt],rt<<1);


        push(lazy[rt],rt<<1|1);


        lazy[rt<<1]+=lazy[rt];

        lazy[rt<<1|1]+=lazy[rt];

        lazy[rt]=0;


    }


}
void build(int l,int r,int rt)
{
     if(l==r)
     {
         double  x;

         cin>>x;

         sumsin[rt]=sin(x);

         sumcos[rt]=cos(x);

         return ;

     }

     int mid=(l+r)>>1;


     build(l,mid,rt<<1);

     build(mid+1,r,rt<<1|1);

     pushup(rt);

}

void change(int L,int R,int l,int r,int rt,double x)
{
    if(L<=l&&r<=R)
    {

        push(x,rt);

        lazy[rt]+=x;

        return ;

    }

    int mid=(l+r)>>1;


    pushdown(rt);

    if(L<=mid)
        change(L,R,l,mid,rt<<1,x);

    if(R>mid)
        change(L,R,mid+1,r,rt<<1|1,x);

    pushup(rt);

}
double querysum(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        return sumsin[rt];

    }

    int mid=(l+r)>>1;


    pushdown(rt);


    double ans=0;


    if(L<=mid)

        ans+=querysum(L,R,l,mid,rt<<1);

    if(R>mid)
        ans+=querysum(L,R,mid+1,r,rt<<1|1);

    return ans;



}

int main ()
{


   int n;

   cin>>n;


   build(1,n,1);

   int t;

   cin>>t;

   while(t--)
   {
       int a;

       cin>>a;

       if(a==1)
       {

           int l,r,x;

           cin>>l>>r>>x;


           change(l,r,1,n,1,x);

       }
       else
       {
           int l,r;

           cin>>l>>r;

           cout<<querysum(l,r,1,n,1)<<endl;

       }
   }



    return 0;

}

高斯消元

为线性代数在计算机编码中的应用。

常见的形式为求解 线性方程组

ax+by+cz= A

dx+ey+fz=B

gx+hy+iz=C

求解出 x,y,z

名词 系数矩阵

\bigl(\begin{smallmatrix} a &b &c \\ d &e &f \\ g & h& i \end{smallmatrix}\bigr)  

增广矩阵

\begin{pmatrix} a &b & c &A \\ d& e& f& B\\ g& h & i & C \end{pmatrix}

利用高斯消元可以将此线性方程组进行求解

常见的高斯消元有四大类  整数解型，浮点数解型，取模型，异或型。

整形高斯消元

int a[50][50];
int x[50];


int gcd(int x,int y)
{
    return !x?x:gcd(y,x%y);

}
int lcm(int x,int y)
{
    return x/gcd(x,y)*y;

}
int Gauss(int hang,int lie)
{
    for(int i=0;i<=lie;i++)
    {
        x[i]=0;
    }

    int row=0,col=0;

    for(row=0;row<hang&&col<lie;col++,row++)
    {

        int maxrow=row;

        for(int i=row+1;i<hang;i++)
        {
            if(abs(a[i][col])>abs(a[maxrow][col]))
                maxrow=i;

        }

        if(maxrow!=row)
        {

            for(int j=col;j<=lie;j++)
            {
                swap(a[row][j],a[maxrow][j]);

            }
        }

        if(a[row][col]==0)
        {
            row--;

            continue;

        }

        for(int i=row+1;i<hang;i++)
        {
            if(a[i][col]!=0)
            {
                int LCM=lcm(abs(a[i][col]),abs(a[row][col]));

                int ta=LCM/abs(a[i][col]);
                int tb=LCM/abs(a[row][col]);

                if(a[i][col]*a[row][col]<0)
                    tb=-tb;

                for(int j=col;j<=lie;j++)
                {
                    a[i][j]=a[i][j]*ta-a[row][j]*tb;

                }
            }
        }
    }
    
    for(int i=row;i<hang;i++)
    {
        if(a[i][col])
            return -1;   //无解
        
    }
    
    int temp=hang-row;
    
    if(row<hang)
        return temp;   //自由元
        
    for(int i=hang-1;i>=0;i--)
    {
        
        int temp=a[i][lie];
        
        for(int j=i+1;j<lie;j++)
        {
            if(a[i][j])
            {
                temp-=a[i][j]*x[j];   //该行j列系数和第j解
                
            }
            
        }
        
        if(temp%a[i][i])
            return -2;    //有解但无整数解
        
        x[i]=temp/a[i][i];
        
        
    }
    
    return  0;
    
    
}

浮点型高斯消元

例题

 例题     ​​​​​​【模板】高斯消元法 - 洛谷

细节为EPS的设定

# include<iostream>
# include<cstring>
# include<vector>
# include<iomanip>
# include<queue>
# include<set>
# include<math.h>
# include<algorithm>
using namespace std;
# define mod 998244353
typedef __int128 ll;

double  a[110][110];
double  x[110];


bool check(double x)
{
    return fabs(x)>1e-6;

}
int Gauss(int hang,int lie)
{
    for(int i=0;i<=lie;i++)
    {
        x[i]=0;
    }

    int row=0,col=0;

    for(row=0;row<hang&&col<lie;col++,row++)
    {

        int maxrow=row;

        for(int i=row+1;i<hang;i++)
        {
            if(fabs(a[i][col])>fabs(a[maxrow][col]))
                maxrow=i;

        }

        if(maxrow!=row)
        {

            for(int j=col;j<=lie;j++)
            {
                swap(a[row][j],a[maxrow][j]);

            }
        }

        if(!check(a[row][col]))
        {
            row--;

            continue;

        }

        for(int i=row+1;i<hang;i++)
        {
            if(check(a[i][col]))
            {

              double ji=a[i][col]/a[row][col];


                for(int j=col;j<=lie;j++)
                {
                    a[i][j]-=a[row][j]*ji;


                }

                a[i][col]=0;

            }
        }
    }

    for(int i=row;i<hang;i++)
    {
        if(check(a[i][col]))
            return -1;   //无解

    }

    int temp=hang-row;

    if(row<hang)
        return temp;   //自由元

    for(int i=hang-1;i>=0;i--)
    {

        double  tem=a[i][lie];

        for(int j=i+1;j<lie;j++)
        {
            if(a[i][j])
            {
                tem-=a[i][j]*x[j];   //该行j列系数和第j解

            }

        }



        x[i]=tem/a[i][i];


    }

    return  0;


}
int main()
{


      int n;

      cin>>n;


      for(int i=0;i<n;i++)
      {
          for(int j=0;j<=n;j++)
          {
              cin>>a[i][j];

          }
      }


     if(Gauss(n,n))
     {
         cout<<"No Solution";

     }
     else
     {
         for(int i=0;i<n;i++)
         {
             cout<<fixed<<setprecision(2)<<x[i]<<endl;

         }
     }



    return 0;
}

模数型高斯消元

int a[100][100];

int x[100];

int gcd(int a,int b)
{
    return !b?a:gcd(b,a%b);

}
int lcm(int a,int b)
{
    return a/gcd(a,b)*b;

}
int gauss(int hang,int lie)
{
    for(int i=0;i<=lie;i++)
    {
        x[i]=0;

    }
    int col=0,row=0;

    for(row=0;row<hang&&col<lie;row++,col++)
    {

        int maxrow=row;

        for(int i=row+1;i<hang;i++)
        {
            if(abs(a[i][col])>abs(a[maxrow][col]))
                maxrow=i;

        }

        if(maxrow!=row)
        {
            for(int j=col;j<=lie;j++)
            {
                swap(a[row][j],a[maxrow][j]);

            }
        }

        if(a[row][col]==0)
        {
            row--;

            continue;
        }

        for(int i=row+1;i<hang;i++)
        {
            if(a[i][col]!=0)
            {
                int lc=lcm(abs(a[i][col]),abs(a[row][col]));

                int ta=lc/abs(a[i][col]);

                int tb=lc/abs(a[row][col]);

                if(a[i][col]*a[row][col]<0)
                    tb=-tb;

                for(int j=col;j<=lie;j++)
                {
                    a[i][j]=((a[i][j]*ta-a[row][j]*tb)%mod+mod)%mod;

                }
            }
        }
    }


    for(int i=row;i<hang;i++)
    {
        if(a[i][col])
            return  -1;

    }

    int temp=hang-row;

    if(row<hang)
        return temp;


    for(int i=hang-1;i>=0;i--)
    {
        int temp=a[i][lie];


        for(int j=i+1;j<lie;j++)
        {
            if(a[i][j])
            {
                temp-=a[i][j]*x[j];

                temp=(temp%mod+mod)%mod;

            }
        }


        while(temp%a[i][i])
        {
            temp+=mod;

        }

        x[i]=(temp/a[i][i])%mod;

    }

    return  0;


}

 异或型高斯消元

通常其系数矩阵为01，求出的解集也是01的形式

int a[100][100];

int x[100];


int gauss(int hang,int lie)
{
    for(int i=0;i<=lie;i++)
    {
        x[i]=0;
        
    }
    
    int col=0,row=0;
    
    for(row=0;row<hang&&col<lie;row++,col++)
    {
        int maxrow=row;
        
        for(int i=row+1;i<hang;i++)
        {
            if(abs(a[i][col])>abs(a[maxrow][col]))
                maxrow=i;
            
        }
        
        if(maxrow!=row)
        {
            for(int j=col;j<=lie;j++)
            {
                swap(a[row][j],a[maxrow][j]);
                
            }
        }
        
        if(a[row][col]==0)
        {
            row--;
            
            continue;
            
        }
        
        for(int i=row+1;i<hang;i++)
        {
            if(a[i][col])
            {
                for(int j=col;j<=lie;j++)
                {
                    a[i][j]^=a[row][j];
                    
                }
            }
        }
    }
    
    for(int i=row;i<hang;i++)
    {
        if(a[i][col])
            return -1;
        
    }
    
    int temp=hang-row;
    
    if(row<hang)
    return temp;
    
    
    for(int i=hang-1;i>=0;i--)
    {
        x[i]=a[i][lie];
        
        for(int j=i+1;j<lie;j++)
        {
            x[i]^=(a[i][j]&&x[j]);
            
        }
        
        //异或之后x[i]==(a[i][i]&&x[i])  如果是1，那么x[i]必须是1，如果是0，那么要具体看题意再进行分析
        
    }

    return  0;
    

}

例题

EXTENDED LIGHTS OUT

典型例题，开关灯问题

 以3*3灯为例，研究第一盏灯

L1 ^ (   A(1,1)&&X(1)  )  ^   (   A(1,2)&&X(2)  ) ^.....(   A(1,9)&&X(9)  )  =0

L为初始状态  A（x,y)为 第y盏灯的开关是否对第x盏灯有影响  X为这盏灯是否按下

其异或结果为0才能保证最终第一站灯为熄灭状态  

而我们对左边异或L1

(   A(1,1)&&X(1)  )  ^   (   A(1,2)&&X(2)  ) ^.....(   A(1,9)&&X(9)  )   =L1

类似处理其余8个灯，以A为系数矩阵，（A,L）为增广矩阵，求出X即可

# include<iostream>
# include<cstring>
# include<vector>
# include<iomanip>
# include<queue>
# include<set>
# include<math.h>
# include<algorithm>
using namespace std;
# define mod 998244353
typedef __int128 ll;

int getid(int x,int y)
{
    return x*6+y;


}

int a[50][50];

int x[50];

int gauss(int hang,int lie)
{
    for(int i=0;i<=lie;i++)
    {
        x[i]=0;

    }

    int row=0,col=0;

    for(row=0;row<hang&&col<lie;row++,col++)
    {

        int maxrow=row;

        for(int i=row+1;i<hang;i++)
        {
            if(a[i][col]>a[maxrow][col])
            {
                maxrow=i;

            }
        }


        if(maxrow!=row)
        {


        for(int j=col;j<=lie;j++)
        {
            swap(a[row][j],a[maxrow][j]);

        }

        }


        if(a[row][col]==0)
        {
            row--;

            continue;

        }



        for(int i=row+1;i<hang;i++)
        {
            if(a[i][col])
            {
                for(int j=col;j<=lie;j++)
                {
                    a[i][j]^=a[row][j];

                }
            }
        }

    }


    for(int i=hang-1;i>=0;i--)
    {
        x[i]=a[i][lie];

        for(int j=i+1;j<lie;j++)
        {
            x[i]^=(a[i][j]&&x[j]);

        }



    }
    
    
    return 0;
    
}
int main()
{




    int t;

    cin>>t;

    int cnt=1;

    while(t--)
    {

        memset(a,0,sizeof(a));

        for(int i=0; i<30; i++)
        {
            cin>>a[i][30];

        }


        for(int i=0; i<5; i++)
        {
            for(int j=0; j<6; j++)
            {
               int t=i*6+j;
               a[t][t]=1;


                if(i>0)
                    a[(i-1)*6+j][t]=1;

                if(i<4)
                    a[(i+1)*6+j][t]=1;

                if(j>0)
                    a[i*6+j-1][t]=1;

                if(j<5)
                    a[i*6+j+1][t]=1;

            }
        }


        gauss(30,30);

        int mo=5;


        cout<<"PUZZLE #"<<cnt<<endl;

        for(int i=0;i<30;i++)
        {
           cout<<x[i]<<" ";

           if(i&&i%mo==0)
           {
               cout<<endl;

               mo+=6;
           }
        }


        cnt++;


    }




    return 0;
}

qinsanma and Code
关注
专栏目录
基于MATLAB的LU高斯消元法求解线性方程组代码，与矩阵求逆方法的对比，条件数的统计
04-02
在MATLAB环境中，LU高斯消元法是一种高效求解线性方程组的方法，而矩阵求逆则是另一种常见的解决方案。这两种方法各有优劣，适用于不同的情况。本篇将详细介绍这两种方法及其应用，并探讨条件数在数值稳定性中的作用...
C语言用高斯消元法求行列式
最新发布
王元笙
12-02 4147
C语言，通过高斯消元法化为上三角行列式求其值
hihoCoder1195 1196(高斯消元，异或方程组)
qq_40828805的博客
03-22 373
高斯消元     异或方程组1.高斯消元我们把每一件商品的价格看作是x[1]..x[n]，第i个组合中第j件商品数量记为a[i][j]，其价格记作y[i]，则可以列出方程式：a[1][1] * x[1] + a[1][2] * x[2] + ... + a[1][n] * x[n] = y[1] a[2][1] * x[1] + a[2][2] * x[2] + ... + a[2][n] * x...
高斯消元入门②-异或线性方程组-POJ1222
qq_35577488的博客
12-31 534
题目大意: 给你一个5∗65 * 65∗6大小的二维01矩阵代表灯的开关状态。改变任意一个灯的状态，会导致其上下左右的灯的状态的改变。问一种灯的开关方案使得最终所有灯都关闭. 题目思路: 首先，一个灯只会被按0次或1次。两次等于没按。不同灯按下的效果是叠加起来的. 解释:想象按下某个位置,等效于原矩阵异或上一个新矩阵。 例如按下(2,2)(2,2)(2,2)产生的效果. A2,2=[010111010]A_{2,2} = \left[\begin{array}{lll} 0 & 1 & 0
【模板题】高斯消元解（异或）线性方程组
一只快乐的小蒟蒻~
10-25 1770
一、高斯消元解线性方程组 【题目描述】 输入一个包含nnn个方程nnn个未知数的线性方程组。 方程组中的系数为实数。 求解这个方程组。 一个包含mmm个方程nnn个未知数的线性方程组示例如下： {a11x1+a12x2+⋯+a1nxn=b1a21x1+a22x2+⋯+a2nxn=b2…am1x1+am2x2+⋯+amnxn=bm\left\{ \begin{aligned} &a_{11}x_1+a_{12}x_2+\dots +a_{1n}x_n=b_1 \\ &a_{21}x_1+a_{
高斯消元法解01异或方程组（附poj 1222题解）
Eason的博客
11-12 6055
const int maxn=50; //有equ个方程，var个变元。增广矩阵行数为equ，列数为var+1 int equ,var; int a[maxn][maxn]; //增广矩阵 int x[maxn]; //解集 int free_x[maxn]; int free_num; void init(){ memset(a,0,sizeof(a)); memset(x,0
shuzhifenxi.rar_求方程组的解_高斯消元_高斯消元法
09-24
高斯消元法是线性代数中一种经典且实用的方法，用于求解线性方程组。在解决数学问题，特别是在计算机科学和工程计算中，它扮演着至关重要的角色。这种方法通过一系列矩阵变换，将系数矩阵转化为简化行阶梯形矩阵，...
gaosixiaoyuan.rar_gauss_数值算法_线性方程组_高斯消元_高斯消元法
09-21
在本压缩包文件中，"高斯消元法求方程组的线性方程组的根"可能是一个实现高斯消元法的程序或代码示例，供数值算法学习者参考。通过阅读和理解这段代码，我们可以更深入地了解高斯消元法的实现细节，并能够运用到实际...
矩阵分解与线性方程组直接方法_LU分解求逆_线性方程组直接方法_矩阵分解_矩阵求逆_
10-04
4. **线性方程组的直接方法**：直接方法是指通过矩阵分解等手段，将线性方程组的求解过程转化为一系列更简单的运算，如矩阵乘法和逆运算。这种方法与迭代方法相对，后者通常用于处理大规模且难以直接求解的系统。...
高斯消元_高斯消元法_线性方程组_
10-04
高斯消元法是线性代数中一种重要的算法，用于求解线性方程组。这种方法通过一系列矩阵变换，将原始的线性方程组转换为阶梯形或简化阶梯形，进而找到方程组的唯一解或者确定无解或多解的情况。在计算机科学和信息技术...
数学_高斯消元+异或方程组
m0_46082460的博客
01-05 232
题意: 给一个n * n的矩阵A 和 B,求有多少个矩阵C能使A x C = B ⊙ C??? 输入描述: 输入n和01矩阵A和01矩阵B 1 <= n <=200 输出描述: Output the answer module 998244353 输入 2 0 1 1 1 1 0 0 1 输出 2 思路: 对于矩阵C的每一列考虑,其实就是异或方程组的高斯消元 但是在赛场上高斯消元我不会啊… 代码实现: #include<bits/stdc++.h> using namespace s
初等行变换和高斯消元
ID246783的博客
11-05 2013
高斯消元   前置芝士：关于线性代数的基本知识   高斯消元是在数学中一种用去求解线性方程组的方法，并且这个算法还能用来求出矩阵的秩和矩阵的逆矩阵。在说高斯消元之前，我们先要说一下什么是矩阵的初等行变换。 初等行变换   首先，我们知道 M 个 N 元一次方程组能够成一个线性方程组，而这些方程组的系数能够写成一个 M 行 N 列的 “系数矩阵”，这个系数矩阵再加上每个方程等号右侧的常数，可以写成一个 M 行 N + 1 列的 “增广矩阵”，举个例子： {x1+2x2+x3=72x1−x2+3x3=73x1+
矩阵用jordan解决initial-value问题_矩阵与数值计算（6）——矩阵幂级数 sin A、cos A...
weixin_39527911的博客
01-28 698
前言矩阵函数是以矩阵为变量且取值为矩阵的一类函数，矩阵函数通常是利用收敛的矩阵幂级数的和来定义。一、矩阵幂级数的收敛求解矩阵幂级数的思路主要利用初等函数的泰勒展开，将矩阵A带入泰勒展开式即可求解得到答案。矩阵幂级数的一般形式为 。求解矩阵函数的问题是：判断矩阵幂级数是否收敛，如果收敛，求收敛矩阵。解析函数的幂级数展开形式是什么样子的针对这两个问题，分别展开描述。判断矩阵幂级数收敛有下述结论：设 ...
矩阵乘+高斯消元专题小结【矩阵乘法】
Senbonzakura
05-19 1698
http://acm.hust.edu.cn/vjudge/contest/view.action?cid=20851#overview A-H是矩阵乘 置顶里面有一个struct matrix，平时写题会比较方便。 首先矩阵乘法满足结合律，于是可以用快速幂的方法求矩阵的幂。 matrix expmod(int k) { matrix e;//单位矩阵 e.n=a.n; e.in
矩阵树定理||高斯消元求行列式
YjmStr
01-21 616
参考链接-博客园 参考链接-oiwiki 定理部分并没有什么原创内容，全是阅读上面两篇文章做的笔记。 矩阵树定理 KirchhoffKirchhoffKirchhoff 矩阵树定理（简称矩阵树定理）解决了一张图的生成树个数计数问题。 矩阵树定理有很多形式，以下内容是一些声明。 应用矩阵树定理的图允许重边，但是不允许自环。 以下内容是照抄oiwiki的 无向图情况： 设GGG是一个有nnn个顶点的无向图。定义度数矩阵D(G)D(G)D(G)为： Dii(G)=deg(i),Dij(G)=0,i≠jD_{ii
【暖*墟】 #数论# 矩阵乘法与高斯消元
flora715的博客
09-07 637
【矩阵乘法与高斯消元】       目录 1.高斯消元的概念方法 【具体过程模拟】 【具体代码实现】  2.矩阵与矩阵乘法  【例题2】洛谷 p3390 矩阵快速幂  【例题3】poj 3318 随机化算法  【例题4】hdu 2157 How many ways  【例题5】洛谷 p1349 广义斐波拉契数列 一. 概念引入 1.高斯消元的概念方法 根据数学知识可...
MIT线性代数 矩阵与高斯消元
KjfureOne的专栏
11-28 777
本系列笔记为方便日后自己查阅而写，更多的是个人见解，也算一种学习的复习与总结，望善始善终吧~ 1. Gauss Elimination 高斯消元 还是从线性方程组谈起，对于以下方程组：    对其求解，我们使用高斯消元法： 想办法消掉第二个与第三个方程中的x，还有第三个方程的y，使得第三个方程只留下一个未知数z，代入第二个只有y和z的方程得到y，再重复以上过程代入第一个方
程序员的自我修养之数学基础05：线性方程组解的情况（矩阵的初等变换和高斯消元法）
M&Q的博客
08-28 1009
真是非常不情愿啊，之前刚刚把矩阵变化讲得非常“玄幻”，但是马上又要转到枯燥的计算上来了。 线性方程组是各个方程关于未知量均为一次的方程组。啥意思呢，举个栗子： 上就是我们常见的线性方程组了，四个未知数。这个方程组可以用矩阵相乘的方式表示（逆推）： 用， ， ， 上面的线性方程组就可以用来表示。 所以我们先来讨论一下线性方程组解的情况。 1. 矩阵的初等变换 解线性方程组的...
线性代数（一）线性方程组与矩阵——高斯消元法 矩阵的初等变换
学习笔记
09-09 2568
写在前面 一直以来都感觉线性代数是门很神奇的课程，尤其后面学到的矩阵的变换以及线性相关等，虽然每次复习一遍理解一遍相关的知识点，但总有些点让我琢磨不透，不过也正因此很喜欢这门课程。 我的笔记可能不太适合初学者，因为只是整理了知识点，有很多没有写上为什么，比如定理是怎么得出的。不过可以拿来看看基本的线代都有哪些内容。 对于要上研究生的学生，个人感觉还是好好学学线性代数，因为不仅仅是为了考试拿高...
C++实现线性方程组解法：高斯消元与Doolittle分解
"这篇资源是关于使用C++编程语言解决线性方程组的方法，包括高斯消元法、Doolittle分解法等经典算法。提供的代码片段展示了如何实现这些方法，同时也包含了辅助函数用于输入、输出和矩阵操作。" 在计算机科学中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qinsanma and Code

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值