算法分析与设计：分治递归实现斯特拉森（Strassen）矩阵乘法

最新推荐文章于 2024-05-24 09:22:23 发布
最新推荐文章于 2024-05-24 09:22:23 发布
阅读量6.6k 收藏 67
点赞数 13
分类专栏： 笔记 # 算法分析与设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SongXJ_01/article/details/109078565
版权

数据结构 c++ 算法

分治问题

分治法的基本思想是将一个规模很大的问题分解为许多规模较小的子问题，这些子问题互相独立且与原问题相同。对这些子问题递归地进行求解后合并，得到原问题的解。

斯特拉森（Strassen）矩阵乘法

设A和B是两个 n × n n \times n n×n的矩阵，其中 n n n可以写成 2 k 2^k 2k。将A和B分别等分成4个小矩阵，此时如果把A和B都当成 2 × 2 2 \times 2 2×2矩阵来看,每个元素就是一个 ( n / 2 ) × ( n / 2 ) (\mathrm{n} / 2) \times(\mathrm{n} / 2) (n/2)×(n/2) 矩阵，而矩阵A和B的乘积就可以写成
( A 11 A 12 A 21 A 22 ) ( B 11 B 12 B 21 B 22 ) = ( C 11 C 12 C 21 C 22 ) \left(\begin{array}{ll} A_{11} & A_{12} \\ A_{21} & A_{22} \end{array}\right)\left(\begin{array}{ll} B_{11} & B_{12} \\ B_{21} & B_{22} \end{array}\right)=\left(\begin{array}{ll} C_{11} & C_{12} \\ C_{21} & C_{22} \end{array}\right) (A11​A21​​A12​A22​​)(B11​B21​​B12​B22​​)=(C11​C21​​C12​C22​​)
其中利用斯特拉森方法得到7个小矩阵，分别定义为:
M 1 = A 11 ( B 12 − B 22 ) M 2 = ( A 11 + A 12 ) B 22 M 3 = ( A 21 + A 22 ) B 11 M 4 = A 22 ( B 21 − B 11 ) M 5 = ( A 11 + A 22 ) ( B 11 + B 22 ) M 6 = ( A 12 − A 22 ) ( B 21 + B 22 ) M 7 = ( A 11 − A 21 ) ( B 11 + B 12 ) \begin{array}{rl} M_{1}=& A_{11}\left(B_{12}-B_{22}\right) \\ M_{2}=&\left(A_{11}+A_{12}\right) B_{22} \\ M_{3}=&\left(A_{21}+A_{22}\right) B_{11} \\ M_{4}=& A_{22}\left(B_{21}-B_{11}\right) \\ M_{5}=&\left(A_{11}+A_{22}\right)\left(B_{11}+B_{22}\right) \\ M_{6}=&\left(A_{12}-A_{22}\right)\left(B_{21}+B_{22}\right) \\ M_{7}=&\left(A_{11}-A_{21}\right)\left(B_{11}+B_{12}\right) \\ \end{array} M1​=M2​=M3​=M4​=M5​=M6​=M7​=​A11​(B12​−B22​)(A11​+A12​)B22​(A21​+A22​)B11​A22​(B21​−B11​)(A11​+A22​)(B11​+B22​)(A12​−A22​)(B21​+B22​)(A11​−A21​)(B11​+B12​)​

矩阵 M 1 ∼ M 7 M_{1} \sim M_{7} M1​∼M7​ 可以通过7次矩阵乘法、6次矩阵加法和4次矩阵减法计算得出，前述4个小矩阵 C 1 ∼ C 4 C_{1} \sim C_{4} C1​∼C4​ 可以由矩阵 M 1 ∼ M 7 M_{1} \sim M_{7} M1​∼M7​ 通过6次矩阵加法和2次矩阵减法得出，方法如下:
C 11 = M 4 + M 5 − M 2 + M 6 C 12 = M 1 + M 2 C 21 = M 3 + M 4 C 22 = M 5 + M 1 − M 3 − M 7 \begin{aligned} C_{11}=&M_{4}+M_{5}-M_{2}+M_{6}\\ C_{12}=&M_{1}+M_{2}\\ C_{21}=&M_{3}+M_{4}\\ C_{22}=&M_{5}+M_{1}-M_{3}-M_{7} \end{aligned} C11​=C12​=C21​=C22​=​M4​+M5​−M2​+M6​M1​+M2​M3​+M4​M5​+M1​−M3​−M7​​

