快速幂矩乘学习报告

最新推荐文章于 2024-10-29 16:59:55 发布
最新推荐文章于 2024-10-29 16:59:55 发布
阅读量101 收藏
点赞数 3
文章标签： 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eliyou/article/details/120202366
版权

科学到了一定境界就是玄学，玄学到了一定境界就是科学。
——题记

目录

快速幂矩乘学习报告

矩阵是一个非常庞大和复杂的课题，本文只涉及最简单的矩阵运算和优化。
对于更多内容，详见OI Wiki 数学/线性代数/矩阵一节。

矩阵及其运算的基本性质

矩阵加法/矩阵减法：对应位置相加减
矩阵加法部分代码如下：

const matrix operator + (const matrix &x,const matrix &y){
	matrix ret;
	int i,j;
	ret.l = x.l,ret.r = x.r;
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = 0;
		}
	}
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = (x.mat[i][j] + y.mat[i][j]) % mod;
		}
	}
	return ret;
}

矩阵乘法：结果矩阵中的点 ( i , j ) (i,j) (i,j)为左矩阵 i i i行与右矩阵 j j j列对应位置的积的和。
矩阵乘法要求左矩阵的列数等于右矩阵的行数，这样才能一一对应。
矩阵乘法满足分配律和结合律，但是不满足交换律。

在矩阵乘法当中， a n s [ i ] [ j ] = x [ i ] [ k ] ∗ y [ k ] [ j ] ans[i][j]=x[i][k]*y[k][j] ans[i][j]=x[i][k]∗y[k][j]，先枚举k，再枚举i,j能优化常数，把j用register int声明能进一步优化常数。

矩阵乘法部分代码如下：

const matrix operator * (const matrix &x,const matrix &y){
	matrix ret;
	int i,k;
	register int j;
	long long temp;
	ret.l = x.l,ret.r = y.r;
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = 0;
		}
	}
	for(k = 1;k <= x.r;k++){
		for(i = 1;i <= ret.l;i++){
			temp = x.mat[i][k];
			for(j = 1;j <= ret.r;j++){
				ret.mat[i][j] = (ret.mat[i][j] + temp * y.mat[k][j]) % mod; 
			}
		}
	}
	return ret;
}

矩阵快速幂：优化求矩阵的幂的方法。

单位矩阵：只有对角线是1，剩余部分都是0的矩阵。一切矩阵乘单位矩阵仍等于它本身。

矩阵运算的应用

矩阵运算一般用来优化一些线性的、符合某些递推关系的计算过程的时间复杂度（但矩阵快速幂的常数是绝对不能忽视的），也能简化多个元素共同计算的问题。矩阵运算的优化一般都是用矩阵乘法。

矩阵运算优化时间复杂度

矩阵运算能够优化的递推关系中常见的如下：

  • f [ i ] = p f [ i − x ] + q f [ i − y ] ⋯ f[i]=pf[i-x]+qf[i-y]\cdots f[i]=pf[i−x]+qf[i−y]⋯
  • g [ i ] [ j ] = g [ i ] [ k ] + g [ k ] [ j ] g[i][j]=g[i][k]+g[k][j] g[i][j]=g[i][k]+g[k][j]

总而言之，通常可以优化的递推式接近于矩阵乘法的形式。

T1 广义斐波那契数列（洛谷P1349，难度2）
这题的递推式就是一个线性的普通递推，因此考虑用矩阵加速递推。为了得到转移矩阵，由于这里 f [ i ] f[i] f[i]只与 f [ i − 1 ] f[i-1] f[i−1]有关，因此我们理论上只需要考虑2*2的矩阵。
先列出这么一个形式的递推：
[ f [ i ] f [ i − 1 ] ] = [ f [ i − 1 ] f [ i − 2 ] ] ∗ [ ? ? ? ? ] \begin{bmatrix}f[i]&f[i-1]\end{bmatrix}=\begin{bmatrix}f[i-1]&f[i-2]\end{bmatrix}*\begin{bmatrix}?& ?\\?& ?\end{bmatrix} [f[i]​f[i−1]​]=[f[i−1]​f[i−2]​]∗[??​??​]

