[C++]矩阵乘法Strassen算法-----代码实现

最新推荐文章于 2024-05-24 16:04:58 发布
最新推荐文章于 2024-05-24 16:04:58 发布
阅读量3k 收藏 26
点赞数 4
分类专栏： C++编程 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmmm0584/article/details/109662031
版权

关于矩阵乘法的Strassen算法，这里不再叙述，推荐简书博客：
https://www.jianshu.com/p/6e21f8e872fd
本篇博客便是参考该简书的算法思想，采用C++进行代码实现，可作为上述简书的补充。

关于使用参数传递二维数组，可参考：
https://www.cnblogs.com/huipengly/p/8892110.html

#include<iostream>
using namespace std;
/*
可以传递二维数组作为参数,有两种方法,
1.change(int **a)直接传递一个指针进去
2.change(int a[][10])数组的第二维维度一定要显式指定
*/
//打印矩阵
void PrintMatrix(int **MatrixA, int N){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			cout << MatrixA[i][j] << " ";
		}
		cout << endl;
	}
}
//矩阵加法
void Matrix_Sum(int N, int** MatrixA, int** MatrixB, int** Sum_Matrix){

	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Sum_Matrix[i][j] = MatrixA[i][j] + MatrixB[i][j];
		}
	}
}
//矩阵减法
void Matrix_Sub(int N, int** MatrixA, int** MatrixB, int** Sub_Matrix){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Sub_Matrix[i][j] = MatrixA[i][j] -MatrixB[i][j];
		}
	}
}
//矩阵乘法
void Matrix_Mul(int N, int** MatrixA, int** MatrixB, int** Mul_Matrix){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Mul_Matrix[i][j] = 0;
			for (int k = 0; k < N; k++){
				Mul_Matrix[i][j] = Mul_Matrix[i][j] + MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}
//基于Strassen的矩阵乘法,输入矩阵A，B，C
void Strassen(int N, int** MatrixA, int** MatrixB, int** MatrixC){
	//新建矩阵
	int** MatrixA11;
	int** MatrixA12;
	int** MatrixA21;
	int** MatrixA22;

	int** MatrixB11;
	int** MatrixB12;
	int** MatrixB21;
	int** MatrixB22;

	int** MatrixC11;
	int** MatrixC12;
	int** MatrixC21;
	int** MatrixC22;
	//初始化每个小矩阵的大小
	MatrixA11 = new int*[N/2];//数组的第二维一定要显示指定
	MatrixA12 = new int*[N/2];
	MatrixA21 = new int*[N/2];
	MatrixA22 = new int*[N/2];

	MatrixB11 = new int*[N/2];
	MatrixB12 = new int*[N/2];
	MatrixB21 = new int*[N/2];
	MatrixB22 = new int*[N/2];

	MatrixC11 = new int*[N/2];
	MatrixC12 = new int*[N/2];
	MatrixC21 = new int*[N/2];
	MatrixC22 = new int*[N/2];
	for (int i = 0; i < N/2; i++)//分配连续内存
	{
		MatrixA11[i] = new int[N/2];
		MatrixA12[i] = new int[N / 2];
		MatrixA21[i] = new int[N / 2];
		MatrixA22[i] = new int[N / 2];

		MatrixB11[i] = new int[N / 2];
		MatrixB12[i] = new int[N / 2];
		MatrixB21[i] = new int[N / 2];
		MatrixB22[i] = new int[N / 2];
		
		MatrixC11[i] = new int[N / 2];
		MatrixC12[i] = new int[N / 2];
		MatrixC21[i] = new int[N / 2];
		MatrixC22[i] = new int[N / 2];
	}
	 //为每个小矩阵赋值，将大矩阵分割为4个小矩阵
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixA11[i][j] = MatrixA[i][j];
			MatrixA12[i][j] = MatrixA[i][j + N / 2];
			MatrixA21[i][j] = MatrixA[i + N / 2][j];
			MatrixA22[i][j] = MatrixA[i + N / 2][j + N / 2];

			MatrixB11[i][j] = MatrixB[i][j];
			MatrixB12[i][j] = MatrixB[i][j + N / 2];
			MatrixB21[i][j] = MatrixB[i + N / 2][j];
			MatrixB22[i][j] = MatrixB[i + N / 2][j + N / 2];
		}
	}
   //做10个辅助矩阵S，计算加法
	int** MatrixS1=new int*[N/2];
	int** MatrixS2 = new int*[N/2];
	int** MatrixS3 = new int*[N/2];
	int** MatrixS4 = new int*[N / 2];
	int** MatrixS5 = new int*[N / 2];
	int** MatrixS6 = new int*[N / 2];
	int** MatrixS7 = new int*[N / 2];
	int** MatrixS8 = new int*[N / 2];
	int** MatrixS9 = new int*[N / 2];
	int** MatrixS10 = new int*[N / 2];
	
	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixS1[i] = new int[N / 2];
		MatrixS2[i] = new int[N / 2];
		MatrixS3[i] = new int[N / 2];
		MatrixS4[i] = new int[N / 2];
		MatrixS5[i] = new int[N / 2];
		MatrixS6[i] = new int[N / 2];
		MatrixS7[i] = new int[N / 2];
		MatrixS8[i] = new int[N / 2];
		MatrixS9[i] = new int[N / 2];
		MatrixS10[i] = new int[N / 2];
	}

	Matrix_Sub(N/2, MatrixB12, MatrixB22, MatrixS1);//S1 = B12 - B22
	Matrix_Sum(N / 2, MatrixA11, MatrixA12, MatrixS2);//S2 = A11 + A12
	Matrix_Sum(N / 2, MatrixA21, MatrixA22, MatrixS3);//S3 = A21 + A22
	Matrix_Sub(N / 2, MatrixB21, MatrixB11, MatrixS4);//S4 = B21 - B11
	Matrix_Sum(N / 2, MatrixA11, MatrixA22, MatrixS5);//S5 = A11 + A22
	Matrix_Sum(N / 2, MatrixB11, MatrixB22, MatrixS6);//S6 = B11 + B22
	Matrix_Sub(N / 2, MatrixA12, MatrixA22, MatrixS7);//S7 = A12 - A22
	Matrix_Sum(N / 2, MatrixB21, MatrixB22, MatrixS8);//S8 = B21 + B22
	Matrix_Sub(N / 2, MatrixA11, MatrixA21, MatrixS9);//S9 = A11 - A21
	Matrix_Sum(N / 2, MatrixB11, MatrixB12, MatrixS10);//S10 = B11 + B12

	//做7个辅助矩阵P，计算乘法
	int** MatrixP1 = new int*[N / 2];
	int** MatrixP2 = new int*[N / 2];
	int** MatrixP3 = new int*[N / 2];
	int** MatrixP4 = new int*[N / 2];
	int** MatrixP5 = new int*[N / 2];
	int** MatrixP6 = new int*[N / 2];
	int** MatrixP7 = new int*[N / 2];

	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixP1[i] = new int[N / 2];
		MatrixP2[i] = new int[N / 2];
		MatrixP3[i] = new int[N / 2];
		MatrixP4[i] = new int[N / 2];
		MatrixP5[i] = new int[N / 2];
		MatrixP6[i] = new int[N / 2];
		MatrixP7[i] = new int[N / 2];
	}
	Matrix_Mul(N / 2, MatrixA11, MatrixS1, MatrixP1);//P1 = A11 • S1
	Matrix_Mul(N / 2, MatrixS2, MatrixB22, MatrixP2);//P2 = S2 • B22
	Matrix_Mul(N / 2, MatrixS3, MatrixB11, MatrixP3);//P3 = S3 • B11
	Matrix_Mul(N / 2, MatrixA22, MatrixS4, MatrixP4);//P4 = A22 • S4
	Matrix_Mul(N / 2, MatrixS5, MatrixS6, MatrixP5);//P5 = S5 • S6
	Matrix_Mul(N / 2, MatrixS7, MatrixS8, MatrixP6);//P6 = S7 • S8
	Matrix_Mul(N / 2, MatrixS9, MatrixS10, MatrixP7);//P7 = S9 • S10

	//根据以上7个结果计算C矩阵
	Matrix_Sum(N / 2, MatrixP5, MatrixP4, MatrixC11); //C11 = P5 + P4 - P2 + P6
	Matrix_Sub(N / 2, MatrixC11, MatrixP2, MatrixC11);
	Matrix_Sum(N / 2, MatrixC11, MatrixP6, MatrixC11);
	Matrix_Sum(N / 2, MatrixP1, MatrixP2, MatrixC12);//C12 = P1 + P2
	Matrix_Sum(N / 2, MatrixP3, MatrixP4, MatrixC21);	//C21 = P3 + P4
	Matrix_Sum(N / 2, MatrixP5, MatrixP1, MatrixC22);	//C22 = P5 + P1 - P3 - P7
	Matrix_Sub(N / 2, MatrixC22, MatrixP3, MatrixC22);
	Matrix_Sub(N / 2, MatrixC22, MatrixP7, MatrixC22);
	//将C11，C12,C21,C21合并为C矩阵
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixC[i][j] = MatrixC11[i][j];
			MatrixC[i][j+N/2] = MatrixC12[i][j];
			MatrixC[i+N/2][j] = MatrixC21[i][j];
			MatrixC[i+N/2][j+N/2] = MatrixC22[i][j];
		}
	}
}
//朴素矩阵相乘算法
void NormalMul_Matrix(int N, int **MatrixA, int **MatrixB, int **MatrixC){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixC[i][j] = 0;
			for (int k = 0; k < N; k++){
				MatrixC[i][j] = MatrixC[i][j]+MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}

	//初始化矩阵A，B
void Init_Matrix(int N,int** MatrixA, int** MatrixB){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixA[i][j] = rand() % 10 + 1;//产生1~10
			MatrixB[i][j] = rand() % 10 + 1;
		}
	}
	/*
	C++中rand() 函数的用法
	1、rand()不需要参数，它会返回一个从0到最大随机数的任意整数，最大随机数的大小通常是固定的一个大整数。
	2、如果你要产生0~99这100个整数中的一个随机整数，可以表达为：int num = rand() % 100;
	这样，num的值就是一个0~99中的一个随机数了。
	3、如果要产生1~100，则是这样：int num = rand() % 100 + 1;
	4、总结来说，可以表示为：int num = rand() % n +a;
	其中的a是起始值，n-1+a是终止值，n是整数的范围。
	*/
}
//矩阵A,B测试用例
void Test_Matrix(int N, int** MatrixA, int** MatrixB){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixA[i][j] = 1;
			MatrixB[i][j] = 2;
		}
	}
	}

