矩阵运算（加，减，乘，除，快速幂）

最新推荐文章于 2023-02-19 19:36:04 发布
最新推荐文章于 2023-02-19 19:36:04 发布
阅读量874 收藏 1
点赞数
分类专栏： 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanghuaqings/article/details/47187129
版权


矩阵运算

矩阵运算：

/**=========================================
    矩阵运算
    复杂度：O(N^3)
=========================================*/
const int maxn = 105;
const int maxm = 105;
struct Matrix
{
    int n, m;
    int a[maxn][maxm];
    void clear()
    {
        n = m = 0;
        memset(a, 0, sizeof(a));
    }
    Matrix operator + (const Matrix &b) const
    {
        Matrix tmp;
        tmp.n = n;
        tmp.m = m;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                tmp.a[i][j] = a[i][j] + b.a[i][j];
        return tmp;
    }
    Matrix operator - (const Matrix &b) const
    {
        Matrix tmp;
        tmp.n = n;
        tmp.m = m;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                tmp.a[i][j] = a[i][j] - b.a[i][j];
        return tmp;
    }
    Matrix operator * (const Matrix &b) const
    {
        Matrix tmp;
        tmp.clear();
        tmp.n = n;
        tmp.m = b.m;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < b.m; j++)
                for (int k = 0; k < m; k++)
                    tmp.a[i][j] += a[i][k] * b.a[k][j];
        return tmp;
    }
};


矩阵加法

对应位置相加。（等行等列）

代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <sstream>
#include <fstream>
#include <limits.h>
#define debug "output for debug\n"
#define pi (acos(-1.0))
#define eps (1e-6)
#define inf (1<<28)
#define sqr(x) (x) * (x)
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef unsigned long long ULL;
const int MAX=105;
struct Matrix
{
    int n,m;
    int a[MAX][MAX];
    void clear()
    {
        n=m=0;
        memset(a,0,sizeof(a));
    }
};
Matrix operator +(Matrix a,Matrix b)
{
    Matrix c;
    c.clear();
    c.n=a.n;
    c.m=a.m;
    for(int i=0;i<a.n;i++)
    {
        for(int j=0;j<a.m;j++)
        {
            c.a[i][j]=a.a[i][j]+b.a[i][j];
        }
    }
    return c;
}
int main()
{
    int i,j,k,n1,m1;
    Matrix a,b,c;
    printf("输入矩阵的行(n)列(m):\n");
    scanf("%d%d",&n1,&m1);
    a.n=n1;a.m=m1;
    b.n=n1;b.m=m1;
    printf("输入矩阵a:\n");
    for(i=0;i<a.n;i++)
    {
        for(j=0;j<a.m;j++)
            scanf("%d",&a.a[i][j]);
    }
    printf("输入矩阵b:\n");
    for(i=0;i<b.n;i++)
    {
        for(j=0;j<b.m;j++)
            scanf("%d",&b.a[i][j]);
    }
    c=a+b;
    printf("矩阵a+b的和:\n");
    for(i=0;i<c.m;i++)
    {
        for(j=0;j<c.m;j++)
            printf("%d ",c.a[i][j]);
        printf("\n");
    }
    return 0;
}




矩阵减法

对应位置相减（等行等列）

代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <sstream>
#include <fstream>
#include <limits.h>
#define debug "output for debug\n"
#define pi (acos(-1.0))
#define eps (1e-6)
#define inf (1<<28)
#define sqr(x) (x) * (x)
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef unsigned long long ULL;
const int MAX=105;
struct Matrix
{
    int n,m;
    int a[MAX][MAX];
    void clear()
    {
        n=m=0;
        memset(a,0,sizeof(a));
    }
};
Matrix operator -(Matrix a,Matrix b)
{
    Matrix c;
    c.clear();
    c.n=a.n;
    c.m=a.m;
    for(int i=0;i<a.n;i++)
    {
        for(int j=0;j<a.m;j++)
        {
            c.a[i][j]=a.a[i][j]-b.a[i][j];
        }
    }
    return c;
}
int main()
{
    int i,j,k,n1,m1;
    Matrix a,b,c;
    printf("输入矩阵的行(n)列(m):\n");
    scanf("%d%d",&n1,&m1);
    a.n=n1;a.m=m1;
    b.n=n1;b.m=m1;
    printf("输入矩阵a:\n");
    for(i=0;i<a.n;i++)
    {
        for(j=0;j<a.m;j++)
            scanf("%d",&a.a[i][j]);
    }
    printf("输入矩阵b:\n");
    for(i=0;i<b.n;i++)
    {
        for(j=0;j<b.m;j++)
            scanf("%d",&b.a[i][j]);
    }
    c=a-b;
    printf("矩阵a-b的差:\n");
    for(i=0;i<c.m;i++)
    {
        for(j=0;j<c.m;j++)
            printf("%d ",c.a[i][j]);
        printf("\n");
    }
    return 0;
}