分析算法时间复杂度

设 T ( k ) T(k) T(k)是斯特拉森（Strassen）算法对两个 2 k 2^k 2k阶方阵进行运算所需的时间，Strassen算法中共使用了7次递归调用的矩阵乘法（即在生成 M 1 ∼ M 7 M_1\sim M_7 M1​∼M7​的7个矩阵的时候），共使用了18次矩阵加减运算（在生成 M 1 ∼ M 7 M_1\sim M_7 M1​∼M7​的时候使用了6次矩阵加法和4次矩阵减法，在生成 C 1 ∼ C 4 C_1\sim C_4 C1​∼C4​的时候使用了6次矩阵加法和2次矩阵减法）。所以其递归表达式如下：

{ T ( k ) = O ( 1 ) , ( k ≤ 1 ) T ( k ) = 7 T ( k − 1 ) + O ( 2 2 k ) , ( k ≥ 2 ) \left\{\begin{array}{ll}T(k)=O(1), & (k \leq 1) \\ T(k)=7 T(k-1)+O\left(2^{2 k}\right), & (k \geq 2)\end{array}\right. {T(k)=O(1),T(k)=7T(k−1)+O(22k),​(k≤1)(k≥2)​

令 n = 2 k n=2^k n=2k进行求解： T ( n ) = O ( n l o g 7 ) T(n)=O(n^{log7} ) T(n)=O(nlog7)，即斯特拉森算法的时间复杂度为 O ( n l o g 7 ) O(n^{log7} ) O(nlog7)。而传统的矩阵乘法中有三层 f o r for for循环，因此显然其时间复杂度为 O ( n 3 ) O(n^3) O(n3)。由此可见，Strassen矩阵乘法的计算时间复杂性比普通算法有着较大改进。

C++分治递归实现斯特拉森（Strassen）矩阵乘法

#include <iostream>
#include <string.h>

using namespace std;

/*****************************************************************
* 函数描述： 析取矩阵元素
* 函数参数： pM——矩阵指针
			nCol——使用矩阵列大小（指针取值使用）
			i——索引横坐标
			j——索引纵坐标
* 函数返回： 矩阵对应位置的元素值
*****************************************************************/
int& GetArrayVal(int* pM, int nCol, int i, int j)
{
	return *(pM + i * nCol + j);
}


/*****************************************************************
* 函数描述： 创建矩阵
			矩阵元素为 [0,5] 范围内的随机整数
* 函数参数： pM——矩阵指针
			nRow——创建矩阵的行规模
			nCol——创建矩阵的列规模
* 函数返回： void
*****************************************************************/
void CreateMatrix(int** pM, int nRow, int nCol)
{
	*pM = new int[nRow * nCol];
	memset(*pM, 0, sizeof(int*) * nRow * nCol);

	for (int i = 0; i < nRow; ++i)
	{
		for (int j = 0; j < nCol; ++j)
		{
			GetArrayVal(*pM, nCol, i, j) = rand() % 6;
		}
	}
}


/*****************************************************************
* 函数描述： 销毁矩阵(内存管理)
* 函数参数： pM——矩阵指针
* 函数返回：void
*****************************************************************/
void DeleteMatrix(int** pM)
{
	if (NULL != *pM)
	{
		delete* pM;
		*pM = NULL;
	}
}


/*****************************************************************
* 函数描述： 矩阵加减法（n阶方阵）
* 函数参数： pM1——矩阵1
			nLeftIndex1，nTopIndex1——矩阵1左上角索引点（相对于源矩阵pMl）
			nTotalCol1——矩阵1实际使用的列数
			pM2——矩阵2
			nLeftIndex2, nTopIndex2——矩阵2左上角索引点（相对于源矩阵pM2）
			nTotalCol2——矩阵2实际使用的列数
			nCount——方阵阶数n
			pResult——运算结果矩阵
			bAdd——加减标记
* 函数返回：void
*****************************************************************/
void MatrixAddOrSub(int* pM1, int nLeftIndex1, int nTopIndex1, int nTotalCol1,
	int* pM2, int nLeftIndex2, int nTopIndex2, int nTotalCol2,
	int nCount, int** pResult, bool bAdd)
{
	*pResult = new int[nCount * nCount];
	for (int i = 0; i < nCount; ++i)
	{
		for (int j = 0; j < nCount; ++j)
		{
			if (bAdd)	// 加法
			{
				GetArrayVal(*pResult, nCount, i, j) = GetArrayVal(pM1, nTotalCol1, nLeftIndex1 + i, nTopIndex1 + j)
					+ GetArrayVal(pM2, nTotalCol2, nLeftIndex2 + i, nTopIndex2 + j);
			}
			else		// 减法
			{
				GetArrayVal(*pResult, nCount, i, j) = GetArrayVal(pM1, nTotalCol1, nLeftIndex1 + i, nTopIndex1 + j)
					- GetArrayVal(pM2, nTotalCol2, nLeftIndex2 + i, nTopIndex2 + j);
			}

		}
	}
}


/*****************************************************************
* 函数描述： 矩阵乘法（n阶方阵）
* 函数参数： pM1——矩阵1
			nLeftIndex1，nTopIndex1——矩阵1左上角索引点（相对于源矩阵pMl）
			nTotalCol1——矩阵1实际使用的列数
			pM2——矩阵2
			nLeftIndex2, nTopIndex2——矩阵2左上角索引点（相对于源矩阵pM2）
			nTotalCol2——矩阵2实际使用的列数
			nCount——方阵阶数n
			pResult——运算结果矩阵
* 函数返回：void
*****************************************************************/
void MatrixMulti(int* pM1, int nLeftIndex1, int nTopIndex1, int nTotalCol1,
	int* pM2, int nLeftIndex2, int nTopIndex2, int nTotalCol2,
	int nCount, int** pResult)
{

	*pResult = new int[nCount * nCount];
	for (int i = 0; i < nCount; ++i)
	{
		for (int j = 0; j < nCount; ++j)
		{
			GetArrayVal(*pResult, nCount, i, j) = 0;
			for (int k = 0; k < nCount; ++k)
			{
				GetArrayVal(*pResult, nCount, i, j) += GetArrayVal(pM1, nTotalCol1, nLeftIndex1 + i, nTopIndex1 + k)
					* GetArrayVal(pM2, nTotalCol2, nLeftIndex2 + k, nTopIndex2 + j);
			}
		}
	}
}


/*****************************************************************
* 函数描述： 递归实现斯特拉森矩阵乘法（n阶方阵）
* 函数参数： pM1——矩阵1
			nLeftIndex1，nTopIndex1——矩阵1左上角索引点（相对于源矩阵pMl）
			nTotalCol1——矩阵1实际使用的列数
			pM2——矩阵2
			nLeftIndex2, nTopIndex2——矩阵2左上角索引点（相对于源矩阵pM2）
			nTotalCol2——矩阵2实际使用的列数
			nCount——方阵阶数n
			pResult——运算结果矩阵
* 函数返回：void
*****************************************************************/
void StrassenMatrix(int* pM1, int nLeftIndex1, int nTopIndex1, int nTotalCol1,
	int* pM2, int nLeftIndex2, int nTopIndex2, int nTotalCol2,
	int nCount, int** pResult)
{
	if (nCount == 2) // 如果当前为2阶，不能继续划分则跳出迭代
	{
		MatrixMulti(pM1, nLeftIndex1, nTopIndex1, nTotalCol1,
			pM2, nLeftIndex2, nTopIndex2, nTotalCol2, nCount, pResult);
	}
	else	// 如果当前大于2阶，拆分成4个大小相等的子矩阵，分别进行迭代
	{
		int* pResultM1 = NULL;
		int* pResultM2 = NULL;
		int* pResultM3 = NULL;
		int* pResultM4 = NULL;
		int* pResultM5 = NULL;
		int* pResultM6 = NULL;
		int* pResultM7 = NULL;

		// M1 = A11 * (B12 - B22)
		int* pB12_B22 = NULL;
		MatrixAddOrSub(pM2, nLeftIndex2, nTopIndex2 + nCount / 2, nTotalCol2,
			pM2, nLeftIndex2 + nCount / 2, nTopIndex2 + nCount / 2, nTotalCol2, nCount / 2, &pB12_B22, false);
		StrassenMatrix(pM1, nLeftIndex1, nTopIndex1, nTotalCol1,
			pB12_B22, 0, 0, nCount / 2, nCount / 2, &pResultM1);

		// M2 = (A11 + A12) * B22;
		int* pA11_A12 = NULL;
		MatrixAddOrSub(pM1, nLeftIndex1, nTopIndex1, nTotalCol1,
			pM1, nLeftIndex1, nTopIndex1 + nCount / 2, nTotalCol1, nCount / 2, &pA11_A12, true);
		StrassenMatrix(pA11_A12, 0, 0, nCount / 2,
			pM2, nLeftIndex2 + nCount / 2, nTopIndex2 + nCount / 2, nTotalCol2, nCount / 2, &pResultM2);

		// M3 = (A21 + A22) * B11;
		int* pA21_A22 = NULL;
		MatrixAddOrSub(pM1, nLeftIndex1 + nCount / 2, nTopIndex1, nTotalCol1,
			pM1, nLeftIndex1 + nCount / 2, nTopIndex1 + nCount / 2, nTotalCol1, nCount / 2, &pA21_A22, true);
		StrassenMatrix(pA21_A22, 0, 0, nCount / 2,
			pM2, nLeftIndex2, nTopIndex2, nTotalCol2, nCount / 2, &pResultM3);

		// M4 = A22 * (B21 - B11)
		int* pB21_B11 = NULL;
		MatrixAddOrSub(pM2, nLeftIndex2 + nCount / 2, nTopIndex2, nTotalCol2,
			pM2, nLeftIndex2, nTopIndex2, nTotalCol2, nCount / 2, &pB21_B11, false);
		StrassenMatrix(pM1, nLeftIndex1 + nCount / 2, nTopIndex1 + nCount / 2, nTotalCol1,
			pB21_B11, 0, 0, nCount / 2, nCount / 2, &pResultM4);


		// M5 = (A11 + A22) * (B11 + B22)
		int* pA11_A22 = NULL;
		int* pB11_B22 = NULL;
		MatrixAddOrSub(pM1, nLeftIndex1, nTopIndex1, nTotalCol1,
			pM1, nLeftIndex1 + nCount / 2, nTopIndex1 + nCount / 2, nTotalCol1, nCount / 2, &pA11_A22, true);
		MatrixAddOrSub(pM2, nLeftIndex2, nTopIndex2, nTotalCol2,
			pM2, nLeftIndex2 + nCount / 2, nTopIndex2 + nCount / 2, nTotalCol2, nCount / 2, &pB11_B22, true);
		StrassenMatrix(pA11_A22, 0, 0, nCount / 2,
			pB11_B22, 0, 0, nCount / 2, nCount / 2, &pResultM5);

		// M6 = (A12 - A22) * (B21 + B22)
		int* pA12_A22 = NULL;
		int* pB21_B22 = NULL;
		MatrixAddOrSub(pM1, nLeftIndex1, nTopIndex1 + nCount / 2, nTotalCol1,
			pM1, nLeftIndex1 + nCount / 2, nTopIndex1 + nCount / 2, nTotalCol1, nCount / 2, &pA12_A22, false);
		MatrixAddOrSub(pM2, nLeftIndex2 + nCount / 2, nTopIndex2, nTotalCol2,
			pM2, nLeftIndex2 + nCount / 2, nTopIndex2 + nCount / 2, nTotalCol2, nCount / 2, &pB21_B22, true);
		StrassenMatrix(pA12_A22, 0, 0, nCount / 2,
			pB21_B22, 0, 0, nCount / 2, nCount / 2, &pResultM6);

		// M7 = (A11 - A21) * (B11 + B12)
		int* pA11_A21 = NULL;
		int* pB11_B12 = NULL;
		MatrixAddOrSub(pM1, nLeftIndex1, nTopIndex1, nTotalCol1,
			pM1, nLeftIndex1 + nCount / 2, nTopIndex1, nTotalCol1, nCount / 2, &pA11_A21, false);
		MatrixAddOrSub(pM2, nLeftIndex2, nTopIndex2, nTotalCol2,
			pM2, nLeftIndex2, nTopIndex2 + nCount / 2, nTotalCol2, nCount / 2, &pB11_B12, true);
		StrassenMatrix(pA11_A21, 0, 0, nCount / 2,
			pB11_B12, 0, 0, nCount / 2, nCount / 2, &pResultM7);


		int* pResultC11 = NULL;
		int* pResultC12 = NULL;
		int* pResultC21 = NULL;
		int* pResultC22 = NULL;
		int* pResultTemp1 = NULL;
		int* pResultTemp2 = NULL;

		// C11 = M5 + M4 - M2 + M6
		MatrixAddOrSub(pResultM5, 0, 0, nCount / 2,
			pResultM4, 0, 0, nCount / 2, nCount / 2, &pResultTemp1, true);
		MatrixAddOrSub(pResultTemp1, 0, 0, nCount / 2,
			pResultM2, 0, 0, nCount / 2, nCount / 2, &pResultTemp2, false);
		MatrixAddOrSub(pResultTemp2, 0, 0, nCount / 2,
			pResultM6, 0, 0, nCount / 2, nCount / 2, &pResultC11, true);


		// C12 = M1 + M2
		MatrixAddOrSub(pResultM1, 0, 0, nCount / 2,
			pResultM2, 0, 0, nCount / 2, nCount / 2, &pResultC12, true);

		// C21 = M3 + M4 
		MatrixAddOrSub(pResultM3, 0, 0, nCount / 2,
			pResultM4, 0, 0, nCount / 2, nCount / 2, &pResultC21, true);

		// C22 = M5 + M1 - M3 - M7
		MatrixAddOrSub(pResultM5, 0, 0, nCount / 2,
			pResultM1, 0, 0, nCount / 2, nCount / 2, &pResultTemp1, true);
		MatrixAddOrSub(pResultTemp1, 0, 0, nCount / 2,
			pResultM3, 0, 0, nCount / 2, nCount / 2, &pResultTemp2, false);
		MatrixAddOrSub(pResultTemp2, 0, 0, nCount / 2,
			pResultM7, 0, 0, nCount / 2, nCount / 2, &pResultC22, false);


		// 构造结果
		*pResult = new int[nCount * nCount];
		for (int i = 0; i < nCount / 2; ++i)
		{
			for (int j = 0; j < nCount / 2; ++j)
			{
				GetArrayVal(*pResult, nCount, i, j) = GetArrayVal(pResultC11, nCount / 2, i, j);
				GetArrayVal(*pResult, nCount, i, j + nCount / 2) = GetArrayVal(pResultC12, nCount / 2, i, j);
				GetArrayVal(*pResult, nCount, i + nCount / 2, j) = GetArrayVal(pResultC21, nCount / 2, i, j);
				GetArrayVal(*pResult, nCount, i + nCount / 2, j + nCount / 2) = GetArrayVal(pResultC22, nCount / 2, i, j);

			}
		}

		//释放内存
		DeleteMatrix(&pResultM1);
		DeleteMatrix(&pResultM2);
		DeleteMatrix(&pResultM3);
		DeleteMatrix(&pResultM4);
		DeleteMatrix(&pResultM5);
		DeleteMatrix(&pResultM6);
		DeleteMatrix(&pResultM7);
		DeleteMatrix(&pA11_A12);
		DeleteMatrix(&pA21_A22);
		DeleteMatrix(&pB12_B22);
		DeleteMatrix(&pB21_B11);
		DeleteMatrix(&pA11_A22);
		DeleteMatrix(&pB11_B22);
		DeleteMatrix(&pA12_A22);
		DeleteMatrix(&pB21_B22);
		DeleteMatrix(&pA11_A21);
		DeleteMatrix(&pB11_B12);
		DeleteMatrix(&pResultTemp1);
		DeleteMatrix(&pResultTemp2);
		DeleteMatrix(&pResultC11);
		DeleteMatrix(&pResultC12);
		DeleteMatrix(&pResultC21);
		DeleteMatrix(&pResultC22);

	}
}

/*****************************************************************
* 函数描述： 打印矩阵
* 函数参数： pM——矩阵指针
			nRow——矩阵行规模
			nCol——矩阵列规模
* 函数返回：void
*****************************************************************/
void PrintMatrix(int* pM, int nRow, int nCol)
{
	for (int i = 0; i < nRow; ++i)
	{
		for (int j = 0; j < nCol; ++j)
		{
			cout << GetArrayVal(pM, nCol, i, j) << " ";
		}
		cout << endl;
	}
}

int main()
{
	srand(0);	// 随机数种子

	int* pM1 = NULL;
	int* pM2 = NULL;
	int* pMResult1 = NULL;
	int nRow1, nCol1, nRow2, nCol2;

	// 测试4阶方阵乘法
	nRow1 = 4;
	nCol1 = 4;
	nRow2 = 4;
	nCol2 = 4;

	// 测试8阶方阵乘法
	//nRow1 = 8;
	//nCol1 = 8;
	//nRow2 = 8;
	//nCol2 = 8;

	// 随机构建两个矩阵，并打印
	CreateMatrix(&pM1, nRow1, nCol1);
	CreateMatrix(&pM2, nRow2, nCol2);
	cout << "\nMatrix A:" << endl;
	PrintMatrix(pM1, nRow1, nCol1);
	cout << "\nMatrix B:" << endl;
	PrintMatrix(pM2, nRow2, nCol2);

	// 使用普通方法计算矩阵乘法
	cout << "\nGeneral matrix multiplication:" << endl;
	MatrixMulti(pM1, 0, 0, nRow1, pM2, 0, 0, nRow1, nRow1, &pMResult1);
	PrintMatrix(pMResult1, nRow1, nCol2);

	// 使用斯特拉森方法计算矩阵乘法
	cout << "\nStrassen matrix multiplication:" << endl;
	StrassenMatrix(pM1, 0, 0, nRow1, pM2, 0, 0, nRow1, nRow1, &pMResult1);
	PrintMatrix(pMResult1, nRow1, nCol2);

	//内存释放
	DeleteMatrix(&pM1);
	DeleteMatrix(&pM2);
	DeleteMatrix(&pMResult1);
	cout << "-----------------------------------" << endl;

	return 0;
}

代码输出

阶数为4的矩阵乘法

阶数为8的矩阵乘法

参考：https://blog.csdn.net/s634772208/article/details/46594707

SongXJ--
关注
  • 13
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
简单递归实现矩阵相乘
砖家
11-15 2119
《算法导论》的课后习题中有这么一道题--要求用简单递归方法实现矩阵相乘。我的代码还不完善，现在只能做两个(2^n)*（2^n）类型的矩阵相乘，例如：2*2 、4*4、8*8的矩阵 但这并不妨碍体现 伪代码到c语言代码的转换核心，即坐标计算：采用基地址加偏移量来计算。#include #include #define M1 (p1->w-p1->x+1) #define N1 (p1->z-p
矩阵乘法递归求解
weixin_30652491的博客
06-26 712
给定两个N×N的矩阵，求乘积 如下图所示，乘法执行过程如下： 1.矩阵1先拿出一行，矩阵2先拿出一列 2.行与列相乘得到value1 3.行与剩下矩阵2相乘得到value2（递归过程） 4.剩下矩阵1与列相乘得到value3（递归过程） 5.剩下矩阵1与剩下矩阵2相乘得到value4（递归过程） 6.将value1~value4合并成结果数组 写代码时注意约定，val...
c++ 分而治之（施特拉森矩阵乘法）
最新发布
csdn_aspnet的专栏
05-24 550
在上面的分而治之的方法中，高时间复杂度的主要成分是8次递归调用。Strassen 方法与上述简单的分而治之方法类似，该方法也将矩阵划分为大小为 N/2 x N/2 的子矩阵：如上图所示，但在Strassen方法中，结果的四个子矩阵是使用以下公式计算的。在上述方法中，我们对大小为 N/2 x N/2 的矩阵进行 8 次乘法和 4 次加法。1、将矩阵 A 和 B 分为 4 个大小为 N/2 x N/2 的子矩阵，如下图所示。2、对于稀疏矩阵，有专门为其设计的更好的方法。上述方法的时间复杂度为O(N 3 )。
矩阵乘法的递归实现
小猪爱拱地
09-10 1569
根据算法导论里的矩阵乘法递归的思想实现 #if 0 int a[8][8] = { {1,2,3,4,5,6,7,8}, {2,3,4,5,6,7,8,9}, {3,4,5,6,7,8,9,10}, {4,5,6,7,8,9,10,11}, {5,6,7,8,9,10,11,12}, {6,7,8,9,10,11,12,13}, {7,8,9,1...
Strassen矩阵乘法 分治与递归
yuebao的专栏
01-07 4752
转自：http://blog.sina.com.cn/s/blog_7e9a88f70100zj2h.html Strassen矩阵乘法 矩阵乘法是线性代数中最常见的运算之一，它在数值计算中有广泛的应用。若A和B是2个n×n的矩阵，则它们的乘积C=AB同样是一个n×n的矩阵。A和B的乘积矩阵C中的元素C[i,j]定义为: 分治与递归--strassen矩阵乘法 若依此定义来
递归矩阵乘法c语言,递归矩阵乘法(Recursive matrix multiplication)
weixin_42202724的博客
05-18 416
我读算法导论由CLRS。 本书展示了简单的分而治之矩阵乘法伪代码：n = A.rowslet c be a new n x n matrixif n == 1c11 = a11 * b11else partition A, B, and CC11 = SquareMatrixMultiplyRecursive(A11, B11)+ SquareMatrixMultiplyRecursive(A1...
strassen算法实现
08-14
strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ 可以看到上面只有7次乘法和多次加减法，最终达到降低复杂度为O( n^lg7 ) ~= O( n^2.81 );
递归与分治之Srassen矩阵乘法
weixin_44952817的博客
11-25 314
Srassen矩阵乘法 矩阵乘法的传统做法的复杂度：O（n^3） 使用分治法的方法跟处理大整数乘法的做法一致，就是拆分矩阵，最后合并。只不过这次我们是将矩阵分割为几个大小相等的子矩阵，具体如下： 这里的A,B,C都代指矩阵块，而非矩阵中的元素。 显然其复杂度仍然是O（n^3） 为了降低复杂度我们仍选择用加法来替代乘法，只不过这次的元素将比大整数乘法中复杂得多。 此时的复杂度O（n^(log7)）=O(n^(2.81)) 据研究，目前最好的计算时间上界是O（n^2.376） ...
Strassen矩阵算法的实现
hello_bravo_的博客
05-30 600
仅仅针对2的幂次数阶的矩阵，时间复杂度O(n^lg7)#include <iostream>using namespace std; void gerResultStrassen(int **arr, int **brr, int n, int **crr) { if (n == 1) { crr[0][0] += arr[0][0] * brr[0][0];
算法导论-矩阵乘法-strassen算法
weixin_30633405的博客
09-09 432
目录 1、矩阵相乘的朴素算法 2、矩阵相乘的strassen算法 3、完整测试代码c++ 4、性能分析 5、参考资料 内容 ...
五、分治法应用--矩阵乘法
runing
01-17 2495
1 朴素算法 这个算法就是矩阵乘法的定义： 很容易看出这个算法复杂度是Θ(n3)\Theta(n^3)Θ(n3)。 2 递归算法 分治法首先是从分割问题开始的，得到数学上的递归关系后，然后使用递归的方式实现。 由上面的数学性质，可以使用递归实现： T(n)=8T(n/2)+Θ(n2)T(n)=8T(n/2)+\Theta(n^2)T(n)=8T(n/2)+Θ(n2)，应用主定理可知，T(n)=Θ(n3)T(n)=\Theta(n^3)T(n)=Θ(n3)，没有什么进步，不过这里分割思路是没有问题
矩阵乘法的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; strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ strassen的处理是： 令： p1 = a * ( f - h ) p2 = ( a + b ) * h p3 = ( c +d ) * e p4 = d * ( g - e ) p5 = ( a + d ) * ( e + h ) p6 = ( b - d ) * ( g + h ) p7 = ( a - c ) * ( e + f ) 那么我们可以知道： r = p5 + p4 + p6 - p2 s = p1 + p2 t = p3 + p4 u = p5 + p1 - p3 - p7
Strassen 算法 C++ 实现 任意矩阵相乘
11-18
Strassen 算法 C++ 实现 任意矩阵相乘 用Command line 输入编制好的两个矩阵，输出相乘的结果矩阵。如果需要手动输入，删除程序里的相关语句，添加输入命令即可。
Strassen矩阵算法分析及其C++实现 递归分治法（转）
weixin_30394333的博客
04-11 169
对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示： 从上图可以看出这种分块相乘总共用了8次乘法，当然对于子矩阵相乘（如A0×B0），还可以继续递归使用分块相乘。对于中小矩阵来说，很适合使用这种分块乘法，但是对于大矩阵来说，递归的次数较多，如果能减少每次分块乘法的次数，那么性能将可以得到很好的提高。 Strassen矩阵乘法就是采用了一个简单的运算...
《算法导论》：矩阵乘法的Strassen算法代码实现
Toby的博客
09-04 869
本文为《算法导论》：矩阵乘法的Strassen算法代码实现，欢迎参考，期待您的关注！
c++实现Strassen算法 与朴素算法时间复杂度对比及优化（含源码）
qq_55582202的博客
10-10 1286
c++实现Strassen算法 与朴素算法对比及优化 编程实现普通的矩阵乘法； 编程实现 Strassen’s algorithm； 在不同数据规模情况下（数据规模）下，比较两种算法的运行时间各是多少； 修改 Strassen’s algorithm，使之适应矩阵规模 N 不是 2 的幂的情况； 改进后的算法与 2 中的算法在相同数据规模下进行比较。 设计实验 将给出的实验数据写入 datas.txt 文件，为控制变量，两种算法分别从文件中读取数据。记录从数据读入到计算完成所用时间，取 5 次实验得
用C语言实现strassen算法,C++ Strassen算法代码的实现
weixin_39943750的博客
05-24 774
本文仅代码，无理论解释实话实说，我觉得这个算法在C系列的语言下，简直垃圾到爆炸……毕竟是一群完全不懂程序数学家对着纸弄出来的，看起来好像非常的有用，实际上耗时是非常爆炸的。但是《算法导论》里有啊……然后上课又要求手写一个于是我就手写了一个……我尽可能的减少使用的空间同时加快速度了，当 n = 512 的时候，内存使用量峰值没有超过 10mb，而且是通过递归实现 Strassen 算法其中，in.t...
矩阵乘法 递归 优化 c语言,递归+优化 一维数组实现矩阵乘法
weixin_31596631的博客
05-17 497
1.计算T(n)队列，规则是T(n) = T(n - 1) + T(n - 2) + T(n -3)，其中T(0) = T(1) = 1，T(2) = 2。函数定义：int Tribonaci(int n) {}备注，不考虑证整数溢出，尽可能优化算法。这一题我一看就知道要考什么，很显然的递归定义，但也是很显然的，这里所谓的优化是指不要重复计算。简单的说，在计算T(n)的时候要用到T(n - 1)、...
分治策略之矩阵乘法的几种实现
爱你的推理能手
10-27 6544
欢迎关注，定期更新算法问题 今天介绍一下分治算法的一个典型例子——矩阵乘法 如果以前了解过矩阵，应该知道矩阵的乘法公式C(m,n)=A(m,k)*B(k,n)，在这里我们只讨论方阵，假设A是n*n阶，B也是n*n阶，那么要计算乘积需要进行n^2个元素，看《算法导论》给出的伪码： 上边这个过程进行三次循环，每次循环执行n步，故花费时间是O(n^3)，下边是代码实现： void
分治策略实现斯特拉森矩阵乘法
09-30
斯特拉森矩阵乘法的分治策略实现如下： 1. 将矩阵A和矩阵B划分为4个大小相等的子矩阵，每个子矩阵的大小为原矩阵的一半。 2. 对于每个子矩阵，递归地计算以下7个临时矩阵： - S1 = B12 - B22 - S2 = A11 + A12 - S3 = A21 + A22 - S4 = B21 - B11 - S5 = A11 + A22 - S6 = B11 + B22 - S7 = A12 - A22 3. 递归地计算以下7个中间矩阵： - P1 = A11 * S1 - P2 = S2 * B22 - P3 = S3 * B11 - P4 = A22 * S4 - P5 = S5 * S6 - P6 = S7 * S1 - P7 = S5 * S4 4. 计算结果矩阵C的4个子矩阵： - C11 = P5 + P4 - P2 + P6 - C12 = P1 + P2 - C21 = P3 + P4 - C22 = P5 + P1 - P3 - P7 5. 将4个子矩阵组合成新矩阵C。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值