【算法】_016_矩阵乘法_Strassen算法

最新推荐文章于 2024-03-26 10:31:21 发布
最新推荐文章于 2024-03-26 10:31:21 发布
阅读量366 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq912966864/article/details/39724271
版权

1、013_matrix_mutiply_strassen.h

/***************************************************************
*版权所有 (C)2014,长沙铁信交通科技有限公司。
*
*文件名称：013_matrix_mutiply_strassen.h
*内容摘要：矩阵乘法Strassen算法(矩阵分解)
*其它说明：难点在于矩阵的具体实现
*当前版本：V1.0
*作   者：伍定湘
*完成日期：2014年9月29日
*
*修改记录1：
*   修改日期：2014年9月29日
*   版本号：V1.0
*   修改人：伍定湘
*   修改内容：创建
***************************************************************/


#ifndef _MATRIX_MUTIPLY_STRASSEN_H_ //防止头文件被重复引用
#define _MATRIX_MUTIPLY_STRASSEN_H_


/**************************************************************
头文件引用
**************************************************************/
#include "typedef.h"//引入内置类型重定义


/**************************************************************
相关宏定义
**************************************************************/


/**************************************************************
相关结构体定义
**************************************************************/
#ifndef _MATRIX_TYPEDEF_2_ //防止头文件被重复引用
#define _MATRIX_TYPEDEF_2_
typedef struct
{
	INT32 iOriginI;
	INT32 iOriginJ;
	INT32 iOriginOrder;
	INT32 *aMtrData;
}MatrixTypedef2;
#endif

/**************************************************************
本程序中出现的函数的声明
**************************************************************/
void matrix_mutiply_strassen(INT32 aMtrDataA[], INT32 aMtrDataB[], const INT32 iOriginOrder);
void mutiply_strassen(MatrixTypedef2 mtrA, MatrixTypedef2 mtrB, MatrixTypedef2 mtrC, INT32 iCurrentOrder, const INT32 iOriginOrder);
void plus_strassen(MatrixTypedef2 mtr1, MatrixTypedef2 mtr2, MatrixTypedef2 mtr3, INT32 iCurrentOrder);
void minus_strassen(MatrixTypedef2 mtr1, MatrixTypedef2 mtr2, MatrixTypedef2 mtr3, INT32 iCurrentOrder);
MatrixTypedef2 child_matrix(MatrixTypedef2 mtrOrigin, INT32 iNewI, INT32 iNewJ, INT32 iCurrentOrder);


#endif


2、013_matrix_mutiply_strassen.c

/***************************************************************
*版权所有 (C)2014,长沙铁信交通科技有限公司。
*
*文件名称：013_matrix_mutiply_strassen.c
*内容摘要：矩阵乘法Strassen算法(矩阵分解)
*其它说明：难点在于矩阵的具体实现
*当前版本：V1.0
*作   者：伍定湘
*完成日期：2014年9月29日
*
*修改记录1：
*   修改日期：2014年9月29日
*   版本号：V1.0
*   修改人：伍定湘
*   修改内容：创建
***************************************************************/


/**************************************************************
头文件引用
**************************************************************/
#include "typedef.h"//引入内置类型重定义
#include "013_matrix_mutiply_strassen.h"

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>


/**************************************************************
全局变量定义
**************************************************************/


/**************************************************************
函数实现
**************************************************************/

/**********************************************************************
*功能描述：矩阵乘法
*输入参数：aMtrDataA - 存储矩阵A数值的一维数组
*        aMtrDataB - 存储矩阵B数值的一维数组
*        aMtrDataC - 存储矩阵B数值的一维数组
*        iOriginOrder - 矩阵的初始阶数
*输出参数：
*返回值：
*其它说明：
*修改日期           版本号         修改人        修改内容
* ---------------------------------------------------------------------
*2014年9月29日      V1.0          伍定湘        创建
***********************************************************************/
void matrix_mutiply_strassen(INT32 aMtrDataA[], INT32 aMtrDataB[], const INT32 iOriginOrder)
{
	MatrixTypedef2 mtrA = { 0, 0, iOriginOrder, aMtrDataA };
	MatrixTypedef2 mtrB = { 0, 0, iOriginOrder, aMtrDataB };
	INT32 *pMtrDataC = (INT32 *)malloc(iOriginOrder * iOriginOrder * sizeof(INT32));
	memset(pMtrDataC, 0, iOriginOrder * iOriginOrder * sizeof(INT32));
	MatrixTypedef2 mtrC = { 0, 0, iOriginOrder, pMtrDataC };
	INT32 iCurrentOrder = iOriginOrder;
	mutiply_strassen(mtrA, mtrB, mtrC, iOriginOrder, iOriginOrder);
	INT32 x;
	while (iCurrentOrder--)
	{
		x = iOriginOrder;
		while (x--)
		{
			printf("%d\t", pMtrDataC[(iOriginOrder - iCurrentOrder - 1) * iOriginOrder + (iOriginOrder - x - 1)]);
		}
		printf("\n");
	}
	printf("\n");
	printf("\n");
}