我们接下来考虑矩阵乘法的定义，套入原来的式子 f [ i ] = p f [ i − 1 ] + q f [ i − 2 ] f[i]=pf[i-1]+qf[i-2] f[i]=pf[i−1]+qf[i−2]，就可以得到矩阵递推式：
[ f [ i ] f [ i − 1 ] ] = [ f [ i − 1 ] f [ i − 2 ] ] ∗ [ p 1 q 0 ] \begin{bmatrix}f[i]&f[i-1]\end{bmatrix}=\begin{bmatrix}f[i-1]&f[i-2]\end{bmatrix}*\begin{bmatrix}p&1\\q& 0\end{bmatrix} [f[i]​f[i−1]​]=[f[i−1]​f[i−2]​]∗[pq​10​]

最终答案如下：

[ f [ i ] f [ i − 1 ] ] = [ a 2 a 1 ] ∗ [ p 1 q 0 ] n − 2 \begin{bmatrix}f[i]&f[i-1]\end{bmatrix}=\begin{bmatrix}a_2&a_1\end{bmatrix}*\begin{bmatrix}p&1\\q& 0\end{bmatrix}^{n-2} [f[i]​f[i−1]​]=[a2​​a1​​]∗[pq​10​]n−2

因此，对于这类问题，一个比较可行的办法就是先列出结果和转移出结果的两个矩阵，然后通过这两个矩阵填写转移矩阵。

T2 行为方案（难度3）

  • 某个国家用一个机器人攻击一个有n个城市、m个道路的地区，机器人每一次行动可以进行以下三项之一：原地不动，运动到可达的相邻城市，自爆。机器人从1号城市出发，求机器人进行t次行动的全部方案数。

设 d p [ i ] [ j ] dp[i][j] dp[i][j]表示机器人从i走到j的总方案数，枚举中转城市，则有 d p [ i ] [ j ] = ∑ d p [ i ] [ k ] + d p [ k ] [ j ] dp[i][j]=\sum dp[i][k] +dp[k][j] dp[i][j]=∑dp[i][k]+dp[k][j]，这个形式明显是矩阵乘法的形式，可以考虑用矩阵优化。把 d p [ i ] [ j ] dp[i][j] dp[i][j]就看作是矩阵 ( i , j ) (i,j) (i,j)的值，那么两个城市联通可以表示为 d p [ x ] [ y ] = d p [ y ] [ x ] = 1 dp[x][y] = dp[y][x] = 1 dp[x][y]=dp[y][x]=1，原地不动相当于 d p [ x ] [ x ] = 1 dp[x][x]=1 dp[x][x]=1，自爆看作走到城市0，即 d p [ x ] [ 0 ] = 1 dp[x][0]=1 dp[x][0]=1.按照这些规则构造矩阵，然后计算它的t次方，取出x=1的值加和就是最终答案。
代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int mod = 2017;
struct matrix{
	long long l,r,mat[101][101];
}A,tot;
int n;
matrix GetE(){
	matrix ret;
	int i;
	ret.l = ret.r = n;
	for(i = 0;i <= n;i++){
		ret.mat[i][i] = 1;
	}
	return ret;
}
matrix operator * (const matrix &x,const matrix &y){
	matrix ret;
	int i,j,k;
	long long temp;
	ret.l = x.l,ret.r = y.r;
	for(i = 0;i <= ret.l;i++){
		for(j = 0;j <= ret.r;j++){
			ret.mat[i][j] = 0;//必要的初始化
		}
	}
	for(k = 0;k <= x.r;k++){
		for(i = 0;i <= ret.l;i++){
			temp = x.mat[i][k];
			for(j = 0;j <= ret.r;j++){
				ret.mat[i][j] = (ret.mat[i][j] + temp * y.mat[k][j] % mod) % mod;
			}
		}
	}
	return ret;
}
matrix ksm(matrix a,int b){
	matrix ret = GetE();
	while(b){
		if(b & 1){
			ret = ret * a;
		}
		a = a * a;
		b >>= 1;
	}
	return ret;
}
int main(){
	int i,j,m,t,x,y;
	long long res = 0;
	scanf("%d %d",&n,&m);
	for(i = 0;i <= n;i++){
		A.mat[i][i] = 1;
		A.mat[i][0] = 1;
	}
	for(i = 1;i <= m;i++){
		scanf("%d %d",&x,&y);
		A.mat[x][y] = A.mat[y][x] = 1;
	}
	scanf("%d",&t);
	A.l = A.r = n;
	tot = ksm(A,t);
	for(i = 0;i <= n;i++){
		res = (res + tot.mat[1][i]) % mod;
	}
	printf("%lld\n",res);
	return 0;
}
/*
3 2
1 2
2 3
2
*/

