递归构造之矩阵快速幂

于 2024-01-27 17:55:39 发布
阅读量340 收藏 6
点赞数 8
分类专栏： ACM 文章标签： 矩阵 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52384627/article/details/135886156
版权

递归构造之矩阵快速幂
一.前提须知：在这里插入图片描述
二.各种递推公式构造
1.缺项型（1)//AC
在这里插入图片描述

在这里插入图片描述
题目来源
在这里插入图片描述
在这里插入图片描述

//include<bits/stdc++.h>
#include<cstring>
#include<iostream>
#include<cstdio>
using namespace std;
const int N=12;
int mod;

/*
10 9999
1 1 1 1 1 1 1 1 1 1
20 500
1 0 1 0 1 0 1 0 1 0
*/
struct mat{
    int m[N][N];
};


mat operator*(mat a,mat b)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
        for(int k=0;k<10;k++)
        res.m [i][j]=res.m [i][j]+a.m [i][k]*b.m [k][j];    
        res.m [i][j]%=mod;
        }
    }
    return res;
}



mat quickpow(mat a,int k)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    for(int i=0;i<10;i++)
    res.m [i][i]=1;
    

    while(k)
    {
        if(k&1)res=res*a; 
            k>>=1;
            a=a*a;      
    }
        return res;
}



int main() 
{
    mat cst,a;
    memset(cst.m,0,sizeof(cst.m));
    int k;
    
    
    
    
    while(scanf("%d%d",&k,&mod)!=EOF)
    {
    	
    	//构造cst 
        for(int i=0;i<10;i++)
        {
        scanf("%d",&cst.m [0][i]);
        }
        for(int i=0;i<9;i++)
        cst.m [i+1][i]=1;
        
        //条件判断
        if(k<=9)printf("%d\n",k%mod);
        else
        {
        a=quickpow(cst,k-9);
        int sum=0;
        for(int i=0;i<10;i++)
        sum=sum+a.m [0][i]*(9-i); 
        printf("%d\n",sum%mod);
        }
    }    
}

2.常数型
在这里插入图片描述

在这里插入图片描述
3.含有变量型（1）//Time Limit Exceeded
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
题目来源
在这里插入图片描述
在这里插入图片描述

#include<cstring>
#include<iostream>
#include<cstdio>
using namespace std;

const int N=12;
int mod=123456789;
int n=6;

struct mat{
    int m[N][N];
};

mat operator*(mat a,mat b)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
        
        for(int k=0;k<n;k++)
        res.m [i][j]=res.m [i][j]+(a.m [i][k]*b.m [k][j])%mod;    
        res.m [i][j]%=mod;
        }
    }
    return res;
}

mat quickpow(mat a,int k)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    for(int i=0;i<n;i++)
    res.m [i][i]=1;
    
    
    while(k)
    {
        if(k&1)res=res*a;
            k>>=1;
            a=a*a;   
    }
        return res;
}

/*
5
3
6
9
12
15

31
700
7486
64651
527023
*/
int main() 
{
    mat cst,a;
    int cns,l;
    scanf("%d",&cns); 
    
        cst.m [0][0]=1,cst.m [0][1]=2,cst.m [0][2]=1,cst.m [0][3]=3,cst.m [0][4]=3,cst.m [0][5]=1;
        cst.m [1][0]=1,cst.m [1][1]=0,cst.m [1][2]=0,cst.m [1][3]=0,cst.m [1][4]=0,cst.m [1][5]=0;
        cst.m [2][0]=0,cst.m [2][1]=0,cst.m [2][2]=1,cst.m [2][3]=3,cst.m [2][4]=3,cst.m [2][5]=1;
        cst.m [3][0]=0,cst.m [3][1]=0,cst.m [3][2]=0,cst.m [3][3]=1,cst.m [3][4]=2,cst.m [3][5]=1;
        cst.m [4][0]=0,cst.m [4][1]=0,cst.m [4][2]=0,cst.m [4][3]=0,cst.m [4][4]=1,cst.m [4][5]=1;
        cst.m [5][0]=0,cst.m [5][1]=0,cst.m [5][2]=0,cst.m [5][3]=0,cst.m [5][4]=0,cst.m [5][5]=1;    
    while(n--)
    {
        scanf("%d",&l);       

        a=quickpow(cst,l-2);//快速幂调用 
     
        unsigned long long int sum=0;        
        sum=a.m [0][0]*2+a.m [0][1]+a.m [0][2]*8+a.m [0][3]*4+a.m [0][4]*2+a.m [0][5];
		 
        printf("%lld\n",sum%mod);
    }    
}