/**********************************************************************
*功能描述：矩阵乘法Strassen算法(矩阵分解)
*输入参数：mtrA - 矩阵A的参数结构体
*        mtrB - 矩阵B的参数结构体
*        mtrC - 矩阵C的参数结构体
*        iCurrentOrder - 当前阶数
*        iOriginOrder - 初始阶数
*输出参数：
*返回值：
*其它说明：1 - 递归函数
*        2 - 通过向下级传递新的首元素位置以及减半的阶数实现分解矩阵
*        3 - 指针修改C矩阵数值，无返回值
*        4 - 不要返回下一级矩阵的参数，以免返回值修改了上级矩阵C的首元素参数
*修改日期           版本号         修改人        修改内容
* ---------------------------------------------------------------------
*2014年9月29日      V1.0          伍定湘        创建
***********************************************************************/
void mutiply_strassen(MatrixTypedef2 mtrA, MatrixTypedef2 mtrB, MatrixTypedef2 mtrC, INT32 iCurrentOrder, const INT32 iOriginOrder)
{
	/* 递归至最基本情况，递归结束 */
	if (iCurrentOrder == 1)
	{
		INT32 x = mtrA.aMtrData[mtrA.iOriginI *  mtrA.iOriginOrder + mtrA.iOriginJ] *
			mtrB.aMtrData[mtrB.iOriginI *  mtrB.iOriginOrder + mtrB.iOriginJ];
		mtrC.aMtrData[mtrC.iOriginI *  mtrC.iOriginOrder + mtrC.iOriginJ] = x;
		return;
	}

	iCurrentOrder >>= 1;//阶数减半

	/* 分解矩阵 */
	MatrixTypedef2 mtrA00 = child_matrix(mtrA, 0, 0, iCurrentOrder);
	MatrixTypedef2 mtrA01 = child_matrix(mtrA, 0, 1, iCurrentOrder);
	MatrixTypedef2 mtrA10 = child_matrix(mtrA, 1, 0, iCurrentOrder);
	MatrixTypedef2 mtrA11 = child_matrix(mtrA, 1, 1, iCurrentOrder);

	MatrixTypedef2 mtrB00 = child_matrix(mtrB, 0, 0, iCurrentOrder);
	MatrixTypedef2 mtrB01 = child_matrix(mtrB, 0, 1, iCurrentOrder);
	MatrixTypedef2 mtrB10 = child_matrix(mtrB, 1, 0, iCurrentOrder);
	MatrixTypedef2 mtrB11 = child_matrix(mtrB, 1, 1, iCurrentOrder);

	MatrixTypedef2 mtrC00 = child_matrix(mtrC, 0, 0, iCurrentOrder);
	MatrixTypedef2 mtrC01 = child_matrix(mtrC, 0, 1, iCurrentOrder);
	MatrixTypedef2 mtrC10 = child_matrix(mtrC, 1, 0, iCurrentOrder);
	MatrixTypedef2 mtrC11 = child_matrix(mtrC, 1, 1, iCurrentOrder);

	INT32 *pMtrS[10];
	MatrixTypedef2 mtrS[10] = { { 0, 0, 0, NULL } };
	for (size_t i = 0; i < 10; i++)
	{
		pMtrS[i]= (INT32 *)malloc(iCurrentOrder * iCurrentOrder * sizeof(INT32));
		memset(pMtrS[i], 0, iCurrentOrder * iCurrentOrder * sizeof(INT32));
		mtrS[i].iOriginOrder = iCurrentOrder;
		mtrS[i].aMtrData = pMtrS[i];
	}

	/* 根据矩阵A、B获取十个矩阵 */
	minus_strassen(mtrB01, mtrB11, mtrS[0], iCurrentOrder);//S0 = B01 - B11
	plus_strassen(mtrA00, mtrA01, mtrS[1], iCurrentOrder);//S1 = A00 + A01
	plus_strassen(mtrA10, mtrA11, mtrS[2], iCurrentOrder);//S2 = A10 + A11
	minus_strassen(mtrB10, mtrB00, mtrS[3], iCurrentOrder);//S3 = B10 - B00
	plus_strassen(mtrA00, mtrA11, mtrS[4], iCurrentOrder);//S4 = A00 + A11
	plus_strassen(mtrB00, mtrB11, mtrS[5], iCurrentOrder);//S5 = B00 + B11
	minus_strassen(mtrA01, mtrA11, mtrS[6], iCurrentOrder);//S6 = A01 - A11
	plus_strassen(mtrB10, mtrB11, mtrS[7], iCurrentOrder);//S7 = B10 + B11
	minus_strassen(mtrA00, mtrA10, mtrS[8], iCurrentOrder);//S8 = A00 - A10
	plus_strassen(mtrB00, mtrB01, mtrS[9], iCurrentOrder);//S9 = B00 + B01

	INT32 *pMtrP[7];
	MatrixTypedef2 mtrP[7] = { { 0, 0, 0, NULL } };//不要带变量初始化数组
	for (size_t i = 0; i < 7; i++)
	{
		pMtrP[i] = (INT32 *)malloc(iCurrentOrder * iCurrentOrder * sizeof(INT32));
		memset(pMtrP[i], 0, iCurrentOrder * iCurrentOrder * sizeof(INT32));
		mtrP[i].iOriginOrder = iCurrentOrder;
		mtrP[i].aMtrData = pMtrP[i];
	}

	/* 递归地计算7次子矩阵乘法 */
	mutiply_strassen(mtrA00, mtrS[0], mtrP[0], iCurrentOrder, iOriginOrder);//P0 = A00 * S0
	mutiply_strassen(mtrS[1], mtrB11, mtrP[1], iCurrentOrder, iOriginOrder);//P1 = S1 * B11
	mutiply_strassen(mtrS[2], mtrB00, mtrP[2], iCurrentOrder, iOriginOrder);//P2 = S2 * B00
	mutiply_strassen(mtrA11, mtrS[3], mtrP[3], iCurrentOrder, iOriginOrder);//P3 = A11 * S3
	mutiply_strassen(mtrS[4], mtrS[5], mtrP[4], iCurrentOrder, iOriginOrder);//P4 = S4 * S5
	if (iCurrentOrder == 2)
	{
		int a = 5;
	}
	mutiply_strassen(mtrS[6], mtrS[7], mtrP[5], iCurrentOrder, iOriginOrder);//P5 = S6 * S7
	mutiply_strassen(mtrS[8], mtrS[9], mtrP[6], iCurrentOrder, iOriginOrder);//P6 = S8 * S9

	/* 释放S */
	for (size_t i = 0; i < 10; i++)
	{
		free(pMtrS[i]);
	}

	/* C00 = P4 + P3 - P1 + P5 */
	plus_strassen(mtrP[4], mtrP[3], mtrC00, iCurrentOrder);
	minus_strassen(mtrC00, mtrP[1], mtrC00, iCurrentOrder);
	plus_strassen(mtrC00, mtrP[5], mtrC00, iCurrentOrder);

	/* C01 = P0 + P1 */
	plus_strassen(mtrP[0], mtrP[1], mtrC01, iCurrentOrder);

	/* C10 = P2 + P3 */
	plus_strassen(mtrP[2], mtrP[3], mtrC10, iCurrentOrder);

	/* C11 = P4 + P0 - P2 - P6 */
	plus_strassen(mtrP[4], mtrP[0], mtrC11, iCurrentOrder);
	minus_strassen(mtrC11, mtrP[2], mtrC11, iCurrentOrder);
	minus_strassen(mtrC11, mtrP[6], mtrC11, iCurrentOrder);

	/* 释放P */
	for (size_t i = 0; i < 7; i++)
	{
		free(pMtrP[i]);
	}
}