void main(){
	int N;
	cout << "请输入矩阵大小(必须是2的幂指数值(例如:32,64,512,..): ";
	cin >> N;	
	int** MatrixA = new int *[N];
	int**  MatrixB = new int *[N];
	int** MatrixC = new int *[N];//测试Strassen矩阵

	int** MatrixC1 = new int*[N];//测试朴素相乘矩阵
	for (int i = 0; i < N; i++)//分配连续内存
	{
		MatrixA[i] = new int[N];
		MatrixB[i] = new int[N];
		MatrixC[i] = new int[N];

		MatrixC1[i] = new int[N];
	}

	Init_Matrix(N, MatrixA, MatrixB);
	//Test_Matrix(N, MatrixA, MatrixB);
	cout << "A矩阵为：" << endl;
	PrintMatrix(MatrixA, N);
	cout << "B矩阵为：" << endl;
	PrintMatrix(MatrixB, N);	
	cout << "朴素矩矩阵为：" << endl;
	NormalMul_Matrix(N, MatrixA, MatrixB, MatrixC1);
	PrintMatrix(MatrixC1, N);
	cout << "Strassen矩阵为：" << endl;
	Strassen(N, MatrixA, MatrixB, MatrixC);
	PrintMatrix(MatrixC, N);
	system("pause");				//等待按任意键退出
	
}

