矩阵乘法-简记

最新推荐文章于 2026-04-14 15:37:09 发布
原创 最新推荐文章于 2026-04-14 15:37:09 发布 · 628 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#矩阵 #算法 #线性代数 #矩阵乘法 #c++
#编程 #DP优化

1.快速入门

洛谷B2105 矩阵乘法，看到题目，题目中已经告诉了我们矩阵乘法的基本操作，按照题目模拟即可

给出我的代码：

#include <bits/stdc++.h>
using namespace std;
int x[105][105];
int y[105][105];
int main(){
    int n,m,k;
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) cin >> x[i][j];
    for (int i = 1; i <= m; i++) for (int j = 1; j <= k; j++) cin >> y[i][j];
    for (int i = 1; i <= n; i++){
        for (int j = 1; j<= k; j++){
            int z = 0;
            for (int k = 1; k <= m; k++){//套公式
                z += x[i][k]*y[k][j];
            }
            cout << z << " ";
        }
        cout << "\n";
    }
    
    return 0;
}

z我咋没用数组存

2.矩阵快速幂

P3390 【模板】矩阵快速幂

还记得那个矩阵乘法的模板吗？只需将它套入快速幂的模板里即可。

但是这边细节比较多，本蒟蒻也不太会用类，给出一个比较浅显的代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int The_Boeing_757_is_the_best_aircraft_model_in_the_world = 1e9+7;
int n;
int x[104][104];
int a[104][104];
int y[104][104];
int z[104][104];
void m(){
    memset(z,0,sizeof(z));
    for (int i = 1; i <= n; i++){
        for (int j = 1; j<= n; j++){
            for (int k = 1; k <= n; k++){//套公式
                (z[i][j] += x[i][k]*y[k][j]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
            }
        }
    }
}
void boeing(){//转换函数
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= n; j++) x[i][j] = z[i][j];
    }
}
void airbus(){//转换函数
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= n; j++) y[i][j] = z[i][j];
    }
}
void fast(int k){//统一把这一次的乘积放x，方便之后处理
    if (k == 0){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++) x[i][j] = 0;
            x[i][i] = 1;
        }
        return ;
    }
    if (k == 1){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++) x[i][j] = a[i][j];
        }
        return ;
    }
    fast(k/2);
    for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) y[i][j] = x[i][j];
    m();
    airbus();
    fast(k%2);
    m();
    boeing();
}
signed main(){
    int k;
    cin >> n >> k;
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= n; j++){
            cin >> a[i][j];
            a[i][j] %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
        }
    }
    fast(k);
    for (int i = 1; i <= n; i++){ for (int j = 1; j <= n; j++) {cout << x[i][j] << " ";} cout << "\n";}
    return 0;
}

不要管我的变量名和函数名啊

总体而言，在细节处理时：我将每一次的结果存在x里，这样方便统计。

举个例子：

我们在计算矩阵的k次方。

先调用函数算出\lfloork/2\rfloor次方的矩阵，存在x里。

复制一份，放到y里

用m函数计算出x*y的值——也就是矩阵的\lfloork/2\rfloor*\lfloork/2\rfloor次方，存放到z里

当然如果k是奇数，那么还要再乘一遍

统一再乘一遍

那么将z中的转移到y

然后调用fast(k%2)

再（用m函数）乘

再将z中的转移到x里存放

感觉总体还是比较简单的，至少跟用类的对比

这样的模板就写好了，思路不难，就是细节有点多

3.简单的优化

那么好问题，我们学了矩阵乘法该怎么用呢？

请看入门题目——P1962 斐波那契数列 - 洛谷

对于60%的数据用普通DP即可，以下是转移方程：

dp[i] = dp[i-1]+dp[i-2]

只看60%的数据，实现就是个普及-，可是当n<2^{63}时，O(n)的时间复杂度不再能支撑

此时就要用到矩阵乘法优化了！