/**********************************************************************
*功能描述：矩阵加法
*输入参数：mtr1 - 矩阵1的参数结构体
*        mtr2 - 矩阵2的参数结构体
*        mtr3 - 矩阵3的参数结构体
*        iCurrentOrder - 当前阶数
*        iOriginOrder - 初始阶数
*输出参数：
*返回值：
*其它说明：1 - 递归函数
*        2 - 通过向下级传递新的首元素位置以及减半的阶数实现分解矩阵
*        3 - 指针修改C矩阵数值，无返回值
*        4 - 不要返回下一级矩阵的参数，以免返回值修改了上级矩阵C的首元素参数
*修改日期           版本号         修改人        修改内容
* ---------------------------------------------------------------------
*2014年9月29日      V1.0          伍定湘        创建
***********************************************************************/
void plus_strassen(MatrixTypedef2 mtr1, MatrixTypedef2 mtr2, MatrixTypedef2 mtr3, INT32 iCurrentOrder)
{
	INT32 x;
	for (INT32 i = 0; i < iCurrentOrder; i++)
	{
		for (INT32 j = 0; j < iCurrentOrder; j++)
		{
			x = mtr1.aMtrData[(i + mtr1.iOriginI) *  mtr1.iOriginOrder + mtr1.iOriginJ + j] +
				mtr2.aMtrData[(i + mtr2.iOriginI) *  mtr2.iOriginOrder + mtr2.iOriginJ + j];
			mtr3.aMtrData[(i + mtr3.iOriginI) *  mtr3.iOriginOrder + mtr3.iOriginJ + j] = x;
		}
	}
}