矩阵运算优化实现过程

T3 大魔法师（洛谷P7453）
此题首先全是区间操作，无疑要上线段树了。
这题麻烦的地方在于怎么同时更新三个数组。一个比较简单直接的想法是用结构体存，但是这就需要同时写区间赋值、区间加、区间乘，尤其是怎么把区间赋值和后两个很好的匹配（毕竟肯定要打懒标记的）是一个比较头疼的问题。再加上同时区间加和区间乘，那一天OIer又回想起了被线段树2pushdown支配的恐惧。
然而如果我们换个思路，用矩阵乘法来考虑这个问题，会有一些新的发现。以操作一和操作四为例：
[ A i B i C i ] ∗ [ 1 0 0 1 1 0 0 0 1 ] = [ A i + B i B i C i ] ( 1 ) \begin{bmatrix}A_i&B_i&C_i\end{bmatrix}*\begin{bmatrix}1& 0&0\\1& 1&0\\0&0&1\end{bmatrix}=\begin{bmatrix}A_i+B_i&B_i&C_i\end{bmatrix}(1) [Ai​​Bi​​Ci​​]∗⎣⎡​110​010​001​⎦⎤​=[Ai​+Bi​​Bi​​Ci​​](1)

[ A i B i C i 1 ] ∗ [ 1 0 0 0 0 1 0 0 0 0 1 0 v 0 0 1 ] = [ A i + v B i C i 1 ] ( 4 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\0& 1&0&0\\0&0&1&0\\v&0&0&1\end{bmatrix}=\begin{bmatrix}A_i+v&B_i&C_i&1\end{bmatrix}(4) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​100v​0100​0010​0001​⎦⎥⎥⎤​=[Ai​+v​Bi​​Ci​​1​](4)

（当然，为了统一，我们实际写的时候对于123操作的矩阵也要变成4x4和1x4的）
这样一来，对于全部的六个修改操作，就可以全部用矩阵乘法解决，维护区间三种元素的和只要再相加就可以了。这样一来，我们只需要在区间乘区间求和的基础上，套上矩阵就完成了此题。

此题的六个转移式在代码后我会完整地列出。

代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define mid (l + r >> 1)
const int mod = 998244353;
const int N = 250001;
struct matrix{
	int l,r;
	long long mat[5][5];
}I,emp,op[7];
int a[N],b[N],c[N];
const matrix operator * (const matrix &x,const matrix &y){
	matrix ret;
	int i,k;
	register int j;
	long long temp;
	ret.l = x.l,ret.r = y.r;
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = 0;
		}
	}
	for(k = 1;k <= x.r;k++){
		for(i = 1;i <= ret.l;i++){
			temp = x.mat[i][k];
			for(j = 1;j <= ret.r;j++){
				ret.mat[i][j] = (ret.mat[i][j] + temp * y.mat[k][j]) % mod; 
			}
		}
	}
	return ret;
}
const matrix operator + (const matrix &x,const matrix &y){
	matrix ret;
	int i,j;
	ret.l = x.l,ret.r = x.r;
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = 0;
		}
	}
	for(i = 1;i <= ret.l;i++){
		for(j = 1;j <= ret.r;j++){
			ret.mat[i][j] = (x.mat[i][j] + y.mat[i][j]) % mod;
		}
	}
	return ret;
}
void GetI(){
	int i,j;
	I.l = I.r = 4;
	for(i = 1;i <= 4;i++){
		for(j = 1;j <= 4;j++){
			I.mat[i][j] = (i == j);
		}
	}
	emp.l = 1,emp.r = 4;
	for(i = 1;i <= 4;i++){
		emp.mat[1][i] = 0;
	}
	for(i = 1;i <= 6;i++) op[i].l = op[i].r = 4;
	op[1].mat[1][1] = op[1].mat[2][1] = op[1].mat[2][2] = op[1].mat[3][3] = op[1].mat[4][4] = 1;
	op[2].mat[1][1] = op[2].mat[2][2] = op[2].mat[3][2] = op[2].mat[3][3] = op[2].mat[4][4] = 1;
	op[3].mat[1][1] = op[3].mat[2][2] = op[3].mat[1][3] = op[3].mat[3][3] = op[3].mat[4][4] = 1;
	op[4].mat[1][1] = op[4].mat[2][2] = op[4].mat[3][3] = op[4].mat[4][4] = 1;
	op[5].mat[1][1] = op[5].mat[3][3] = op[5].mat[4][4] = 1;
	op[6].mat[1][1] = op[6].mat[2][2] = op[6].mat[4][4] = 1;
}
struct wyx{
	matrix tre[N << 2],laz[N << 2];
	void push(int k,int l,int r){
		laz[k << 1] = laz[k << 1] * laz[k];
		laz[k << 1 | 1] = laz[k << 1 | 1] * laz[k];
		tre[k << 1] = tre[k << 1] * laz[k];
		tre[k << 1 | 1] = tre[k << 1 | 1] * laz[k];
		laz[k] = I;
	}
	void build(int k,int l,int r){
		laz[k] = I;
		tre[k].l = 1,tre[k].r = 4;
		if(l == r){
			tre[k].mat[1][1] = a[l],tre[k].mat[1][2] = b[l],tre[k].mat[1][3] = c[l],tre[k].mat[1][4] = 1;
			return;
		}
		build(k << 1,l,mid);
		build(k << 1 | 1,mid + 1,r);
		tre[k] = tre[k << 1] + tre[k << 1 | 1];
	}
	void modify(int k,int l,int r,int x,int y,int id){
		if(x <= l && r <= y){
			laz[k] = laz[k] * op[id];
			tre[k] = tre[k] * op[id];
			return;
		}
		push(k,l,r);
		if(x <= mid) modify(k << 1,l,mid,x,y,id);
		if(y > mid) modify(k << 1 | 1,mid + 1,r,x,y,id);
		tre[k] = tre[k << 1] + tre[k << 1 | 1];
	}
	matrix query(int k,int l,int r,int x,int y){
		matrix ret = emp;
		if(x <= l && r <= y){
			return tre[k];
		}
		push(k,l,r);
		if(x <= mid) ret = ret + query(k << 1,l,mid,x,y);
		if(y > mid) ret = ret + query(k << 1 | 1,mid + 1,r,x,y);
		return ret;
	}
}STr;
int main(){
	int i,n,m,x,y,v,z;
	matrix temp;
	scanf("%d",&n);
	for(i = 1;i <= n;i++){
		scanf("%d %d %d",&a[i],&b[i],&c[i]);
	}
	GetI();
	STr.build(1,1,n);
	scanf("%d",&m);
	for(i = 1;i <= m;i++){
		scanf("%d %d %d",&z,&x,&y);
		if(z <= 6){
			if(z >= 4 && z <= 6){
				scanf("%d",&v);
				op[4].mat[4][1] = op[5].mat[2][2] = op[6].mat[4][3] = v;
			}
			STr.modify(1,1,n,x,y,z);
			op[4].mat[4][1] = op[5].mat[2][2] = op[6].mat[4][3] = 0;
		}
		else{
			temp = STr.query(1,1,n,x,y);
			printf("%lld %lld %lld\n",temp.mat[1][1],temp.mat[1][2],temp.mat[1][3]);
		}
	}
	return 0;
}