如何构建？
1.写出递推：
此题为：f[n] = f[n-1]+f[n-2]
2.构建矩阵
先放dp[i]、再看dp[i]要哪些转移过来、再看dp[i]要哪些转移过来的要要哪些转移过来...
此题为：
dp[i]
dp[i-1]
3.考虑次方矩阵
转移为dp[i]从以的dp[i-1]为第一项的转来
为了方便描述，以的dp[i]为第一项称为A（矩阵）,以的dp[i-1]为第一项称为B（矩阵）
对于次方矩阵C（叫做C）第i行代表A[i] = ∑[在列j] B[j] * C[i][j]
靠递推转移方程进行构建C，以及对于入门\正常的矩阵乘法优化A与B一般是一列，所以在我的表达式里A[i][1]=>(写为)A[i],其他同理
此题为：
1 1（dp[i] = dp[i-1]*1+dp[i-2]*1）
1 0（dp[i-1] = dp[i-1]*1+dp[i-2]*0）

注意再乘 确定的前几项 即可：

代码是在模板上稍加修改的：

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int The_Boeing_757_is_the_best_aircraft_model_in_the_world = 1e9+7;
int n;
int x[104][104];
int a[104][104];
int y[104][104];
int z[104][104];
void m(){
    memset(z,0,sizeof(z));
    for (int i = 1; i <= n; i++) for (int j = 1; j<= n; j++) for (int k = 1; k <= n; k++)(z[i][j] += x[i][k]*y[k][j]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
}
void boeing(){ for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) x[i][j] = z[i][j];}
void airbus(){for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) y[i][j] = z[i][j];}
void fast(int k){//统一把这一次的乘积放x，方便之后处理
    if (k == 0){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){ x[i][j] = 0;}x[i][i] = 1;}
        return ;
    }
    if (k == 1){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++) x[i][j] = a[i][j];}
        return ;
    }
    fast(k/2);
    for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) y[i][j] = x[i][j];
    m();
    airbus();
    fast(k%2);
    m();
    boeing();
}
signed main(){
    int k;
    cin >> k;
    if (k < 2){ cout << 1;return 0;}
    n = 2;
    a[1][1] = 1;
    a[1][2] = 1;
    a[2][1] = 1;
    fast(k-2);//我们以第三项来举例:第三项只是*了一次就可以得到,所以是N减二
    memset(y,0,sizeof y);
    y[1][1] = 1;
    y[2][1] = 1;
    int ans = 0;
    for (int k = 1; k <= 2; k++) (ans += x[1][k]*y[k][1]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
    cout << ans;
    return 0;
}

4.习题

P1939 矩阵加速（数列） - 洛谷

P1349 广义斐波那契数列 - 洛谷

都是比较简单的思路，与P1962 斐波那契数列思路都差不多

以下是我的解题思路：

P1939:

状态：
dp[i]
dp[i-1]
dp[i-2]
想求dp[i]就要从第一位为dp[i-1]更新来
记住！a*b是用a的一行*b的一列
轻松得出：
1(让第一位0 +dp[i-1]) 0 1(让第一位0+dp[i-1] +dp[i-3])
1(让第2位0 +dp[i-1]) 0 0
0 1(让第3位0 +dp[i-2]) 0

代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int The_Boeing_757_is_the_best_aircraft_model_in_the_world = 1e9+7;
int n;
int x[104][104];
int a[104][104];
int y[104][104];
int z[104][104];
void m(){
    memset(z,0,sizeof(z));
    for (int i = 1; i <= n; i++) for (int j = 1; j<= n; j++) for (int k = 1; k <= n; k++)(z[i][j] += x[i][k]*y[k][j]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
}
void boeing(){ for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) x[i][j] = z[i][j];}
void airbus(){for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) y[i][j] = z[i][j];}
void fast(int k){//统一把这一次的乘积放x，方便之后处理
    if (k == 0){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){ x[i][j] = 0;}x[i][i] = 1;}
        return ;
    }
    if (k == 1){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++) x[i][j] = a[i][j];}
        return ;
    }
    fast(k/2);
    for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) y[i][j] = x[i][j];
    m();
    airbus();
    fast(k%2);
    m();
    boeing();
}
signed main(){
    int t;
    cin >> t;
    while (t--){
        int k;
        cin >> k;
        if (k <= 3){ cout << "1\n";continue;}
        n = 3;
        a[1][1] = 1;
        a[1][3] = 1;
        a[2][1] = 1;
        a[3][2] = 1;
        fast(k-3);//注意减3
        memset(y,0,sizeof y);
        y[1][1] = 1;
        y[2][1] = 1;
        y[3][1] = 1;
        int ans = 0;
        for (int k = 1; k <= 3; k++) (ans += x[1][k]*y[k][1]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
        cout << ans << "\n";
    }
    return 0;
}

P1349:

其实就是把系数改一下就行：

#include <bits/stdc++.h>
using namespace std;
#define int long long
int The_Boeing_757_is_the_best_aircraft_model_in_the_world;
int n;
int x[104][104];
int a[104][104];
int y[104][104];
int z[104][104];
int k,p,q,a1,a2;
void m(){
    memset(z,0,sizeof(z));
    for (int i = 1; i <= n; i++) for (int j = 1; j<= n; j++) for (int k = 1; k <= n; k++)(z[i][j] += x[i][k]*y[k][j]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
}
void boeing(){ for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) x[i][j] = z[i][j];}
void airbus(){for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++) y[i][j] = z[i][j];}
void fast(int k){//统一把这一次的乘积放x，方便之后处理
    if (k == 0){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){ x[i][j] = 0;}x[i][i] = 1;}
        return ;
    }
    if (k == 1){
        for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++) x[i][j] = a[i][j];}
        return ;
    }
    fast(k/2);
    for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) y[i][j] = x[i][j];
    m();
    airbus();
    fast(k%2);
    m();
    boeing();
}
signed main(){
    cin >> p >> q >> a1 >> a2 >> k >> The_Boeing_757_is_the_best_aircraft_model_in_the_world;
    if (k == 1) {cout << a1; return 0;}
    if (k == 2) {cout << a2; return 0;}
    n = 2;
    a[1][1] = p;
    a[1][2] = q;
    a[2][1] = 1;
    fast(k-2);//和那个斐波那契数列同理
    memset(y,0,sizeof y);
    y[1][1] = a2;//别搞反了
    y[2][1] = a1;
    int ans = 0;
    for (int k = 1; k <= 2; k++) (ans += x[1][k]*y[k][1]) %= The_Boeing_757_is_the_best_aircraft_model_in_the_world;
    cout << ans;
    return 0;
}