/**********************************************************************
*功能描述：矩阵加法
*输入参数：mtr1 - 矩阵1的参数结构体
*        mtr2 - 矩阵2的参数结构体
*        mtr3 - 矩阵3的参数结构体
*        iCurrentOrder - 当前阶数
*        iOriginOrder - 初始阶数
*输出参数：
*返回值：
*其它说明：1 - 递归函数
*        2 - 通过向下级传递新的首元素位置以及减半的阶数实现分解矩阵
*        3 - 指针修改C矩阵数值，无返回值
*        4 - 不要返回下一级矩阵的参数，以免返回值修改了上级矩阵C的首元素参数
*修改日期           版本号         修改人        修改内容
* ---------------------------------------------------------------------
*2014年9月29日      V1.0          伍定湘        创建
***********************************************************************/
void minus_strassen(MatrixTypedef2 mtr1, MatrixTypedef2 mtr2, MatrixTypedef2 mtr3, INT32 iCurrentOrder)
{
	INT32 x;
	for (INT32 i = 0; i < iCurrentOrder; i++)
	{
		for (INT32 j = 0; j < iCurrentOrder; j++)
		{
			x = mtr1.aMtrData[(i + mtr1.iOriginI) *  mtr1.iOriginOrder + mtr1.iOriginJ + j] -
				mtr2.aMtrData[(i + mtr2.iOriginI) *  mtr2.iOriginOrder + mtr2.iOriginJ + j];
			mtr3.aMtrData[(i + mtr3.iOriginI) *  mtr3.iOriginOrder + mtr3.iOriginJ + j] = x;
		}
	}
}

/**********************************************************************
*功能描述：矩阵加法
*输入参数：mtr1 - 矩阵1的参数结构体
*        mtr2 - 矩阵2的参数结构体
*        mtr3 - 矩阵3的参数结构体
*        iCurrentOrder - 当前阶数
*        iOriginOrder - 初始阶数
*输出参数：
*返回值：
*其它说明：1 - 递归函数
*        2 - 通过向下级传递新的首元素位置以及减半的阶数实现分解矩阵
*        3 - 指针修改C矩阵数值，无返回值
*        4 - 不要返回下一级矩阵的参数，以免返回值修改了上级矩阵C的首元素参数
*修改日期           版本号         修改人        修改内容
* ---------------------------------------------------------------------
*2014年9月29日      V1.0          伍定湘        创建
***********************************************************************/
MatrixTypedef2 child_matrix(MatrixTypedef2 mtrOrigin, INT32 iNewI, INT32 iNewJ, INT32 iCurrentOrder)
{
	if (iNewI)
	{
		mtrOrigin.iOriginI += iCurrentOrder;
	}
	if (iNewJ)
	{
		mtrOrigin.iOriginJ += iCurrentOrder;
	}
	return(mtrOrigin);
}