4.正常前缀和型(1)//AC
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
题目来源
在这里插入图片描述
在这里插入图片描述

#include<cstring>
#include<iostream>
#include<cstdio>
#define int long long//避免数据溢出 
using namespace std;
 

const int N=12;//不变量一定const,不然m[N][N]定义错误 
const int mod=1000000007;
int n=4;

struct mat{
    int m[N][N];//int矩阵乘法会溢出 ,long long 不会 
};

//0 2
//0 5
//3
//20


mat operator*(mat a,mat b)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
        for(int k=0;k<n;k++)
            res.m [i][j]=(res.m [i][j]%mod+(a.m [i][k]*b.m [k][j])%mod)%mod;    
        }
    }
    return res;
}


mat quickpow(mat a,int k)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    for(int i=0;i<n;i++)
    res.m [i][i]=1;
    
    
    while(k)
    {
        if(k&1)res=res*a;
        
            k>>=1;
            a=a*a;
        
    }
        return res;
}


int sum(int x,mat cst)
{
    if(x < 0) return 0;
    else if(x == 0) return 1;
    else if(x == 1) return 2;
    else if(x == 2) return 3;
    mat ma;
    ma = quickpow(cst, x-2);
    return (3*ma.m[0][0]%mod+ma.m[0][1]%mod+ma.m[0][2]%mod+ma.m[0][3]%mod)%mod;
}
//1 2 3 6 11 20
//1 1 1 3 5 9

signed main()//由于#define定义，所以用signed 
{
    mat cst,a,b;
    int bn,an;
    memset(cst.m,0,sizeof(cst.m));
    
        cst.m [0][0]=1,cst.m [0][1]=1,cst.m [0][2]=1,cst.m [0][3]=1;
        cst.m [1][0]=0,cst.m [1][1]=1,cst.m [1][2]=1,cst.m [1][3]=1;
        cst.m [2][0]=0,cst.m [2][1]=1,cst.m [2][2]=0,cst.m [2][3]=0;
        cst.m [3][0]=0,cst.m [3][1]=0,cst.m [3][2]=1,cst.m [3][3]=0;
        
    
    while(~scanf("%lld%lld",&an,&bn))//long long
    {
        if(an==bn)printf("%lld\n",sum(bn,cst)%mod);
        else {
            int resb = sum(bn,cst)%mod;
            int resa = sum(an-1,cst)%mod;
            int res = (resb-resa+mod)%mod;//+mod,因为resb可能小于resa,成为负数 
            printf("%lld\n",res);
        }
        
    }
    return 0;    
}

5.平方前缀和型(1)//AC
在这里插入图片描述

在这里插入图片描述
题目来源
在这里插入图片描述
在这里插入图片描述

#include<cstring>
#include<iostream>
#include<cstdio>
//#define int long long
using namespace std;

const int N=12;
int mod=10007;
int n=4;

struct mat{
    int m[N][N];
};

mat operator*(mat a,mat b)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
        
        for(int k=0;k<n;k++)
        res.m [i][j]=(res.m [i][j]+(a.m [i][k]*b.m [k][j])%mod)%mod;    
     
        }
    }
    return res;
}