希望大家能把这5倍经验接好了：

广义斐波那契数列

斐波那契数列

矩阵加速（数列）

【模板】矩阵快速幂

矩阵乘法

OK啊今天就到这里了，希望大家已经大致的了解了矩阵乘法的作用！

B757-300
关注
人工智能： 矩阵乘法从基础到实战
AI Agent 首席体验官
02-17 2426
通过这些内容，我们可以看到矩阵乘法是线性代数中一个非常基础但重要的运算，在实际应用中有着广泛的用途。掌握矩阵乘法的规则和性质，对理解更复杂的数学概念和解决实际问题都很有帮助。通过这个案例，我们可以看到矩阵乘法在推荐系统中的重要应用，以及如何处理大规模稀疏数据的挑战。特别是在处理用户-物品交互数据时，矩阵运算提供了高效且可扩展的解决方案。在处理大规模医疗图像时，特别要注意数值精度和性能优化。在实际应用中，应根据具体问题选择合适的计算方法和优化策略。15. 矩阵乘法在图像处理中的实际应用。
带你深入理解矩阵乘法
zh_94的博客
08-11 8万+
为了不浪费大家宝贵的时间，开头我先简要说明一下这篇博文对哪些读者可能会有帮助 1、你是正在学习矩阵的乘法运算，觉得矩阵的乘法掌握起来很困难 2、你已经学会了矩阵乘法，但如果你在计算矩阵乘法时还在使用“一行乘一列得一数”的方法，那我强烈建议你看看后面的内容。 因为，我将带你更加深刻地理解矩阵，与之而来是对矩阵乘法的全新计算方式。这不仅让你在计算矩阵乘法时更快，而且更省心。 “矩阵就是数...
矩阵的乘法
热门推荐
二哈
09-03 59万+
1. 有两个矩阵：A和B（矩阵实际上就是二维数组） A矩阵和B矩阵可以做乘法运算必须满足A矩阵的列的数量等于B矩阵的行的数量 运算规则：A的每一行中的数字对应乘以B的每一列的数字把结果相加起来 矩阵乘法的结果为行与列的关系为：行数量为A的行数量， 列数量为B的列数量 2. 因为每一次都是A的行与B的列，所以最外层的两层循环可以使用A的行的数量的变化，B的列的数量进行变化 而...
算法详解：矩阵连乘问题（动态规划 C++ 完整实现）
最新发布
W2303576573的博客
04-14 969
m[i][j]：计算矩阵 ～ 连乘的最小乘法次数s[i][j]：记录 ～ 的最优分割位置 k（用于回溯输出加括号方案）矩阵连乘是动态规划入门必做题，核心是状态定义 + 状态转移 + 填表两个关键表：m[i][j]：存储最小乘法次数s[i][j]：存储最优分割点迭代实现效率更高，递归实现更易理解回溯函数可以输出最优计算顺序，完整解决问题。
矩阵的基本运算
有的话没说出来之前，你是他的主人，一旦说出来你就成了他的奴隶||想要干好事，别太把自己当人，别把别人太不当人||认识这个人就是开了一扇窗户，就能看到不一样的东西，听到不一样的声音，能让你思考、觉悟，这已经够了
04-28 29万+
矩阵的运算举例一、矩阵加法二、矩阵减法三、矩阵乘法四、矩阵转置五、逆矩阵六、对称矩阵七、矩阵性质总结 举例 a=[abcd](1) a= \left[ \begin{matrix} a & b \\ c & d \\ \end{matrix} \right] \tag{1} a=[ac​bd​](1) b=[a1a2b1b2](2) b= \lef
线性代数--矩阵基本计算（加减乘法）
qq_51216031的博客
11-27 10万+
对线性代数的矩阵的运算有详细的总结，来源于B站宋浩的视频所作的学习笔记。
【详解】矩阵乘法
_BOSS_的博客
07-14 5万+
矩阵乘法 矩阵 一个 m×nm\times nm×n 的矩阵就是
numpy矩阵乘法_NumPy矩阵乘法
从零开始的教程世界
07-12 3万+
numpy 矩阵乘法NumPy matrix multiplication can be done by the following three methods. NumPy矩阵乘法可以通过以下三种方法完成。 multiply(): element-wise matrix multiplication. multiple（）：逐元素矩阵乘法。 matmul(): matrix product o...
矩阵乘法总结
BigZong
05-09 2万+
矩阵是数的排列 矩阵 （这矩阵有2行和3列） 把矩阵与一个数相乘是容易的： 计算是这样的： 2×4=8 2×0=0 2×1=2 2×-9=-18 我们叫这个数 （"2"）为标量，所以这乘法被称为"标量乘法". 矩阵与矩阵相乘 但若要把矩阵与矩阵相乘，我们要计算行与列的"点积"……这是什么意思？我们来看个例子： 求第一行和第一列的答案： "点积...
python矩阵乘法_Python矩阵乘法
culing2941的博客
09-16 3361
python矩阵乘法Here you will get program for python matrix multiplication. 在这里，您将获得用于python矩阵乘法的程序。 If we want to multiple two matrices then it should satisfy one condition. We need to check this conditi...
矩阵乘法（矩阵乘矩阵）
Rudy1124的博客
07-27 2万+
首先理了解矩阵是什么:矩阵是一个按照长方阵列排列的复数或实数集合。（相信大家都懂）关于矩阵的基本概念：1.方阵：n 阶方阵 （正方形嘛）2.同型矩阵：两个矩阵，行数与列数对应相同，称为同型矩阵。
Strassen矩阵乘法——C++
stu_kk的博客
04-28 2078
基于分治法的矩阵快速乘法---C++实现
矩阵系列：矩阵乘法
u012938458的博客
07-10 4518
上一篇说到一个基本的小知识点浮点到定点的转换，这一篇来说说矩阵乘法。矩阵乘法和下一篇要说的矩阵LU分解是矩阵求逆的重要组成部分，所以就算大家不需要做矩阵求逆，对其先有个整体的认识也是好的。（矩阵求逆的整体框图还是很好理解的 ，甚至你只要瞟一眼图就好）。 1矩阵求逆的整体框图 矩阵求逆的步骤如下： 1.原始矩阵A通过LU分解为上三角矩阵L与单位下三角矩阵U。 2.分别通过三角矩阵的求逆运算得到L逆和U逆。 3.最后通过矩阵乘法得到A逆。 显而易见，矩阵求逆由如下三个部分组成： 1.LU矩阵分解 2.三角矩阵
矩阵乘法的一些应用
路人黑的纸巾
09-18 1万+
矩阵 定义很重要 矩阵的计算 矩阵的线性运算 矩阵加 矩阵减 数乘矩阵 其他操作计算 转置 共轭 共轭转置 矩阵乘法 例题 例题1斐波那契数列 problem 构造矩阵式 矩阵快速幂code 矩阵乘法code code 例题2JZOJsenior1240Fibonacci sequence problem analysis code 例题3NOI2012随机数生成器 problem 构造矩阵式 快速
矩阵乘法的介绍
2202_75335340的博客
10-10 3572
矩阵乘法是线性代数中的一个基本运算，它定义了两个矩阵之间如何相乘。给定两个矩阵A和B，如果A的列数等于B的行数，那么这两个矩阵就可以相乘。结果矩阵C的元素由A的第i行和B的第 j列的对应元素的点积（内积）计算得出。
Strassen矩阵乘法
wulisheng11的博客
06-06 1667
设Aaij​Bbij​是n×n的方阵，则对ij12...n，定义A和B的乘积矩阵C中元素cij​如下cij​k1∑n​aik​⋅bkj​按照定义来计算，我们需要计算n^2个矩阵元素，每个元素是n个值的和(从k=1到n)，也就是说，要每计算一个C矩阵的元素，就要进行n次乘法和n-1次加法。显然依照定义来计算的时间复杂度将达到O(n^3)。
4 Numpy------矩阵(矩阵和向量、加法和标量乘法、矩阵向量乘法、矩阵乘法、矩阵乘法的性质、逆、转置、矩阵运算)
程序猿-凡白的博客
07-07 3490
文章目录4.6数学:矩阵学习目标.1矩阵和向量1.1矩阵1.2向量2加法和标量乘法3 矩阵向量乘法4 矩阵乘法 4.6数学:矩阵 学习目标. 知道什么是矩阵和向量 知道矩阵的加法,乘法 知道矩阵的逆和转置 应用np.matmul、np.dot实现矩阵运算 1矩阵和向量 1.1矩阵 矩阵,英文matrix,和array的区别矩阵必须是2维的,但是array可以是多维的. 如图:这个是3x2矩阵,即3行2列,如m为行,n为列,那么mxn即3x2矩阵的维数即行数x列数 矩阵元素(矩阵项): Aij指第i行
2.7 矩阵分块及矩阵乘法的四种方式
jhshanvip的博客
03-20 2万+
矩阵分块 为了简化矩阵运算或从不同角度看矩阵乘法，把矩阵分成多块，每块是子矩阵，子矩阵可“看作”一个数，只要满足形状要求，就可进行形式上的矩阵运算。 矩阵乘法实质就是矩阵乘以向量，把向量看成列向量，矩阵乘以向量就是矩阵乘以矩阵，以这个最基础构建来说明矩阵分块运算。矩阵乘以向量是向量组的线性组合，必须从这个根源说起！ Ax=x1a1+⋯+xnan=(x1a1+⋯+xkak)+(xk+1ak+1+⋯+...
『PyTorch』矩阵乘法总结
七秒钟的记忆
05-24 2006
PyTorch中张量乘法的一些总结
矩阵乘法
顺其自然~专栏
02-16 1万+
矩阵乘法（Matrix multiplication）最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。由于它把许多数据紧凑的集中到了一起，所以有时候可以简便地表示一些复杂的模型。 定义 设A为  的矩阵，B为  的矩阵，那么称  的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值