运行结果如下：
在这里插入图片描述
关于Strassen算法的性能分析,可参考博客:
https://www.cnblogs.com/zhoutaotao/p/3963048.html
参考博客：
https://blog.csdn.net/zhuangxiaobin/article/details/36476769

臧初之
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《算法导论》：矩阵乘法的Strassen算法代码实现
Toby的博客
09-04 862
本文为《算法导论》：矩阵乘法的Strassen算法代码实现，欢迎参考，期待您的关注！
《算法导论》第四章-矩阵乘法的Strassen算法（含C++代码）
Toby的博客
07-26 2356
本文为《算法导论》第四章-4.2-矩阵乘法的Strassen方法笔记，欢迎大家参考。
C++ 矩阵乘法
最新发布
u011022940的博客
05-24 126
【代码】C++ 矩阵乘法。
【C++】矩阵的乘法
qq_63806300的博客
05-19 3831
由矩阵相乘的性质可以用三层循环求出结果，注意i的循环需要放在最外层，j的循环需要放在中间层，k的循环需要放在最低层。因为矩阵A是2×3矩阵，矩阵B是3×3矩阵，A的列数等于B的行数，所以矩阵A与B可以相乘，乘积AB是一个2×3矩阵。矩阵相乘时需要注意两点，一点是矩阵1的列数要等与矩阵2的行数，一点是矩阵相乘后的矩阵。手算一下AB，不难发现结果是正确的。先复习一下矩阵的乘法。
C++实现矩阵乘法
热门推荐
qq_41843394的博客
02-16 3万+
最近学习C++，做了一个矩阵乘法的练习。先说一下功能，输入两个矩阵A，B，大小自己定，换行用；表示（matlab的习惯）。然后输出A*B的矩阵。 1.思路 首先，由于输入的矩阵维数是随机的，因此，我们要设计程序，手动把行和列算出来，这样方便后续乘法运算。并且把输入的数字提取出来，放入一个float型数组中，这样我们就完成了读入工作，之后就是利用乘法公式进行运算，并把结果放入一个二维数组中，最后...
c语言：矩阵相乘
LYY的学习和记录
05-06 3483
#include <stdio.h> int main() { int a[4][3] = { {1,2,3}, {4,5,6}, {7,8,9}, {1,2,3}}; int b[3][3] = { { 1,2,3 }, { 4,5,6 }, {...
C++ Strassen算法代码的实现
08-19
"C++ Strassen算法代码的实现" 本篇文章将对C++ Strassen算法代码的实现进行详细的介绍。Strassen算法是一种矩阵乘法算法，它可以将矩阵乘法的时间复杂度从O(n^3)降低到O(n^2.81)。在实际应用中，Strassen算法可以...
cpp-基准测试矩阵乘法的实现
08-16
5. **算法优化**：使用Strassen或Coppersmith-Winograd等更高效的矩阵乘法算法，虽然这些算法在理论上的时间复杂度更低，但在实际应用中可能只对极端大尺寸的矩阵有效。 6. **编译器优化**：启用编译器的优化选项，...
TestMatrix_多种C++矩阵乘法算法_avx_
09-29
在本文中，我们将深入探讨标题为“TestMatrix_多种C++矩阵乘法算法_avx_”的项目，该项目旨在实现并比较多种C++矩阵乘法算法，特别关注使用Intel AVX（Advanced Vector Extensions）指令集的优化技术。矩阵乘法是...
矩阵乘法的strassen算法(C++实现)
04-23
一般情况下矩阵乘法需要三个for循环，时间复杂度为O(n^3)，现在我们将矩阵分块如图：( 来自MIT算法导论 ) 一般算法需要八次乘法 r = a * e + b * g ; s = a * f + b * h ; t = c * e + d * g; u = c * f + d * h; ...
Desktop_C++_算法导论_矩阵乘法_递归_
10-03
在本项目中，我们主要探讨的是C++编程语言中的矩阵乘法算法，特别是基于《算法导论》第六版第四章77页所描述的递归方法。递归是一种强大的编程技术，它允许函数调用自身来解决问题。在这个特定的场景中，递归被用来...
两个矩阵乘法c++实现
05-10
实现输入两个矩阵，并作乘法运算！用c++实现！
详解矩阵乘法中的Strassen算法
u011250186的博客
07-29 8379
机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。 一、矩阵乘法 如下图所示： Figure 1 Matrix Multiplication 二、Strassen算法 Figure 2 x^3 vs. x^2.807 三、Strassen原理详解 Strassen算法正是从这个角度出发，实现了降低算法复杂度！ 实现步骤可以分为以下4步： 3.1 S...
二维傅里叶变换_数字图像处理P15P16第一节正交变换的基本概念第五章 第二节 离散傅里叶变换...
weixin_39969060的博客
12-05 723
昨天手滑了，不小心把文章给删了。难受。第一节 正交变换的基本概念 图像是许多点冲激函数的累加，图像通过系统的效果就是每一点冲激函数通过系统的响应之和。 任何图像都可以分解为基图像之和，基图像相互是正交的，图像变换的本质是寻找合适的基图像来表达图像。 广泛应用于图像增强，复原，编码，描述和特征提取等方面。图像正交变换分为三大类： 正弦、余弦型变换 ...
strassen矩阵乘法c语言_[内附完整源码和文档] 基于vc++实现的矩阵乘优化软件
weixin_39590635的博客
12-14 206
一、实验名称矩阵乘优化软件二、实验目的及要求C语言实现矩阵x向量算法矩阵要求CSR压缩存储格式,测试集选用佛罗里达州立大学测试集 http://www.cise.ufl.edu/research/sparse/matrices//SSE优化，LOOP unrolling，software prefetch软件预取，多线程并行给出测试界面，运行时间及加速比结果三、实验环境操作系统（开发）：Windo...
C++实现矩阵的乘法
n750776806的博客
09-15 368
#include<bits/stdc++.h> using namespace std; int A_column = 0; int A_vertical = 0; int B_column = 0; int B_vertical = 0; int C_column = 0; int C_vertical = 0; int main(){ cout << "请输入A的列长度:"; cin >> A_vertical; cout <&l.
递归与分治策略：Strassen矩阵乘法
憧憬，思考，奋斗，飞翔
06-22 7511
辅助函数 为了便于代码的编写，以及在函数参数中传二维数组的方便，写了以下三个辅助函数。 //数组寻址辅助函数 int& GetArrayVal( int* pMatrix, int nCol, int i, int j ) { return *( pMatrix + i * nCol + j); } //创建矩阵 void CreateMatrix( int** pMatrix, int
Strassen矩阵乘法并行实现代码
04-26
1. Github上的Strassen算法C++实现代码：https://github.com/ramchalamk/Strassen-CPP/blob/master/strassen.cpp 2. 由S. Günter在Journal of Parallel and Distributed Computing上发表的一篇名为“Parallel ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值