mat quickpow(mat a,int k)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    for(int i=0;i<n;i++)
    res.m [i][i]=1;
    
    
    while(k)
    {
        if(k&1)res=res*a;
        
            k>>=1;
            a=a*a;
        
    }
    
        
        return res;
}
//2 1 1 
//3 2 3 

//6
//196

int main() 
{
    mat cst,a;
    memset(cst.m,0,sizeof(cst.m));
    int l,x,y;
    
    while(scanf("%d%d%d",&l,&x,&y)!=EOF)
    {    
        //可以mod的都mod,尽量都mod
        x=x%mod,y=y%mod;       
        //构造cst 
        cst.m [0][0]=1%mod,cst.m [0][1]=x*x%mod,cst.m [0][2]=2*x*y%mod,cst.m [0][3]=y*y%mod;
        cst.m [1][0]=0%mod,cst.m [1][1]=x*x%mod,cst.m [1][2]=2*x*y%mod,cst.m [1][3]=y*y%mod;
        cst.m [2][0]=0%mod,cst.m [2][1]=x%mod,cst.m [2][2]=y%mod,cst.m [2][3]=0%mod;
        cst.m [3][0]=0%mod,cst.m [3][1]=1%mod,cst.m [3][2]=0%mod,cst.m [3][3]=0%mod;
        
         
        if(l==0)printf("%d",1);
        else if(l==1)printf("%d",2);
        else {
		a=quickpow(cst,l-1);//快速幂调用
        int sum=0;
        sum=a.m [0][0]*2%mod+a.m [0][1]%mod+a.m [0][2]%mod+a.m [0][3]%mod;
        printf("%d\n",sum%mod);
    		}  
	}
}

6.数字01交替型（1）//NOmake
在这里插入图片描述
在这里插入图片描述
题目来源
在这里插入图片描述
在这里插入图片描述

空

三.简单题目//AC
A.题目来源
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<cstdio>//printf(),scanf()
#include<iostream>//cin>>,cout<< 
#include<cstring>//memset()
#define int long long//避免数据溢出
//#include<bits/stdc++.h>   poj无法进行
using namespace std;
const int N=10;
int n=2;
int mod=10000;


struct mat {
	int m[N][N];
};


//或mat mul(mat a,mat b)//矩阵乘法 
mat operator * (mat a,mat b)
{
	mat res;
	memset(res.m,0,sizeof(res.m));
	for(int i=0;i<n;i++)
	for(int j=0;j<n;j++)
	{
		for(int k=0;k<n;k++)
		res.m[i][j]=(res.m[i][j]+(a.m[i][k]*b.m[k][j])%mod)%mod; 
	}
	return res;
}


mat quickpow(mat a,int k)
{


	mat res;//单位矩阵
	memset(res.m,0,sizeof(res.m));
	for(int i=0;i<n;i++)//n矩阵维数
	res.m [i][i]=1;


	while(k){//快速幂
		if(k&1)res=res*a;
		k>>=1;
		a=a*a;
	} 	
	return res;
}


signed main()
{
	int input;//指数
	mat cst,a;
	//由题意构造cst矩阵，即所需快速幂矩阵
	cst.m [0][0]=1;
	cst.m [0][1]=1;
	cst.m [1][0]=1;
	cst.m [1][1]=0;


	while(cin>>input&&input!=-1)
	{
		if(input<=0)cout<<0<<endl;
		else 
		{
		a=quickpow(cst,input-1);
		cout<<(a.m[0][0])%mod<<endl;//如图第2种方法
		}
	}
	return 0;	
}

B.题目来源
在这里插入图片描述
在这里插入图片描述

#include<cstdio>//printf(),scanf()
#include<iostream>//cin>>,cout<< 
#include<cstring>//memset()
//#include<bits/stdc++.h> //  poj无法进行
using namespace std;

const int N=12;
int mod=9973;
int n;
struct mat {
    int m[N][N];
};