/*
4 4
1 2 3 4
4 3 2 1
4 3 2 1
1 2 3 4
1 2 3 4
4 3 2 1
4 3 2 1
1 2 3 4
*/




矩阵乘法

若一矩阵的列数与另一矩阵的行数相等，则可定义这两个矩阵的乘积。如 A 是 m×n 矩阵和 B 是 n×p矩阵，它们的乘积 AB 是一个 m×p 矩阵。

代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <sstream>
#include <fstream>
#include <limits.h>
#define debug "output for debug\n"
#define pi (acos(-1.0))
#define eps (1e-6)
#define inf (1<<28)
#define sqr(x) (x) * (x)
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef unsigned long long ULL;
const int MAX=105;
struct Matrix
{
    int n,m;
    int a[MAX][MAX];
    void clear()
    {
        n=m=0;
        memset(a,0,sizeof(a));
    }
};
Matrix operator *(Matrix a,Matrix b)
{
    Matrix c;
    c.clear();
    c.n=a.n;
    c.m=b.m;
    for(int i=0;i<a.n;i++)
    {
        for(int j=0;j<b.m;j++)
        {
            for(int k=0;k<a.m;k++)
                c.a[i][j]+=a.a[i][k]*b.a[k][j];
        }
    }
    return c;
}
int main()
{
    int i,j,k,n1,m1;
    Matrix a,b,c,d;
    printf("输入矩阵A的行(n1)列(m1):\n");
    scanf("%d%d",&a.n,&a.m);
    printf("输入矩阵a:\n");
    for(i=0;i<a.n;i++)
    {
        for(j=0;j<a.m;j++)
            scanf("%d",&a.a[i][j]);
    }
    printf("输入矩阵B的行(n2)列(m2):\n");
    scanf("%d%d",&b.n,&b.m);
    printf("输入矩阵b:\n");
    for(i=0;i<b.n;i++)
    {
        for(j=0;j<b.m;j++)
            scanf("%d",&b.a[i][j]);
    }
    if(a.m==b.n)
    {
        c=a*b;
        printf("矩阵a*b的积:\n");
        for(i=0;i<c.n;i++)
        {
            for(j=0;j<c.m;j++)
                printf("%d ",c.a[i][j]);
            printf("\n");
        }
    }
    else
        printf("a*b is Unlawful!\n");
    if(b.m==a.n)
    {
        d=b*a;
        printf("矩阵b*a的积:\n");
        for(i=0;i<d.n;i++)
        {
            for(j=0;j<d.m;j++)
                printf("%d ",d.a[i][j]);
            printf("\n");
        }
    }
    else
        printf("b*a is Unlawful!\n");
    return 0;
}



1、给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转

这里的操作是对所有点同时进行的。其中翻转是以坐标轴为对称轴进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时O(mn)。利用矩阵乘法可以在O(m)的时间里把所有操作合并为一个矩阵，然后每个点与该矩阵相乘即可直接得出最终该点的位置，总共耗时O(m+n)。假设初始时某个点的坐标为x和y，下面5个矩阵可以分别对其进行平移、旋转、翻转和旋转操作。预先把所有m个操作所对应的矩阵全部乘起来，再乘以(x,y,1)，即可一步得出最终点的位置。




矩阵快速幂

1、A^k

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 105
int n;
struct Matrix
{
    int a[MAX][MAX];
    Matrix()
    {
        memset(a,0,sizeof(a));
    }
};

Matrix operator *(Matrix a,Matrix b)
{
    Matrix c;
    int i,j,k;
    memset(c.a,0,sizeof(c.a));
    for(k=0;k<n;k++)
    {
        for(i=0;i<n;i++)
        {
            if(a.a[i][k]==0)
                continue;
            for(j=0;j<n;j++)
            {
                if(b.a[k][j]==0)
                    continue;
                c.a[i][j]=c.a[i][j]+a.a[i][k]*b.a[k][j];
            }
        }
    }
    return c;
}
//a^k
Matrix operator ^(Matrix a,int k)
{
    Matrix c;
    int i;
    //初始化为单位矩阵
    for(i=0;i<n;i++)
        c.a[i][i]=1;
    //
    while(k)
    {
        if(k&1)
            c=c*a;
        a=a*a;
        k>>=1;
    }
    return c;
}

