乘法矩阵几个常用法和注意点

最新推荐文章于 2024-06-15 11:14:29 发布
最新推荐文章于 2024-06-15 11:14:29 发布
阅读量833 收藏
点赞数
文章标签： 矩阵乘法 快速幂 递推优化 斐波那契数列 算法效率
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53688600/article/details/115421076
版权

阅读前请先掌握矩阵乘法的运算规则（自行百度

从易到难，从题目中学习

矩阵快速幂（模板）

先掌握矩阵乘法，以及快速幂的写法

乘法，三层for循环，按照矩阵乘法规则写就行，快速幂就是普通快速幂板子

注意点：快速幂里，ans需要先定义为单位矩阵,结构体里二维数组需要初始化

矩阵左乘，不具有交换律 base * ans  !=  ans * base 

 

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define _for(i,s,b) for(int i=(s) ;i<=(b) ;i++)
#define _rep(i,s,b) for(int i=(s) ;i>=(b) ;i--)
#define mst(x,y) memset(x,y,sizeof(x))
#define all(v) v.begin() , v.end()
#define pb(v) push_back(v)
#define INF 0x3f3f3f3f
#define int long long
#define lson p*2,l,mid
#define rson p*2+1,mid+1,r
typedef long long ll;
int n,k;

const int N =105;
const int md = 1e9+7;
struct matrix
{
    ll a[N][N]={0};
    matrix operator * ( matrix &b)//重定义矩阵乘法
    {
        matrix d;
        _for(i,1,n)
        {
            _for(j,1,n)
            {
                _for(k,1,n)
                {
                  d.a[i][j] = (d.a[i][j] + a[i][k] * b.a[k][j]%md ) %md;
                }
            }
        }
        return d;
    }
};
matrix qsm(matrix a,int k)//矩阵快速幂
{
    matrix ans, temp=a;
    mst(ans.a,0);
    _for(i,1,n) ans.a[i][i] = 1;//建造单位矩阵
    while( k )
    {
        if( k & 1) ans = (ans * temp ) ;
        temp = ( temp * temp );
        k>>=1;
    }
    return ans;
}
signed main()
{
    matrix x,y,z;
    cin>>n>>k;//输入n*n矩阵，k次幂
    _for(i,1,n)
    _for(j,1,n) cin>>x.a[i][j];

    x= qsm(x,k);
    _for(i,1,n)
    {
        _for(j,1,n)
        cout<<x.a[i][j]<<" ";
        cout<<endl;
    }
    return 0;
}

矩阵加速

一般用于递推式里，不需要一项一项推，只要知道函数关系式，推出矩阵然后矩阵快速幂一下就行，O(N)变O(logn)；

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define _for(i,s,b) for(int i=(s) ;i<=(b) ;i++)
#define _rep(i,s,b) for(int i=(s) ;i>=(b) ;i--)
#define mst(x,y) memset(x,y,sizeof(x))
#define all(v) v.begin() , v.end()
#define pb(v) push_back(v)
#define INF 0x3f3f3f3f
#define int long long
#define lson p*2,l,mid
#define rson p*2+1,mid+1,r
typedef long long ll;
int n=3;

const int N =105;
const int md = 1e9+7;
struct matrix
{
    ll a[N][N]={0};
    matrix operator * ( matrix &b)//重定义矩阵乘法
    {
        matrix d;
        mst(d.a,0);//记得初始化
        _for(i,1,n)
        {
            _for(j,1,n)
            {
                _for(k,1,n)
                {
                  d.a[i][j] = (d.a[i][j] + a[i][k] * b.a[k][j]%md ) %md;
                }
            }
        }
        return d;
    }
}ans,base;
matrix qsm(matrix a,int k)//矩阵快速幂
{
    matrix ans, temp=a;
    mst(ans.a,0);
    _for(i,1,n) ans.a[i][i] = 1;//建造单位矩阵
    while( k )
    {
        if( k & 1) ans = (ans * temp ) ;
        temp = ( temp * temp );
        k>>=1;
    }
    return ans;
}
signed main()
{
    IOS;
    int T;
    cin>>T;

    while( T-- )
    {
        mst(base.a,0);
        base.a[1][1]=1;
        base.a[1][3]=1;
        base.a[2][1]=1;
        base.a[3][2]=1;
        mst(ans.a,0);
        _for(i,1,3) ans.a[i][1]=1;

        int x;
        cin>>x;
        if( x<=3 )  {cout<<1<<endl;continue;}
        base = qsm(base,x-3);
        ans = base * ans ;//注意矩阵左乘，不具有交换律

        cout<<ans.a[1][1]<<endl;
    }
}

斐波那契数列

会了矩阵加速，来个入门实战，用这个方法推肥波就很舒服了。

相比于直接递推，矩阵加速节省了内存，减少了时间，可谓利器，用递推的话，这题铁re