//或mat mul(mat a,mat b)//矩阵乘法 
mat operator * (mat a,mat b)
{
    mat res;
    memset(res.m,0,sizeof(res.m));
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    {
        for(int k=0;k<n;k++)
        res.m[i][j]+=a.m[i][k]*b.m[k][j]; 
        res.m[i][j]%=mod;
    }
    return res;
}


mat quickpow(mat a,int k)
{


    mat res;//单位矩阵
    memset(res.m,0,sizeof(res.m));
    for(int i=0;i<n;i++)//n矩阵维数
    res.m [i][i]=1;


    while(k){//快速幂
        if(k&1)res=res*a;
        k>>=1;
        a=a*a;
    }     
    return res;
}


int main()
{
    int l,k;//指数
    mat cst,a;
    cin>>l;
    while(l--)
    {
        cin>>n>>k;
        //所需快速幂矩阵
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        cin>>cst.m [i][j];
        
        a=quickpow(cst,k);
        
		int sum=0;
        for(int i=0;i<n;i++)
        sum=sum+a.m [i][i];
        
        
        printf("%d\n",sum%mod);        
    }
    

    return 0;    
}

四.模板

#include<cstring>
#include<iostream>
#include<cstdio>
#define int long long//避免数据溢出 
using namespace std;
 

const int N=12;//不变量一定const,不然m[N][N]定义错误 
const int mod=1000000007;
int n=4;

struct mat{
    int m[N][N];//int矩阵乘法会溢出 ,long long 不会 
};

//0 2
//0 5
//3
//20

mat operator*(mat a,mat b)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
        for(int k=0;k<n;k++)
            res.m [i][j]=(res.m [i][j]%mod+(a.m [i][k]*b.m [k][j])%mod)%mod;    
        }
    }
    return res;
}


mat quickpow(mat a,int k)
{
    mat res;
    memset(res.m ,0,sizeof(res.m ));
    for(int i=0;i<n;i++)
    res.m [i][i]=1;
    
    
    while(k)
    {
        if(k&1)res=res*a;
        
            k>>=1;
            a=a*a;
        
    }
        return res;
}


int sum(int x,mat cst)
{
    if(x < 0) return 0;
    else if(x == 0) return 1;
    else if(x == 1) return 2;
    else if(x == 2) return 3;
    mat ma;
    ma = quickpow(cst, x-2);
    return (3*ma.m[0][0]%mod+ma.m[0][1]%mod+ma.m[0][2]%mod+ma.m[0][3]%mod)%mod;
}
//1 2 3 6 11 20
//1 1 1 3 5 9