int main()
{
    int i,j,k;
    Matrix a,b,c;
    //printf("输入矩阵的行列（n）和幂值（k）：\n");
    scanf("%d%d",&n,&k);
    //printf("输入n*n的矩阵A：\n");
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            scanf("%d",&a.a[i][j]);
    }
    b=a^k;
    //printf("A^k的矩阵：\n");
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            printf("%d ",b.a[i][j]);
        printf("\n");
    }
    return 0;
}



2、给定矩阵A，请快速计算出A^n（n个A相乘）的结果，输出的每个数都mod p。

由于矩阵乘法具有结合律，因此A^4 = A * A * A * A = (A*A) * (A*A) = A^2 * A^2。我们可以得到这样的结论：当n为偶数时，A^n = A^(n/2) * A^(n/2)；当n为奇数时，A^n = A^(n/2) * A^(n/2) * A （其中n/2取整）。这就告诉我们，计算A^n也可以使用二分快速求幂的方法。例如，为了算出A^25的值，我们只需要递归地计算出A^12、A^6、A^3的值即可。根据这里的一些结果，我们可以在计算过程中不断取模，避免高精度运算。













IUHS
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵乘法（加快速幂）
劭星の博客
11-10 316
参考文献：《算法导论》、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;...
稀疏矩阵的运算（相乘，输出，转置，相加）
千宇乐昊的专栏
10-30 3361
// Matrix.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include using namespace std; #define ElemType int #define MAXSIZE 100 typedef struct { int i,j; //该非零元素的行下标和列下标 ElemType
矩阵相关计算中时间复杂度分析
热门推荐
qq_23174517的博客
07-25 1万+
1.矩阵求逆 伴随矩阵 A−1=A∗det(A)A^{-1} = \frac{A^{*}}{det(A)}A−1=det(A)A∗​ ---- N*O(N!)O(N!)O(N!)+N2∗O((N−1)!)N^{2}*O((N-1)!)N2∗O((N−1)!) 矩阵分解 A=LU⟹A−1=U−1A−1A=LU \Longrightarrow A^{-1}=U^{-1}A^{-1}A=...
和矩阵有关的时间复杂度计算
Daily_365的博客
11-07 9000
论文中有时需要大致给出算法的时间复杂度，我自己比较关注矩阵相关的时间复杂度计算，但是在百度里面搜索到的相关内容有限，于是去看了维基百科，发现维基百科里面有一个词条就叫做"Computational complexity of mathematical operations"，里面总结了很多常见的时间复杂度计算。 我这里只给出关于矩阵运算的时间复杂度计算汇总，对其他内容感兴趣的小伙伴可以直接点击这个链接计算复杂度–维基百科。 ...
算法的时间复杂度
scc的博客
10-27 1812
计算复杂度
【数学】矩阵乘法、计算协方差矩阵的时间复杂度
小白兔的窝
06-11 1万+
（1）矩阵乘法 A(n,m)*B(m,n)=C(n*n) 遍历矩阵C用到两轮循环：遍历n行、每行n个元素； 矩阵C中的每个元素计算，都是是A的一行乘以B的一列，用到一轮循环：m个元素； 所以时间复杂度是n*n*m （2）矩阵的协方差矩阵 向量的协方差，表示两个向量元素之间的相关性，计算公式为： 矩阵的协方差，本质上也是向量运算： 计算协方差矩阵的时间复杂度： （1）不要把这里的X看作矩阵，而是看作多个列向量c1，c2，..., cn的组合，每个列向量中有m个元素； （2）矩阵的.
算法导论【分治思想】—大数乘法、矩阵相乘、残缺棋盘
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
02-19 1774
在分而治之的方法中，一个问题被划分为较小的问题，然后较小的问题被独立地解决，最后较小问题的解决方案被组合成一个大问题的解决。分解：将问题划分为若干子问题，这些子问题是同一问题的较小实例。解决：通过递归地解决子问题来征服它们。如果它们足够小，则将子问题作为基本情况解决。合并：将子问题的解决方案合并为原始问题的解决方法。
常见算法及其时间复杂度总结
weixin_45504248的博客
07-20 8641
常见算法时间复杂度归纳总结
armadillo C++矩阵运算函数库
05-25
还提供了与标量的算术运算，如加、减、乘、除。 4. **随机数生成**：可以生成各种分布的随机数，如均匀分布、正态分布等，用于模拟和测试。 5. **集成其他库**：Armadillo与BLAS（基础线性代数子程序）和LAPACK...
矩阵计算器
09-28
1. **矩阵加减乘**: 矩阵的加法和减法相对简单，只要两个矩阵的维度相同（即行数和列数相等），就可以直接对应元素相加或相减。矩阵乘法则更为复杂，它遵循“行乘列”的规则，即第一个矩阵的每一行与第二个矩阵的每...
matlab 矩阵数组，入门零基础
01-10
矩阵运算方面，矩阵加减 `A+B` 和 `A-B` 同样是对应元素相加减。数乘矩阵 `k*A` 或 `A*k` 是常数乘以矩阵的每个元素。矩阵乘法 `A*B` 遵循数学中的矩阵乘法规则，即第一行与第二列对应元素的乘积之和。矩阵乘方 `A^k...
matlab 矩阵数组-MATLAB快速入门（二）：矩阵
11-18
- 算术运算包括加（+）、减（-）、乘（*）、右除（/）和左除（\），还有幂运算（^）。矩阵乘法遵循行与列的对应原则。 - 逻辑运算包括关系运算符（<, >, ==, ~=）和逻辑运算符（&、|、~、xor）。例如，`A > B` 返回...
Java复数矩阵库——JamPack
04-19
3. **矩阵运算**：JamPack支持矩阵的加、减、乘、点乘（逐元素乘法）等基本运算，以及与标量的乘法。特别地，矩阵乘法遵循线性代数中的规则，即非方阵的乘法需满足维度对应。 4. **矩阵求逆**：JamPack能够计算方阵...
matlab 矩阵数组 快速入门MATLAB之矩阵和数组（下）.zip
最新发布
12-27
3. 矩阵运算：MATLAB支持基本的数学运算，如加减乘除、矩阵乘法（使用`*`）、转置（使用`.'`或`transpose`函数）、逆矩阵（使用`\`或`inv`函数）等。 二、数组的高级操作 1. 数组索引与切片：除了简单的索引，还...
matlab 矩阵数组 快速入门MATLAB之矩阵和数组（上）.zip
12-27
矩阵加减乘除等基本运算可以直接进行，例如`B = A + A`实现矩阵A的自加。乘法需要注意区分元素乘(`.*`)与矩阵乘(`*`)的区别。指数运算如`A.^2`表示元素的平方，而`A^2`则表示矩阵的幂运算。 三、数组索引与切片 ...
矩阵相乘复杂度
欢迎关注，共同进步！
03-07 4302
二维矩阵： 假设矩阵A：i×j，矩阵B：j×k。 AxB计算时，A矩阵的第一行的第一个元素要进行k次乘法运算，A矩阵共有 i×j个元素，故总的需要 i×j×k次乘法运算。即时间复杂度为 O(i×j×k)。 若想了解其他更详细的复杂度分析，可以参阅该博文： https://www.baidu.com/link?url=u6t5Uc1TuYbYm-td9DkfhLp1uPY6FQfUo3zSJ8ocL-UpvEllJBhFs331EHXZtzK8pKWah9DGROuYUn2NvwNRVYc5AHF
数据结构与算法的常见时间复杂度和空间复杂度
qq_41822751的博客
08-12 663
一、时间复杂度 时间复杂度经常使用Big O notation来表示。 O表示某个时间复杂度是n的怎样的一个函数 O(1)：Constant Complexity 常数复杂度 。 O(log n)：Logarithmic Complexity 对数复杂度。 O(n)：Linear Complexity 线性时间复杂度。 O(n^2)：N square Complexity 平方。 O(n^3)：N cube Complexity 立方。 O(2^n)：Exponential Growth 指数。 O(n!)
一些常用计算和常用矩阵计算的时间复杂度
sangba2019的博客
08-08 3343
简单的输入输出语句或赋值语句 O(1) 求最大值 O(n) 排序 O(n*n) 矩阵求模 O(n*n*n) 矩阵赋值 O(n*n) 矩阵求和 O(n*n) 参考： 1、https://www.cnblogs.com/gaochundong/p/complexity_of_algorithms.html 2、https://blog.csdn.net/zolalad/article/details/11848739 ...
矩阵计算复杂度（简洁版）(Computational complexity of matrix)
nobles007820的博客
10-07 2638
计算复杂度、逆矩阵、矩阵乘法
史上最经典的matlab入门教程.docx
02-20
MATLAB支持基本的数学运算，包括加、减、乘、除以及幂次运算。例如，计算表达式`(5*2+1.3-0.8)*10/25`，MATLAB会将结果4.2000存储到变量`ans`中。在MATLAB环境中，`>>`是命令提示符，但中文环境下可能不显示。无需...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值