#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define _for(i,a,b) for(int i=(a) ;i<=(b) ;i++)
#define _rep(i,a,b) for(int i=(a) ;i>=(b) ;i--)
#define mst(x,y) memset(x,y,sizeof(x))
#define all(v) v.begin() , v.end()
#define pb(v) push_back(v)
#define INF 0x3f3f3f3f
#define int long long
#define lson p*2,l,mid
#define rson p*2+1,mid+1,r
typedef long long ll;
const int N = 3;
const int mod = 1e9+7;
int n;
struct mat
{
    ll a[N][N]={0};
    mat operator * (const mat & b)
    {
        mat res;
        _for(i,1,2)
        {
            _for(j,1,2)
            {
                _for(k,1,2)
                {
                    res.a[i][j] = (res.a[i][j] + a[i][k] * b.a[k][j]%mod)%mod;
                }
            }
        }
        return res;
    }
}ans,base;
mat qsm(mat a, ll k)
{
    mat ans , temp = a;
    mst(ans.a,0);
    _for(i,1,3) ans.a[i][i] =1;
    while( k )
    {
        if( k & 1) ans = ans * temp ;
        temp = temp * temp ;
        k>>=1;
    }
    return ans;
}
signed main()
{
    //!!!!!!!!!!!!!!!!!!!!!!
//    freopen("data.txt","r",stdin);
    //!!!!!!!!!!!!!!!!!!!!!!
    IOS;
    mst(base.a,0);
    mst(ans.a,0);
    base.a[1][1]=1;
    base.a[1][2]=1;
    base.a[2][1]=1;
    ans.a[1][1]=1;
    ans.a[2][1]=1;
    cin>>n;
    if( n<=2 )
    {
        cout<<1<<endl;
        return 0;
    }
    base = qsm(base , n-1);
    ans = ans * base;
    cout<<ans.a[1][1]<<endl;
}

群鸡乱舞

思路：dp,矩阵乘优化（为了学个矩阵乘溯源两天

dp[i][j]表示第i年年龄为j的小鸡的数量

转移方程

j=0   dp[i][0] = \sum_{k=1}^{t-2} dp[i-1][k] 今年出生的小鸡是去年1 ~ t-2 的小鸡数量

j!=0  dp[i][j] = dp[i-1][j-1]今年j岁的小鸡数量等于去年j-1岁的小鸡数量

做到这里只能过45%，后面会tle，考虑矩阵加速一下

推一下矩阵式，设t=4，也就是小鸡年龄在[0,3]间，设初始小鸡的年龄矩阵为（这里设为1列矩阵）

\begin{bmatrix} x\\ y\\ z\\ a\\ \end{bmatrix} x,y,z,a分别对应年龄为0,1,2,3的小鸡数量,推下一年的年龄矩阵为

\begin{bmatrix} sum\\ x\\ y\\ z\\ \end{bmatrix}sum = x + y +  z 

从而推得递推矩阵

\begin{pmatrix} &0 &1 &1 &0 \\ &1 &0 &0 &0 \\ &0 &1 &0 &0 \\ &0 &0 &1 &0 \\ \end{pmatrix}

 

//dp,矩阵乘
#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define _for(i,a,b) for(int i=(a) ;i<=(b) ;i++)
#define _rep(i,a,b) for(int i=(a) ;i>=(b) ;i--)
#define mst(x,y) memset(x,y,sizeof(x))
#define all(v) v.begin() , v.end()
#define pb(v) push_back(v)
#define INF 0x3f3f3f3f
#define int long long
#define lson p*2,l,mid
#define rson p*2+1,mid+1,r
#define int long long
typedef long long ll;
const int N = 75;
int mod;
int n,m,t;
struct mat
{
    ll a[N][N]={0};
    mat operator * (const mat & b)
    {
        mat res;
        _for(i,0,t)
        {
            _for(j,0,t)
            {
                _for(k,0,t)
                {
                    res.a[i][j] = (res.a[i][j] + a[i][k] * b.a[k][j]%mod)%mod;
                }
            }
        }
        return res;
    }
}ans,base;
mat qsm(mat a, ll k)
{
    mat ans , temp = a;
    mst(ans.a,0);
    _for(i,0,t-1) ans.a[i][i] =1;
    while( k )
    {
        if( k & 1) ans = ans * temp ;
        temp = temp * temp ;
        k>>=1;
    }
    return ans;
}
ll gcd(ll a, ll b)
{
    return b==0?a:gcd(b,a%b);
}
signed main()
{
    //!!!!!!!!!!!!!!!!!!!!!!
//    freopen("data.txt","r",stdin);
    //!!!!!!!!!!!!!!!!!!!!!!
    IOS;
    cin>>n;
    _for(i,1,n)
    {
        int x;
        cin>>x;
        ans.a[x][0]++;
    }
    cin>>t>>m>>mod;
    //ini
    _for(i,1,t-1)
    {
        base.a[i][i-1]=1;
    }
    _for(i,1,t-2)
    {
        base.a[0][i] = 1;
    }
    base = qsm( base , m-1);
    ans = base * ans;
    ll res = 0;
    _for(i,0,t-1)
    {
        res = (res + ans.a[i][0])%mod;
    }
    cout<<res<<endl;
}

 