signed main()//由于#define定义，所以用signed 
{
    mat cst,a,b;
    int bn,an;
    memset(cst.m,0,sizeof(cst.m));
    
        cst.m [0][0]=1,cst.m [0][1]=1,cst.m [0][2]=1,cst.m [0][3]=1;
        cst.m [1][0]=0,cst.m [1][1]=1,cst.m [1][2]=1,cst.m [1][3]=1;
        cst.m [2][0]=0,cst.m [2][1]=1,cst.m [2][2]=0,cst.m [2][3]=0;
        cst.m [3][0]=0,cst.m [3][1]=0,cst.m [3][2]=1,cst.m [3][3]=0;
        
    
    while(~scanf("%lld%lld",&an,&bn))//long long
    {
        if(an==bn)printf("%lld\n",sum(bn,cst)%mod);
        else {
            int resb = sum(bn,cst)%mod;
            int resa = sum(an-1,cst)%mod;
            int res = (resb-resa+mod)%mod;//+mod,因为resb可能小于resa,成为负数 
            printf("%lld\n",res);
        }
        
    }
    return 0;    
}
阿斯卡码
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法导论(part1)
09-09
4．4．1 取正合幂时的证明 4．4．2 上取整函数和下取整函数 第5章 概率分析和随机算法 5．1 雇用问题 5．2 指示器随机变量 5．3 随机算法 *5．4 概率分析和指示器随机变量的进一步使用 5．4．1 生日悖论 ...
算法导论(part2)
09-09
4．4．1 取正合幂时的证明 4．4．2 上取整函数和下取整函数 第5章 概率分析和随机算法 5．1 雇用问题 5．2 指示器随机变量 5．3 随机算法 *5．4 概率分析和指示器随机变量的进一步使用 5．4．1 生日悖论 ...
快速幂 矩阵快速幂
issey的博客
10-22 5500
前言：好像没啥好写的，链接可能还没有更新完 快速幂 快速幂，用于解决当n很大时的情况。通常与取模同时应用。 用最笨的方法求,即。时间复杂度为,而快速幂（附带取模），可以将时间复杂度降低为。 利用倍增的思想，例如，等于，又等于,即,如果n为奇数，,那么换成代码就是： ll Powermod(ll a,ll b) { ll ans=1; a=a%mod; while(b>0) { if(b%2==1) ans=(ans*a)%...
程序算法艺术与实践:递归策略之矩阵乘法问题
松子茶的专栏
09-16 4210
矩阵（Matrix）是指纵横排列的二维数据表格，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。 矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。并且在ACM竞赛，有很多涉及到矩阵知识的题。许多算法都会结合矩阵来处理，而比较具有代表性的矩阵算法有：矩阵快速幂、高斯消元等等.关于程序算法艺术与实践更多讨论与交流，敬请关注本博客和新浪微博songzi_tea.
矩阵快速幂中矩阵的构造技巧
leodestiny
01-25 2087
对于出现线性递推的题目，当直接暴力计算的复杂度太高时，我们可以考虑用矩阵快速幂进行加速。 因为虽然矩阵乘法的复杂度为O（n^3），但是通过二进制分解，整体的复杂度变成了 log(n^3) = 3logn = O(logn)，复杂度是对数级别的，非常小。 但是矩阵快速幂的难点就是在如何构造矩阵来完成计算。 因为矩阵快速幂是用来加速线性递推的，所以最核心的部分就是线性递推公式。 最经典的就是斐
矩阵快速幂基本思想
请刷题2016
10-02 4574
学长传授 快速幂的思想： 假设我们要求a^b，最朴素的方法就是不断地乘a，乘b次，复杂度O(b)。 如果b很大，10^9，就需要用快速幂的思想。 例：a=3，b=100； 100的二进制为：1100100 也就是100可以化成64+32+4。 所以原数可以化成a^64*a^32*a^4 算法流程： 判断1100100的每一位是否为1，如果是1，就乘对应的二进制次幂。以此类推，
根据递推公式构造系数矩阵用于快速幂
大宝哥spring
10-05 513
简单的例子 Fibonacci数列 考虑Fibonacci数列， F(n)=F(n−1)+F(n−2) 将右边两项看做是一个列向量的形式，令 Xn−1={Fn−1Fn−2} 很容易得到Xn的形式，即 Xn={FnFn−1} 现在的任务就是找到一个系数矩阵A，使得AXn−1=Xn，且A需与n无关。 如果能够找到这个A，则易知An−1X1=Xn，
IOI国家集训队论文集1999-2019
09-20
+ [染色与构造](#染色与构造) * [一类问题](#一类问题) + [区间](#区间) + [序](#序) + [系](#系) + [物理问题](#物理问题) + [编码与译码](#编码与译码) + [对策问题](#对策问题) * [优化](#优化-2) + ...
C程序范例宝典（基础代码详解）
05-17
实例169　求3×3矩阵对角元素之和　244 实例170　矩阵的加法运算　245 实例171　矩阵的乘法运算　246 实例172　打印n阶螺旋方阵　247 5.5　生活中的数学　249 实例173　求车运行速度　249 实例174　卖西瓜　250 实例...
c语言经典案例
10-30
实例022 快速排序 27 实例023 选择排序 28 实例024 归并排序 29 实例025 二分查找 31 实例026 分块查找 32 实例027 哈希查找 34 实例028 斐波那契数列 37 实例029 哥德巴赫猜想 38 实例030 尼科彻斯定理 39 第4章 ...
HDU 5950(Recursive sequence)
大宝哥spring
10-30 2906
Recursive sequence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 29    Accepted Submission(s): 19 Problem Description Farmer John
hdu4565 矩阵构造＋矩阵快速幂
chenhongwei6447的博客
03-03 311
第一眼看到就是矩阵快速幂，当然不能拿浮点数来快速幂了，要转化一下。
矩阵快速幂专题（矩阵快速幂入门、矩阵构造法、数论规律题）
林下的码路
08-04 2318
Link1：http://acm.hdu.edu.cn/showproblem.php?pid=1575 Tr A Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3628    Accepted Submissio
矩阵快速幂+构造方法
swust5120171204的博客
05-14 372
与快速幂一样，可以将递推式通过二进制的方式来进行优化，这个学了快速幂就是十分容易理解 大概的板子如下： struct mat///自己定义大小的矩阵 { ll m[11][11]; }; mat mulmat(mat A,mat B)///两个矩阵相乘 { mat C; memset(C.m,0,sizeof(C.m)); for(int i=0;i<n...
矩阵快速幂模板和构造矩阵
qq_41129854的博客
08-09 414
板子代码（其余的题构造出矩阵代入，改下计算的结果就行） #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;algorithm&gt; using namespace std; #define mod 10000 struct node { long long m[2][2];//根据构造的矩阵而定数组的大小 } a...
矩阵快速幂（模板+构造）
Rshs
02-27 255
矩阵快速幂（模板+构造） #include<bits/stdc++.h> using namespace std; #define LL long long #define mod 1000000007 /* ( x x x x x )^n ( x x x x x ) (x x x x x) * ( x x x x x ...
矩阵快速幂的常数矩阵的构造
qq_27151549的博客
11-01 687
版权声明：本文为湖南师范大学RBS原创文章，转载请注明出处。    https://blog.csdn.net/u012061345/article/details/52224623 各种形式的矩阵快速幂常数矩阵的构造，对于二项式展开也有效果...
矩阵快速幂-构造矩阵
qq_42757965的博客
08-02 383
参考博文：https://blog.csdn.net/Akatsuki__Itachi/article/details/80443939 感觉矩阵快速幂也不是太难吗，矩阵的乘法基本上都会吧，还有快速幂这也没有啥难度，所以矩阵快速幂的板子其实挺简单的。关键都是矩阵的构造，假如矩阵快速幂的题，如果你能够把矩阵给构造出来，那你这道题就已经出来了。所以说矩阵快速幂的关键就是构造矩阵，这篇文章就说一下矩阵...
矩阵快速幂求斐波那契数列（初学整理）
weixin_30399871的博客
10-31 585
参考文章： http://blog.csdn.net/u013795055/article/details/38599321 http://blog.csdn.net/g_congratulation/article/details/52734306 感谢以上两位大神让我明白了如何用矩阵快速幂求斐波那契...
Python矩阵快速幂
最新发布
11-27
矩阵快速幂是一种高效的算法，用于计算矩阵的幂。在计算机科学中，矩阵快速幂通常用于解决递归问题，例如斐波那契数列。下面是Python实现矩阵快速幂的示例代码： ```python def matrix_multiply(a, b): zip_b = list(zip(*b)) return [[sum(ele_a * ele_b for ele_a, ele_b in zip(row_a, col_b)) for col_b in zip_b] for row_a in a] def matrix_power(matrix, power): result = None while power: if power & 1: result = matrix_multiply(result, matrix) if result else matrix matrix = matrix_multiply(matrix, matrix) power >>= 1 return result # 示例 matrix = [[1, 1], [1, 0]] result = matrix_power(matrix, 5) print(result) ``` 上述代码中，`matrix_multiply`函数用于计算两个矩阵的乘积，`matrix_power`函数用于计算矩阵的幂。在`matrix_power`函数中，我们使用了位运算来实现快速幂算法，从而提高了算法的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿斯卡码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值