在所有的矩阵运算之前，必须给矩阵的长宽赋值，这在复杂的问题当中尤其容易被忽略。

全部转移式如下：

[ A i B i C i 1 ] ∗ [ 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 ] = [ A i + B i B i C i 1 ] ( 1 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\1& 1&0&0\\0&0&1&0\\0&0&0&1\end{bmatrix}=\begin{bmatrix}A_i+B_i&B_i&C_i&1\end{bmatrix}(1) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​1100​0100​0010​0001​⎦⎥⎥⎤​=[Ai​+Bi​​Bi​​Ci​​1​](1)

[ A i B i C i 1 ] ∗ [ 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 1 ] = [ A i B i + C i C i 1 ] ( 2 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\0& 1&0&0\\0&1&1&0\\0&0&0&1\end{bmatrix}=\begin{bmatrix}A_i&B_i+C_i&C_i&1\end{bmatrix}(2) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​1000​0110​0010​0001​⎦⎥⎥⎤​=[Ai​​Bi​+Ci​​Ci​​1​](2)

[ A i B i C i 1 ] ∗ [ 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 ] = [ A i B i C i + A i 1 ] ( 3 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&1&0\\0& 1&0&0\\0&0&1&0\\0&0&0&1\end{bmatrix}=\begin{bmatrix}A_i&B_i&C_i+A_i&1\end{bmatrix}(3) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​1000​0100​1010​0001​⎦⎥⎥⎤​=[Ai​​Bi​​Ci​+Ai​​1​](3)

[ A i B i C i 1 ] ∗ [ 1 0 0 0 0 1 0 0 0 0 1 0 v 0 0 1 ] = [ A i + v B i C i 1 ] ( 4 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\0& 1&0&0\\0&0&1&0\\v&0&0&1\end{bmatrix}=\begin{bmatrix}A_i+v&B_i&C_i&1\end{bmatrix}(4) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​100v​0100​0010​0001​⎦⎥⎥⎤​=[Ai​+v​Bi​​Ci​​1​](4)

[ A i B i C i 1 ] ∗ [ 1 0 0 0 0 v 0 0 0 0 1 0 0 0 0 1 ] = [ A i + v B i ∗ v C i 1 ] ( 5 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\0& v&0&0\\0&0&1&0\\0&0&0&1\end{bmatrix}=\begin{bmatrix}A_i+v&B_i*v&C_i&1\end{bmatrix}(5) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​1000​0v00​0010​0001​⎦⎥⎥⎤​=[Ai​+v​Bi​∗v​Ci​​1​](5)

[ A i B i C i 1 ] ∗ [ 1 0 0 0 0 1 0 0 0 0 0 0 0 0 v 1 ] = [ A i B i v 1 ] ( 6 ) \begin{bmatrix}A_i&B_i&C_i&1\end{bmatrix}*\begin{bmatrix}1& 0&0&0\\0& 1&0&0\\0&0&0&0\\0&0&v&1\end{bmatrix}=\begin{bmatrix}A_i&B_i&v&1\end{bmatrix}(6) [Ai​​Bi​​Ci​​1​]∗⎣⎢⎢⎡​1000​0100​000v​0001​⎦⎥⎥⎤​=[Ai​​Bi​​v​1​](6)

总而言之，矩阵是一个复杂的，也是一个相对比较陌生的元素，可能用起来比较玄学，比较难以理解，但是如果能够分清何时使用矩阵优化、能够比较清晰地在矩阵上推导，那么矩阵运算会成为一种非常好的优化手段。
Thank you for reading！

Hanoist
关注
矩阵快速幂
Histranger_的博客
08-20 201
矩阵快速幂 快速幂 求 ana^nan. 显然，一种朴素的方法是：循环 nnn 次，将结果累乘，时间复杂度是 O(n)O(n)O(n) 。 可以考虑将 nnn 表示成二进制的形式： n=a0⋅20+a1⋅21+…an−1⋅2n−1+an⋅2n,ai∈{0,1}n = a_0\cdot 2^0 + a_1\cdot 2^1 + \ldots a_{n-1}\cdot 2^{n-1} + a_n\cdot 2^n, a_i\in\{0, 1\}n=a0​⋅20+a1​⋅21+…an−1​⋅2n−1+an​⋅2n
矩阵快速幂专题（三）
shengtao96的专栏
04-10 1064
哈哈哈，博主又回来了！这次专题是第三弹也是最后一弹了，这次会对矩阵进行一个小收尾。做完这25道题，我感觉到其实我矩阵学得并不好，还有许多知识点没有学会。后面看情况可能还会继续开矩阵的专题，那应该是几个月以后的事了。从下周开始，应该会先学习一下数论的相关算法！ 这次的七道题目（为什么题目越来越少了）主要是针对了矩阵的优化，对于会TLE的和MLE（内存爆了）的矩阵而且这个矩阵又恰好是同构矩阵（同构矩
快速幂、矩阵快速幂、快速乘法
aoniebu42564的博客
08-16 147
快速幂 快速幂是我们经常用到的一种算法，快速幂顾名思义就是快速的幂运算。我们在很多题目中都会遇到幂运算，但是在指数很大的时候，我们如果用for或者是pow就会超时，这时候就用到了快速幂。 快速幂的原理就是，当求b^p的时候，如果p是一个奇数，那么我们就可以把它拆成(b^2)^(p/2)*b，因此每次判断一下是直接乘还是拆开就可以了。 洛谷模板链接：https://www.luogu...
[poj3070]Fibonacci_矩乘_快速幂
weixin_30294021的博客
04-09 52
Fibonacci poj-3070 　　　　题目大意：求Fibonacci第n项。 　　　　注释：模数为10000，$1\le n \le 10^9$。 　　　　　　想法：矩阵题，用例题6的想法，我们构造矩阵 　　　　　　　　　　$\begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix}$ 　　　　　　　　然后，我们快速幂即可。 　　　...
矩阵快速幂优化的动态规划
Leo_h
04-12 2144
为了防止写错
矩阵快速幂总结
路途遥远，初心难忘，道阻且长，愿君走出半生，归来仍是少年
02-08 508
第一部分：矩阵的基础知识1.结合性 （AB)C=A(BC）．2.对加法的分配性 （A+B)C=AC+BC，C(A+B）=CA+CB ．3.对数乘的结合性 k(AB）=（kA)B =A(kB）．4.关于转置 (AB)'=B'A'．一个矩阵就是一个二维数组，为了方便声明多个矩阵，我们一般会将矩阵封装一个类或定义一个矩阵的结构体，我采用的是后者。第二部分：矩阵相乘矩阵相乘的规则：矩阵与矩阵相乘 第一个矩...
poj3070(利用矩阵快速幂加速递推式)
u013509299的专栏
08-27 1518
题意：求斐波拉契数的第n项，n 思路分析：暴力做肯定超时。这里有矩阵进行加速，很多递推的式子（DP）都可以转化成矩阵乘法来做。 递推式为F(n) = F(n-1) + F(n-2) , 对于一个 1*2 的矩阵[f(n-2),F(n-1)],右乘上一个2*2 的矩阵A得到 2*1 的矩[F(n),F(n-1)] = [F(n-1)+F(n-2),F[n-1] A矩阵为 1,1 1,0
【原创】矩阵乘法 矩阵快速幂 矩阵加速 矩阵优化dp
致上
10-22 385
矩阵 说在前面 数论复习…… 数论学习 Part 3。 矩阵乘法 举个例子就过。 所以结果是[123234]×[123456]=[22283140]\begin{bmatrix} 1 & 2 & 3 \\ 2 & 3 & 4\\ \end{bmatrix} \times \begin{bmatrix} 1 & 2 \\ 3&4\\5&6\e...
深度学习面经总结
qq7835144的博客
06-07 5070
文章目录1. 深度学习基础1.1 为什么需要做特征归一化、标准化？1.2 常用的归一化和标准化的方法有哪些？1.3 空洞卷积1.3.1 空洞卷积的作用1.3.2. 空洞卷积如何利用多尺度信息1.3.3 空洞卷积感受野计算1.3.4 潜在的问题及解决方法1.3.5 空洞卷积的替代2. 图像分类模型3.目标检测 参考链接 https://blog.csdn.net/qq_39056987/article/details/112157031?utm_medium=distribute.pc_relevant.no
吴恩达机器学习基础课程笔记
tjujackson的博客
03-06 931
吴恩达机器学习2022笔记
【日常学习】【数学】【矩阵乘法】【大数乘方取模】codevs1982 加密算法题解
西家家
11-02 1628
题目描述 Description Rivest是密码学专家。近日他正在研究一种数列E={E[1],E[2],……,E[n]}， 且E[1]=E[2]=p（p为一个质数），E[i]=E[i-2]*E[i-1] （若2 例如{2,2,4,8,32,256,8192,……}就是p=2的数列。在此基础上他又设计了一种加密 算法，该算法可以通过一个密钥q (q 算公式为：d=E[n] mod
一篇文章入门傅里叶变换
julac的博客
10-29 911
如果忽略表达倍数关系的系数，对应的含义也会发生变化，不再是质心，而是信号存在的时间越久，位置是质心位置乘以一个倍数，它的值就越大。按照上面的说明来记录绘出图像，记录每个缠绕频率（速度）对应的质心位置（在横坐标等于零点处有一个很大的值，只是因为原来的图像没有关于横轴对称，有一个偏移量）从最开始的 0.79圈/秒一直变化到1.55圈/秒，再到最后的恰好是3圈/秒，和原来的信号3次震荡/秒相同，此时会出现一个非常稳定的图像。我们可以看到，新图像的横坐标写的是频率（Frequency），即缠绕圆圈的速度。
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
krb5-devel-1.15.1-55.el7_9.i686.rpm
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh krb5-devel-1.15.1-55.el7_9.i686.rpm
基于Matlab实现Stanley算法项目源码（下载即用）高分项目
11-02
基于Matlab实现Stanley算法项目源码（下载即用）高分项目，本资源中的源码都是经过本地编译过可运行的，评审分达到98分，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、毕业设计、期末大作业和课程设计使用需求，如果有需要的话可以放心下载使用。 基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基
ruby-2.0.0.648-39.el7_9.x86_64.rpm
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh ruby-2.0.0.648-39.el7_9.x86_64.rpm
开题报告SpringBoot电子产品销售系统.docx
最新发布
11-02
毕业设计开题报告
快速幂和快速乘算法实现详解
资源摘要信息:"2024快速幂、快速乘算法(1).zip" 快速幂算法和快速乘算法是计算机科学中高效的数学运算方法。它们在算法竞赛、编程挑战和实际的软件开发中广泛应用，尤其是在需要大量重复的乘方或乘法运算的场景中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值