模板：快速幂

最新推荐文章于 2024-10-24 19:05:02 发布

原创最新推荐文章于 2024-10-24 19:05:02 发布 · 227 阅读

0 ·

CC 4.0 BY-SA版权

----------数论--------- 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了快速幂算法及其在取模运算中的应用，并深入探讨了矩阵快速幂的概念与实现方法，包括矩阵乘法、矩阵相加及快速幂等关键操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

快速幂：

ll quick_pow(ll x, ll n){   //快速幂    
    ll ans=1;    
    while(n){    
        if(n&1){    
            ans=ans*x;    
        }    
        x=x*x;    
        n>>=1;    
    }    
    return (ans+mod)%mod;    
}    
ll quick(ll a,ll b,ll k){  //快速幂取模  
    if(b==0)return 1ll;
    if(b==1)      
        return a%k;      
    ll z=((a%k)*(a%k))%k;      
    if(b&1){      
        z=(a*quick(z,b/2,k))%k;      
        return z;      
    }      
    else      
        return quick(z,b/2,k);      
}

矩阵快速幂：

typedef long long int ll;
const ll mod = 9973;
const int maxn=15;  //自己看情况定义
//定义矩阵乘法
struct matrix{
    ll arr[maxn][maxn];
    matrix operator*(matrix b){
        matrix ans;
        ll tmp;
        for(int i=0; i<maxn; i++)
        for(int j=0; j<maxn; j++){
            ans.arr[i][j] = 0;
            for(int k=0; k<maxn; k++){
                tmp = (arr[i][k]*b.arr[k][j])%mod;
                ans.arr[i][j] = (ans.arr[i][j] + tmp)%mod;
                //cout<<"oh"<<endl;
            }
        }
        return ans;
    }
};
//矩阵快速幂
matrix quick_pow(matrix a,ll N){
    matrix ans;
    memset(ans.arr,0,sizeof(ans.arr));
    for(int i=0; i<maxn; i++)
        ans.arr[i][i] = 1;
    while(N){
        if(N&1)
            ans = ans*a;
        a = a*a;
        N /= 2;;
    }
    return ans;
}

自定义矩阵大小，无需多余计算。

struct matrix{  
    int mat[31][31];  
};  
int n,mod;   
matrix mul(matrix A,matrix B){  
    int i,j,k;  
    matrix C;  
    ll tmp
    for(i=0;i<n;i++){  
        for(j=0;j<n;j++){  
            C.mat[i][j]=0;  
            for(k=0;k<n;k++){  
                tmp=A.mat[i][k]*B.mat[k][j]%mod
                C.mat[i][j]=(tmp+C.mat[i][j])%mod;  
            }  
        }  
    }  
    return C;  
}  
matrix add(matrix A,matrix B)//矩阵相加  
{  
    int i,j;  
    for(i=0;i<n;i++){  
        for(j=0;j<n;j++){  
            A.mat[i][j]+=B.mat[i][j];  
            A.mat[i][j]=A.mat[i][j]%mod;  
        }  
    }  
    return A;  
}  
matrix quick_pow(matrix A,int k){  //A矩阵的k次方  
    if(k==1)return A;  
    matrix B=quick_pow(A,k/2);  
    B=mul(B,B);  
    if(k%2)B=mul(B,A);  
    return B;  
}

这里有一个矩阵套矩阵，当时写的太费劲，也扔过来吧。但是一定注意：

开了maxn的数组，所以n之后的也要初始化。

typedef int ll;  
const int maxn=33;  
int n,mod;  
//定义矩阵乘法  
struct matrix{  
    ll arr[maxn][maxn];  
    matrix operator*(matrix b){  
        matrix ans;  
        ll tmp;  
        for(int i=0; i<maxn; i++)  
        for(int j=0; j<maxn; j++){  
            ans.arr[i][j] = 0;  
            for(int k=0; k<maxn; k++){  
                tmp = (arr[i][k]*b.arr[k][j])%mod;  
                ans.arr[i][j] = (ans.arr[i][j] + tmp)%mod;  
            }  
        }  
        return ans;  
    }  
    matrix operator+(matrix b){  
        matrix ans;  
        for(int i=0; i<maxn; i++)  
        for(int j=0; j<maxn; j++){  
            ans.arr[i][j]=(arr[i][j]+b.arr[i][j])%mod;  
        }  
        return ans;  
    }  
};  
struct Matrix{  
    matrix mat[2][2];  
    Matrix operator*(Matrix b){  
        Matrix ans;  
        for(int i=0;i<2;i++)  
        for(int j=0;j<2;j++)  
        for(int k=0;k<maxn;k++)  
        for(int l=0;l<maxn;l++)  
            ans.mat[i][j].arr[k][l]=0;  
        for(int i=0;i<2;i++)  
        for(int j=0;j<2;j++)  
        for(int k=0;k<2;k++){  
            ans.mat[i][j]=ans.mat[i][j]+(mat[i][k]*b.mat[k][j]);  
        }  
        return ans;  
    }  
};  
  
//矩阵快速幂  
Matrix quick_pow(Matrix a,ll N){  
    Matrix ans;  
    for(int i=0;i<2;i++)  
    for(int j=0;j<2;j++)  
        memset(ans.mat[i][j].arr,0,sizeof(ans.mat[i][j].arr));   
    for(int i=0; i<n; i++)  
        ans.mat[0][0].arr[i][i]=ans.mat[1][1].arr[i][i]=1;  
    while(N){  
        if(N&1)  
            ans = ans*a;  
        a = a*a;  
        N >>= 1;  
    }  
    return ans;  
}