矩阵快速幂、求逆矩阵封装模板

矩阵模板

重载输入流 输出流 + *

矩阵快速幂 求逆矩阵

逆矩阵求法往下滑…

struct matrix{
    vector<vector<ll>>a;
    int n,m;
    matrix(int n,int m){
        this->n=n,this->m=m;
        a=vector<vector<ll>>(n+1,vector<ll>(m+1,0));
    }  
    matrix(int n,int m,char x){
        //单位阵
        this->n=n,this->m=m;
        a=vector<vector<ll>>(n+1,vector<ll>(m+1,0));
        for(int i=1;i<=min(n,m);i++)a[i][i]=1;
    }
    friend istream &operator>>(istream &input,matrix &B){
        for(int i=1;i<=B.n;i++){
            for(int j=1;j<=B.m;j++){
                input>>(B.a[i][j]);
            }
        }
        return input;
    } 
    friend ostream &operator<<(ostream &output,const matrix &B){
        for(int i=1;i<=B.n;i++){
            for(int j=1;j<=B.m;j++){
                output<<B.a[i][j]<<' ';
            }
            output<<'\n';
        }
        return output;
    }
    matrix operator + (const matrix &B){
        matrix sum(n,m);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                sum.a[i][j]=this->a[i][j]+B.a[i][j];
                sum.a[i][j]%=mod;
            }
        }
        return sum;
    }
    matrix operator * (const matrix& B){
        matrix mul(n,B.m);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=B.m;j++){
                for(int k=1;k<=m;k++){
                    mul.a[i][j]+=this->a[i][k]*B.a[k][j];
                    mul.a[i][j]%=mod;
                }
            }
        }
        return mul;
    }
    matrix pow(int k){//矩阵快速幂
        matrix ans(n,m,'E'),base=*this;
        while(k){
            if(k&1)ans=ans*base;
            base=base*base;
            k>>=1;
        }
        return ans;
    }
    matrix inreverse(){//求逆矩阵
        matrix tmp=*this,ans(n,m,'E');
        for(int i=1;i<=n;i++){
            int maxn=i;
            for(int j=i+1;j<=n;j++){
                if(tmp.a[j][i]>tmp.a[maxn][i])maxn=j;
            }
            swap(tmp.a[i],tmp.a[maxn]);
            swap(ans.a[i],ans.a[maxn]);
            if(tmp.a[i][i]==0)return matrix(0,0);//不存在
            for(int j=1;j<=n;j++){
                if(j==i)continue;
                ll base=tmp.a[j][i]*ksm(tmp.a[i][i],mod-2)%mod;
                for(int k=n;k>=1;k--){
                    ans.a[j][k]-=ans.a[i][k]*base%mod;
                    ans.a[j][k]=(ans.a[j][k]%mod+mod)%mod;
                    tmp.a[j][k]-=tmp.a[i][k]*base%mod;
                    tmp.a[j][k]=(tmp.a[j][k]%mod+mod)%mod;
                }
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                ans.a[i][j]*=ksm(tmp.a[i][i],mod-2);
                ans.a[i][j]%=mod;
            }
        }
        return ans;
    }
};

逆矩阵的求解

$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}\end{array}\right]\text{.}$

比如A这个矩阵

只需要往右边补一个单位阵

即为

$T=\left[\begin{array}{cccccccc}{a}_{11}& a_{12}& \cdots & a_{1n}& 1& 0& \cdots & 0\\ a_{21}& a_{22}& \cdots & a_{2n}& 0& 1& \cdots & 0\\ ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}& 0& 0& \cdots & 1\end{array}\right]\text{.}$

然后只需要对矩阵进行初等变换

使得拼接的前半部分变为单位阵 此时右半部分的矩阵即为 $A^{-1}$

正确性证明：

设左半矩阵为$A$，右半矩阵为单位阵$E$

初等行变换 即为 $PA=E$

则$A^{-1}=P$

而右半矩阵经过同等的初等行变换后即变为$PE=P=A^{-1}$

得证