吃花椒的妙酱
关注
矩阵乘法（加快速幂）
劭星の博客
11-10 343
参考文献：《算法导论》、dalao的blog 我真的觉得本篇良心，大大干货 引言： 题目： 斐波那契数列很喜欢被研究，其前几项为：1 1 2 3 5 8 13 …… 则，求斐波那契数列的第n项是？ 解法： 1.朴素求解： 由斐波那契数列的定义，可以由递推求解 f(1)=1,f(2)=1 f(n)=f(n-1)+f(n-2) (n>=3) f[1]=f[2]=1;...
线性代数笔记——矩阵乘法的四种理解方法
weixin_30726161的博客
07-12 2356
设矩阵A:m*p，矩阵B：p*n。A*B得到C矩阵m*n。 一、常规方法　（行*列） 　　(行向量Ai)点乘(列向量Bj) =数Cij 　　C矩阵可以看成若干个这样的点乘结果的拼接 eg: 　　a1　　a2　　　x　　b1　　b2　　=　[　[a1,a2]·[b1,b3]　　[a1,a2]·[b2,b4] 　　a3　　a4　　　　　 b3　　b4　　　　 [a3,a4]·[b1,...
矩阵乘法三种方法（蛮力法、分治法、strassen）
XXXX的博客
03-27 4467
package algorithms; public class strassen { //创建一个随机数构成的nxn矩阵 public static int[][] initializationMatrix(int n){ int[][] result = new int[n][n];//创建一个nxn矩阵 for(int i = 0;i &l...
2.2 矩阵基本运算
最新发布
tang7mj的博客
06-15 1235
本节介绍矩阵的线性运算和乘积运算，它们是矩阵的基本运算。正是这些基本运算的引入，才使矩阵在有序表达和描述有关对象这一基本作用的基础上，成为研究有关对象之间相互联系的有力工具，进而成为具有重要理论意义和实际应用价值的核心数学概念。
c语言乘法注意事项,矩阵乘法 （C语言代码）
weixin_42299472的博客
05-17 187
解题思路:注意事项:本题主要考察线性代数的知识。注意一些特殊情况。参考代码:#includeint juzheng[3][30][30];int n;int js(int i,int j,int a){int k,b=0;for(k=0;k{b+=juzheng[a][i][k]*juzheng[2][k][j];}return b;}void main(){int m,a,b=2,i,j,f;s...
矩阵乘法
.
03-13 493
#include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;cmath&gt; using namespace std; const int Max = 100; int A[Max][Max],B[Max][Max],C[Max][Max]; int main() { ...
Python实现矩阵加法和乘法的方法分析
09-20
### Python实现矩阵加法和乘法的方法分析 在Python中处理矩阵运算时，通常我们会借助于内置的数据结构如列表（list）来表示矩阵，并通过编写特定的函数来完成加法和乘法等基本运算。本篇文章将深入探讨如何在Python...
Python中的几种矩阵乘法（小结）
09-19
本文将深入探讨两种主要的矩阵乘法方法：`np.dot()` 和 `np.multiply()` 或者使用星号 `*` 进行元素级乘法。 首先，让我们详细了解 `np.dot()` 函数。这个函数遵循线性代数中的矩阵乘法规则。`np.dot(A, B)` 用于...
zhuanzhi.rar_矩阵乘法_矩阵乘法优化_矩阵优化 c
09-14
在IT领域，尤其是在高性能计算和科学计算中，矩阵乘法是一项至关重要的操作。"zhuanzhi.rar"压缩包文件提供了关于矩阵乘法优化的C语言实现，这对于我们理解和提升计算效率具有重大意义。 矩阵乘法是线性代数中的...
C中实现矩阵乘法的一种高效的方法
09-05
在现代处理器中，访问L1缓存可能只需要几个时钟周期，L2缓存大约需要十几个时钟周期，而访问主内存可能需要上百个时钟周期。因此，优化缓存使用对程序性能至关重要。在编写代码时，理解这些底层原理并根据它们调整...
Desktop_C++_算法导论_矩阵乘法_递归_
10-03
总的来说，这个项目涵盖了以下几个核心知识点： 1. C++编程基础：包括变量声明、函数定义、内存管理和异常处理。 2. 算法设计：递归思想和分治策略的应用，用于优化矩阵乘法运算。 3. 数据结构：矩阵作为二维数组的...
矩阵的乘法
风一样的少年
06-24 9577
矩阵的乘法
C语言实现4096阶矩阵乘法与性能测试
程序的主要部分包括以下几个关键步骤： 1. **包含头文件**：`#include<time.h>` 用于获取当前时间，计算运行时间；`#include<stdio.h>` 提供输入输出功能；`#include<stdlib.h>` 包含随机数生成所需的函数；`#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值