花和尚_倒拔垂杨柳
关注
专栏目录
使用分治法解决矩阵乘法的Strassen算法及C代码示例
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-20 2232
在计算机科学中，矩阵乘法是一种基本的运算，广泛应用于图像处理、机器学习、线性代数、物理模拟等领域。然而，传统的矩阵乘法算法的时间复杂度较高，为O(n^3)，在处理大规模矩阵时效率低下。为了降低矩阵乘法的计算成本，研究者们提出了多种优化方法，其中Strassen算法便是一种基于分治法的有效算法。 Strassen算法于1969年由德国数学家Volker Strassen提出，它将矩阵乘法的时间复杂度降低到了O(n^log2(7))≈O(n^2.807)，相较于传统算法有了显著的提升。尽管后来有更高效的算法被
矩阵相乘的strassen算法_详解矩阵乘法中的Strassen算法
weixin_32821813的博客
01-12 1034
By LongLuo机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。一、矩阵乘法假设为的矩阵，为的矩阵，那么称的矩阵为矩阵与的乘积，记作，称为矩阵积(matrix product)。其中矩阵中的第行第列元素可以表示为：如下图所示：矩阵乘法假如在矩阵和矩阵中，，那么完成需要多少次乘法呢？对于每...
分治算法_Strassen矩阵乘法
PioneerOneLi的博客
05-12 1702
算法的主要思想是一种分治思想，即将一个2n的方阵分解成4个2n-1的小方阵。 借助这种办法，任何有穷方阵都可以简化为有限个2×2方阵，所以今天我们主要介绍斯特拉森算法在2×2方阵上的应用。 首先我们假设有两个2×2矩阵，A,B. A = a11a12 B = b11 b12 a21 a22 b21 b22 我们设矩阵相乘的结果矩阵...
矩阵相乘的strassen算法_4-2.矩阵乘法的Strassen算法详解
weixin_39856709的博客
12-20 737
题目描述请编程实现矩阵乘法，并考虑当矩阵规模较大时的优化方法。思路分析根据wikipedia上的介绍：两个矩阵的乘法仅当第一个矩阵B的列数和另一个矩阵A的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积AB是一个m×p矩阵，它的一个元素其中 1 ≤ i ≤ m, 1 ≤ j ≤ p。值得一提的是，矩阵乘法满足结合律和分配率，但并不满足交换律，如下图所示的这个例子，两个矩阵交换相乘后...
矩阵相乘的strassen算法_矩阵乘法的Strassen算法
weixin_39992199的博客
12-20 725
目录一、矩阵相乘二、矩阵相乘的朴素算法三、Strassen其人及其算法四、Strassen的理想五、附Strassen的一种代码实现六、参考一、矩阵相乘矩阵相乘，是指一个m*n的矩阵和一个n*k的矩阵相乘而得到一个m*k矩阵的一种运算。矩阵相乘可用于线性变换和矩阵分解[1]。二、矩阵相乘的朴素算法矩阵相乘的一般步骤是第一个矩阵的第i行*第二个矩阵的第j列，得到第三个矩阵的第i行第j列元素因此其素朴...
矩阵相乘的strassen算法_矩阵乘法Strassen算法
weixin_39900023的博客
12-20 563
阅读经典——《算法导论》03矩阵乘法是种极其耗时的运算。以C = A • B为例，其中A和B都是 n x n 的矩阵。根据矩阵乘法的定义，计算过程如下：SQUARE-MATRIX-MULTIPLY(A, B)n = A.rowslet C be a new nxn matrixfor i = 1 to nfor j = 1 to nc[i][j] = 0for k = 1 to nc[i][j] ...
Strassen矩阵乘法的C语言算法实现
fufufunny的博客
01-28 1800
矩阵乘法是高等代数中的重要基本运算，本文将介绍Strassen矩阵乘法的基本原理和用C语言进行算法实现的过程。
strassen矩阵乘法 java_矩阵乘法Strassen算法
weixin_39927861的博客
02-22 304
矩阵乘法是种极其耗时的运算。以 为例，其中 和 都是 矩阵。根据矩阵乘法的定义， 中的每个元素需要按照如下方式计算式(4.8)包含一个 次的循环，因此计算 的时间复杂度为 。而 共有 个元素，因此总时间复杂度为 。这是一个很可怕的数字，当 较大时，连计算机都无法承受如此的计算时间。不过，凭着科学家们的智慧，人们逐渐发现存在一些低于 的矩阵乘法算法。Strassen是这方面的先驱...
C语言经典算法之Strassen矩阵乘法
最新发布
weixin_56154577的博客
03-26 990
Strassen矩阵乘法是一种利用分治策略优化传统矩阵乘法算法的方法，由Volker Strassen于1969年提出。这种方法通过递归地将矩阵分解成更小的块，并运用特定的公式减少乘法操作的数量，从而降低了计算大型矩阵乘积的时间复杂度。然而，由于分治和合并过程引入了额外的开销，对于较小的矩阵，Strassen算法可能不如直接乘法有效率。
strassen矩阵乘法 java_用java写的矩阵乘法（Strassen算法）
weixin_35827671的博客
02-13 231
代码如下，可以看看数据结构的定义，时间换空间。public class Matrix {private final Matrix[] _matrixArray;private final int n;private int element;public Matrix(int n) {this.n = n;if (n != 1) {this._matrixArray = new Matrix[4];...
strassen_矩阵乘法的strassen算法_
10-02
传统矩阵乘法的时间复杂度是O(n^3)，而Strassen算法通过分治策略将这一复杂度降低到了大约O(n^log2(7))，这是因为Strassen算法将矩阵乘法分解成了7次较小的矩阵乘法。 Strassen算法的核心思想是将两个n×n的矩阵A和...
Desktop_C++_算法导论_矩阵乘法_递归_
10-03
最后，将四个结果组合成最终的矩阵C，这就是所谓的Strassen算法或分治策略的一种应用。 在代码实现中，可能会遇到内存管理的问题，比如使用`new`关键字动态分配内存。在C++中，`new`用于在堆上分配对象，这与在栈上...
TestMatrix_多种C++矩阵乘法算法_avx_
09-29
在本文中，我们将深入探讨标题为“TestMatrix_多种C++矩阵乘法算法_avx_”的项目，该项目旨在实现并比较多种C++矩阵乘法算法，特别关注使用Intel AVX（Advanced Vector Extensions）指令集的优化技术。矩阵乘法是...
zhuanzhi.rar_矩阵乘法_矩阵乘法优化_矩阵优化 c
09-14
传统的矩阵乘法算法，即基于Strassen或Coppersmith-Winograd方法的分治策略，虽然在理论上具有较好的时间复杂度，但在实际应用中，由于分割和合并操作的开销，它们的效率并不理想。 描述中提到的优化程序旨在通过...
【算法】_015_矩阵乘法_直接递归
花和尚的专栏
10-01 646
1、 2、
【算法】_008_归并排序_ 插入法优化
花和尚的专栏
10-01 358
1、 2、 /*************************************************************** *版权所有 (C)2014,长沙铁信交通科技有限公司。 * *文件名称：006_sort_merge_i.c *内容摘要：实现归并排序 *其它说明： *当前版本：V1.0 *作 者：伍定湘 *完成日期：2014年9月26日 * *修改记录1：
【算法】_003_代码版式
花和尚的专栏
10-01 356
根据周兆熊学长的文章后，修改了
【算法】_005_选择排序
花和尚的专栏
10-01 352
1、001_sort_insert.h /*************************************************************** *版权所有 (C)2014,长沙铁信交通科技有限公司。 * *文件名称：001_sort_insert.h *内容摘要：实现插入排序 *其它说明： *当前版本：V1.0 *作 者：伍定湘 *完成日期：2014年9月25日
Strassen算法实现矩阵乘法优化
"本文将介绍矩阵乘法中的Strassen算法，一种通过分治策略优化传统矩阵乘法，降低计算次数的高效算法。该算法由德国数学家 Volker Strassen 在1969年提出，其核心思想是将大矩阵分解为小矩阵，然后通过7次乘法而非8次...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值