Strassen算法

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

–《算法导论第三版》第4章 分治策略
Strassen算法的核心思想是令递归树稍微不那么茂盛一点儿， 即只递归进行7次而不是8次 n 2 \frac{n}{2} 2n​ × n 2 \frac{n}{2} 2n​矩阵的乘法。减少一次矩阵乘法带来的代价可能是额外几次 n 2 \frac{n}{2} 2n​ × n 2 \frac{n}{2} 2n​矩阵的加法，但只是常数次 。

假定将A，B和C均分解为4个 n 2 \frac{n}{2} 2n​ × n 2 \frac{n}{2} 2n​的子矩阵：
A = [ A 11 A 12 A 21 A 22 ] , B = [ B 11 B 12 B 21 B 22 ] , C = [ C 11 C 12 C 21 C 22 ] A = \begin{bmatrix} A_{11} & A_{12} \\A_{21} & A_{22} \end{bmatrix}, B = \begin{bmatrix} B_{11} & B_{12} \\B_{21} & B_{22} \end{bmatrix}, C =\begin{bmatrix} C_{11} & C_{12} \\C_{21} & C_{22} \end{bmatrix} A=[A11​A21​​A12​A22​​],B=[B11​B21​​B12​B22​​],C=[C11​C21​​C12​C22​​]
因此可将公式 C = A ⋅ B C = A \cdot B C=A⋅B改写成
[ C 11 C 12 C 21 C 22 ] = [ A 11 A 12 A 21 A 22 ] ⋅ [ B 11 B 12 B 21 B 22 ] \begin{bmatrix} C_{11} & C_{12} \\C_{21} & C_{22} \end{bmatrix} = \begin{bmatrix} A_{11} & A_{12} \\A_{21} & A_{22} \end{bmatrix} \cdot \begin{bmatrix} B_{11} & B_{12} \\B_{21} & B_{22} \end{bmatrix} [C11​C21​​C12​C22​​]=[A11​A21​​A12​A22​​]⋅[B11​B21​​B12​B22​​]
则：
C 11 = A 11 ⋅ B 11 + A 12 ⋅ B 21 C 12 = A 11 ⋅ B 12 + A 22 ⋅ B 21 C 21 = A 21 ⋅ B 11 + A 22 ⋅ B 21 C 22 = A 21 ⋅ B 12 + A 22 ⋅ B 22 C_{11} = A_{11} \cdot B_{11} + A_{12} \cdot B_{21}\\ C_{12} = A_{11} \cdot B_{12} + A_{22} \cdot B_{21}\\ C_{21} = A_{21} \cdot B_{11} + A_{22} \cdot B_{21}\\ C_{22} = A_{21} \cdot B_{12} + A_{22} \cdot B_{22} C11​=A11​⋅B11​+A12​⋅B21​C12​=A11​⋅B12​+A22​⋅B21​C21​=A21​⋅B11​+A22​⋅B21​C22​=A21​⋅B12​+A22​⋅B22​
Strassen算法包含四步

  1. 按上述方法将A，B，C分解（花费时间 Θ ( 1 ) \Theta(1) Θ(1)）。

  2. 如下创建10个 n 2 \frac{n}{2} 2n​ × n 2 \frac{n}{2} 2n​的矩阵 S 1 , S 2 , . . . , S 10 S_1, S_2, ..., S_{10} S1​,S2​,...,S10​，（花费时间 Θ ( n 2 ) \Theta(n^2) Θ(n2)）。
    S 1 = B 12 − B 22 S 2 = A 11 + A 12 S 3 = A 21 + A 22 S 4 = B 21 − B 11 S 5 = A 11 + A 22 S 6 = B 11 + B 22 S 7 = A 12 − A 22 S 8 = B 21 + B 22 S 9 = A 11 − A 21 S 10 = B 11 + B 12 S_1 = B_{12} - B_{22}\\ S_2 = A_{11} + A_{12}\\ S_3 = A_{21} + A_{22}\\ S_4 = B_{21} - B_{11}\\ S_5 = A_{11} + A_{22}\\ S_6 = B_{11} + B_{22}\\ S_7 = A_{12} - A_{22}\\ S_8 = B_{21} + B_{22}\\ S_9 = A_{11} - A_{21}\\ S_{10} = B_{11} + B_{12} S1​=B12​−B22​S2​=A11​+A12​S3​=A21​+A22​S4​=B21​−B11​S5​=A11​+A22​S6​=B11​+B22​S7​=A12​−A22​S8​=B21​+B22​S9​=A11​−A21​S10​=B11​+B12​

  3. 如下递归地计算7个矩阵积 P 1 , P 2 , . . . , P 7 P_1, P_2, ..., P_7 P1​,P2​,...,P7​。每个矩阵 P i P_i Pi​都是 n 2 \frac{n}{2} 2n​ × n 2 \frac{n}{2} 2n​的。

P 1 = A 11 ⋅ S 1 = A 11 ⋅ B 12 − A 11 ⋅ B 22 P 2 = S 2 ⋅ B 22 = A 11 ⋅ B 22 + A 12 ⋅ B 22 P 3 = S 3 ⋅ B 11 = A 21 ⋅ B 11 + A 22 ⋅ B 11 P 4 = A 22 ⋅ S 4 = A 22 ⋅ B 21 − A 22 ⋅ B 11 P 5 = S 5 ⋅ S 6 = A 11 ⋅ B 11 + A 11 ⋅ B 22 + A 22 ⋅ B 11 + A 22 ⋅ B 22 P 6 = S 7 ⋅ S 8 = A 12 ⋅ B 21 + A 12 ⋅ B 22 − A 22 ⋅ B 21 − A 22 ⋅ B 22 P 7 = S 9 ⋅ S 10 = A 11 ⋅ B 11 + A 11 ⋅ B 12 − A 21 ⋅ B 11 − A 21 ⋅ B 12 P_1 = A_{11} \cdot S_1 = A_{11} \cdot B_{12} - A_{11} \cdot B_{22}\\ P_2 = S_2 \cdot B_{22} = A_{11} \cdot B_{22} + A_{12} \cdot B_{22}\\ P_3 = S_3 \cdot B_{11} = A_{21} \cdot B_{11} + A_{22} \cdot B_{11}\\ P_4 = A_{22} \cdot S_4 = A_{22}\cdot B_{21} - A_{22} \cdot B_{11}\\ P_5 = S_5 \cdot S_6 = A_{11} \cdot B_{11} + A_{11} \cdot B_{22} + A_{22} \cdot B_{11} + A_{22} \cdot B_{22}\\ P_6 = S_7 \cdot S_8 = A_{12} \cdot B_{21} + A{12} \cdot B_{22} - A_{22} \cdot B_{21} - A_{22} \cdot B_{22}\\ P_7 = S_9 \cdot S_{10}= A_{11} \cdot B_{11} + A_{11} \cdot B_{12} - A_{21} \cdot B_{11} - A_{21} \cdot B_{12} P1​=A11​⋅S1​=A11​⋅B12​−A11​⋅B22​P2​=S2​⋅B22​=A11​⋅B22​+A12​⋅B22​P3​=S3​⋅B11​=A21​⋅B11​+A22​⋅B11​P4​=A22​⋅S4​=A22​⋅B21​−A22​⋅B11​P5​=S5​⋅S6​=A11​⋅B11​+A11​⋅B22​+A22​⋅B11​+A22​⋅B22​P6​=S7​⋅S8​=A12​⋅B21​+A12⋅B22​−A22​⋅B21​−A22​⋅B22​P7​=S9​⋅S10​=A11​⋅B11​+A11​⋅B12​−A21​⋅B11​−A21​⋅B12​
注意，上述公式中只有中间一列需要计算。

  1. 通过 P i P_i Pi​计算 C 11 , C 12 , C 21 , C 22 C_{11}, C_{12}, C_{21}, C_{22} C11​,C12​,C21​,C22​，（花费时间 Θ ( n 2 ) \Theta(n^2) Θ(n2)）。
    C 11 = P 5 + P 4 − P 2 + P 6 C 12 = P 1 + P 2 C 21 = P 3 + P 4 C 22 = P 5 + P 1 − P 3 − P 7 C_{11} = P_5 + P_4 - P_2 + P_6\\ C_{12} = P_1 + P_2\\ C_{21} = P_3 + P_4\\ C_{22} = P_5 + P_1 - P_3 - P_7 C11​=P5​+P4​−P2​+P6​C12​=P1​+P2​C21​=P3​+P4​C22​=P5​+P1​−P3​−P7​

可得如下递归式：
T ( n ) = { Θ ( 1 ) 若 n = 1 7 T ( n 2 ) + Θ ( n 2 ) 若 n > 1 T(n) = \begin{cases}\Theta(1) & 若n = 1\\7T(\frac{n}{2}) + \Theta(n^2) & 若n> 1\end{cases} T(n)={Θ(1)7T(2n​)+Θ(n2)​若n=1若n>1​
在这里插入图片描述
由递归树或主方法可得：
T ( n ) = Θ ( n l g 7 ) T(n) = \Theta(n^{lg7}) T(n)=Θ(nlg7)

C++实现如下：

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;
 
 
template <typename T>
class Strassen
{
public:
	void ADD(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void SUB(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void NormalMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void StrassenMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size);
	void FillMatrix(T **  MatrixA, T ** MatrixB, int size);//给A、B矩阵赋初值
	int   GetMatrixSum(T ** Matrix, int size);
	//用来计算矩阵各个元素的和，如果两种算法得出的矩阵的和相等则认为算法正确。
};
 
template <typename T>
void Strassen<T>::ADD(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = MatrixA[i][j] + MatrixB[i][j];
		}
	}
}
 
template <typename T>
void Strassen<T>::SUB(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = MatrixA[i][j] - MatrixB[i][j];
		}
	}
}

template <typename T>
void Strassen<T>::NormalMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixResult[i][j] = 0;
			for(int k = 0; k < size; k++)
				MatrixResult[i][j] += MatrixA[i][k] * MatrixB[k][j];
		}
	}
}
 
template <typename T>
void Strassen<T>::FillMatrix(T **  MatrixA, T ** MatrixB, int size)//给A、B矩阵赋初值
{
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			MatrixA[i][j] = MatrixB[i][j] = rand() % 5; 
		}
	}	
}
 
template <typename T>
void Strassen<T>::StrassenMul(T **  MatrixA, T ** MatrixB, T ** MatrixResult, int size)
{
	// if ( size <= 64 )    
	//分治门槛，小于这个值时不再进行递归计算，而是采用常规矩阵计算方法
	// {
	// 	NormalMul(MatrixA, MatrixB, MatrixResult, size);
	// }
	if(size == 1)
	{
		MatrixResult[0][0] = MatrixA[0][0] * MatrixB[0][0];
	}
	else
	{
		int half_size = size / 2;
		T ** A11; T ** A12; T ** A21; T ** A22;
		T ** B11; T ** B12; T ** B21; T ** B22;
		T ** C11; T ** C12; T ** C21; T** C22;
		T ** M1; T ** M2; T ** M3; T ** M4; T ** M5; T ** M6; T ** M7;
		T ** MatrixTemp1; T ** MatrixTemp2;
 
		A11 = new int * [half_size];
		A12 = new int * [half_size];
		A21 = new int * [half_size];
		A22 = new int * [half_size];
 
		B11 = new int * [half_size];
		B12 = new int * [half_size];
		B21 = new int * [half_size];
		B22 = new int * [half_size];
 
		C11 = new int * [half_size];
		C12 = new int * [half_size];
		C21 = new int * [half_size];
		C22 = new int * [half_size];
 
		M1 = new int * [half_size];
		M2 = new int * [half_size];
		M3 = new int * [half_size];
		M4 = new int * [half_size];
		M5 = new int * [half_size];
		M6 = new int * [half_size];
		M7 = new int * [half_size];
		MatrixTemp1 = new int * [half_size];
		MatrixTemp2 = new int * [half_size];
 
		for(int i = 0; i < half_size; i++)
		{
			A11[i] = new int[half_size];	
			A12[i] = new int[half_size];	
			A21[i] = new int[half_size];	
			A22[i] = new int[half_size];
			
			B11[i] = new int[half_size];	
			B12[i] = new int[half_size];	
			B21[i] = new int[half_size];	
			B22[i] = new int[half_size];
			
			C11[i] = new int[half_size];	
			C12[i] = new int[half_size];	
			C21[i] = new int[half_size];	
			C22[i] = new int[half_size];
 
			M1[i] = new int[half_size];	
			M2[i] = new int[half_size];	
			M3[i] = new int[half_size];	
			M4[i] = new int[half_size];
			M5[i] = new int[half_size];	
			M6[i] = new int[half_size];	
			M7[i] = new int[half_size];
 
			MatrixTemp1[i] = new int[half_size];	
			MatrixTemp2[i] = new int[half_size];
		}
 
		//赋值
		for(int i = 0; i < half_size; i++)
		{
			for(int j = 0; j < half_size; j++)
			{
				A11[i][j] = MatrixA[i][j];
				A12[i][j] = MatrixA[i][j+half_size];
				A21[i][j] = MatrixA[i+half_size][j];
				A22[i][j] = MatrixA[i+half_size][j+half_size];
 
				B11[i][j] = MatrixB[i][j];
				B12[i][j] = MatrixB[i][j+half_size];
				B21[i][j] = MatrixB[i+half_size][j];
				B22[i][j] = MatrixB[i+half_size][j+half_size];
			}
		}		
 
		//calculate M1
		ADD(A11, A22, MatrixTemp1, half_size);
		ADD(B11, B22, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M1,half_size);
 
		//calculate M2
		ADD(A21, A22, MatrixTemp1, half_size);
		StrassenMul(MatrixTemp1, B11, M2, half_size);
 
		//calculate M3
		SUB(B12, B22, MatrixTemp1, half_size);
		StrassenMul(A11, MatrixTemp1, M3, half_size);
 
 
		//calculate M4
		SUB(B21, B11, MatrixTemp1, half_size);
		StrassenMul(A22, MatrixTemp1, M4, half_size);
 
		//calculate M5
		ADD(A11, A12, MatrixTemp1, half_size);
		StrassenMul(MatrixTemp1, B22, M5, half_size);
 
		//calculate M6
		SUB(A21, A11, MatrixTemp1, half_size);
		ADD(B11, B12, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M6, half_size);
 
		//calculate M7
		SUB(A12, A22, MatrixTemp1, half_size);
		ADD(B21, B22, MatrixTemp2, half_size);
		StrassenMul(MatrixTemp1, MatrixTemp2, M7, half_size);
 
		//C11
		ADD(M1, M4, C11, half_size);
		SUB(C11, M5, C11, half_size);
		ADD(C11, M7, C11, half_size);
 
		//C12
		ADD(M3, M5, C12, half_size);
 
		//C21
		ADD(M2, M4, C21, half_size);
 
		//C22
		SUB(M1, M2, C22, half_size);
		ADD(C22, M3, C22, half_size);
		ADD(C22, M6, C22, half_size);
 
		//赋值
		for(int i = 0; i < half_size; i++)
		{
			for(int j = 0; j < half_size; j++)
			{
				MatrixResult[i][j] = C11[i][j];
				MatrixResult[i][j+half_size] = C12[i][j];
				MatrixResult[i+half_size][j] = C21[i][j];
				MatrixResult[i+half_size][j+half_size] = C22[i][j];
			}
		}
 
		//释放申请的内存
		for(int i = 0; i < half_size; i++)
		{
			delete[] A11[i];	
			delete[] A12[i];	
			delete[] A21[i];	
			delete[] A22[i];
			
			delete[] B11[i];	
			delete[] B12[i];	
			delete[] B21[i];	
			delete[] B22[i];
			
			delete[] C11[i];	
			delete[] C12[i];	
			delete[] C21[i];	
			delete[] C22[i];
 
			delete[] M1[i];	
			delete[] M2[i];	
			delete[] M3[i];	
			delete[] M4[i];	
			delete[] M5[i];	
			delete[] M6[i];	
			delete[] M7[i];
			
			delete[] MatrixTemp1[i];	
			delete[] MatrixTemp2[i];
		}
		delete[] A11;	
		delete[] A12;	
		delete[] A21;	
		delete[] A22;
		
		delete[] B11;	
		delete[] B12;	
		delete[] B21;	
		delete[] B22;
		
		delete[] C11;	
		delete[] C12;	
		delete[] C21;	
		delete[] C22;
 
		delete[] M1;	
		delete[] M2;	
		delete[] M3;	
		delete[] M4;	
		delete[] M5;	
		delete[] M6;	
		delete[] M7;
		
		delete[] MatrixTemp1;	
		delete[] MatrixTemp2;
	}
}
 
template <typename T>
int   Strassen<T>::GetMatrixSum(T ** Matrix, int size)
{
	int sum = 0;
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			sum += Matrix[i][j];
		}
	}	
	return sum;
}
 
int main()
{
	long startTime_normal, endTime_normal;
	long startTime_strasse, endTime_strassen;
 
	//srand(time(0));
 
	Strassen<int> stra;
	int N;
	cout<<"please input the size of Matrix,and the size must be the power of 2:"<<endl;
	cin>>N;
 
	int ** Matrix1 = new int * [N];
	int ** Matrix2 = new int * [N];
	int ** Matrix3 = new int * [N];
	for(int i=0;i<N;i++)
	{
		Matrix1[i] = new int[N];
		Matrix2[i] = new int[N];
		Matrix3[i] = new int[N];
	}
 
	stra.FillMatrix(Matrix1, Matrix2,N);
 
	cout << "朴素算法开始时间：" << (startTime_normal = clock()) << endl;
	stra.NormalMul(Matrix1, Matrix2, Matrix3,N);
	cout << "朴素算法结束时间：" << (endTime_normal = clock()) << endl;
	cout << "总时间:" << endTime_normal-startTime_normal << endl;
	cout << "sum = " << stra.GetMatrixSum(Matrix3,N) << ';' << endl;
 
	cout << "Strassen算法开始时间：" << (startTime_strasse= clock()) << endl;
	stra.StrassenMul(Matrix1,Matrix2,Matrix3,N);
	cout << "Strassen算法结束时间：" << (endTime_strassen = clock()) << endl;
	cout << "总时间:" << endTime_strassen-startTime_strasse << endl;
	cout << "sum = " << stra.GetMatrixSum(Matrix3,N) << ';' << endl;
}
Liilc
关注
  • 8
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
java实现任意矩阵Strassen算法
09-02
Strassen算法是一种高效的矩阵乘法算法，由德国数学家Gustav Strassen在1969年提出。它通过分治策略将大矩阵的乘法分解为更小矩阵的乘法，减少了运算次数，尤其在处理大型矩阵时，相比传统的矩阵乘法方法，其效率有...
斯特拉森(Strassen)算法
weixin_43736127的博客
12-21 9893
斯特拉森算法简介 先套用一下百度百科： 功能快捷键 合理的创建标题，有助于目录的生成 如何改变文本的样式 C语言描述 #include <stdio.h> #include<malloc.h> int MUL( int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize ); int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixS
《算法导论》第四章-矩阵乘法的Strassen算法（含C++代码）
Toby的博客
07-26 2357
本文为《算法导论》第四章-4.2-矩阵乘法的Strassen方法笔记，欢迎大家参考。
[算法系列之十五]Strassen矩阵相乘算法
SmartSi
02-06 1102
引言 Strassen矩阵乘法是一种典型的分治算法。目前为止，我们已经见过一些分治策略的算法了，例如归并排序和Karatsuba大数快速乘法。现在，让我们看看分治策略的背后原理是什么。 同动态规划不同，在动态规划中，为了得到最终的答案，我们需要把一个大的问题“展开”为几个子问题（“expand” the solutions of sub-problems），但是在这里，我们会更多的谈到如何把...
详解矩阵乘法中的Strassen算法
u011250186的博客
07-29 8380
机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。 一、矩阵乘法 如下图所示： Figure 1 Matrix Multiplication 二、Strassen算法 Figure 2 x^3 vs. x^2.807 三、Strassen原理详解 Strassen算法正是从这个角度出发，实现了降低算法复杂度！ 实现步骤可以分为以下4步： 3.1 S...
strassen矩阵乘法 java_分治法-Strassen矩阵乘法
weixin_42525005的博客
02-22 573
算法思想：分治法 实际问题：Strassen 矩阵乘法 编写语言：Java问题描述我们知道，两个大小为 2 * 2 的矩阵相乘，一般需要进行 8 次乘法。而Strassen矩阵乘法可以减少一次乘法，只需要 7 次，看似很少，但当数据量很大时，效率就会有显著提升。不过使用 Strassen矩阵乘法需要满足 矩阵边长为 2 的幂次方。因为该算法会用到分治，如果分治后矩阵两边边长不等，结果会出错。使用下...
C++ Strassen算法代码的实现
08-19
"C++ Strassen算法代码的实现" 本篇文章将对C++ Strassen算法代码的实现进行详细的介绍。Strassen算法是一种矩阵乘法算法，它可以将矩阵乘法的时间复杂度从O(n^3)降低到O(n^2.81)。在实际应用中，Strassen算法可以...
strassen_矩阵乘法的strassen算法_
10-02
Strassen算法是矩阵乘法的一种高效算法，由德国数学家沃尔夫冈·斯特拉森在1969年提出，它的主要目标是减少运算量，尤其是对于大尺寸矩阵的乘法。传统矩阵乘法的时间复杂度是O(n^3)，而Strassen算法通过分治策略将这...
strassen算法实现
08-14
strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ 可以看到上面只有7次乘法和多次加减法，最终达到降低复杂度为O( n^lg7 ) ~= O( n^2.81 );
strassen算法
01-01
详细代码，运行无误，strassen算法计算矩阵相乘
C语言strassen矩阵乘法代码
04-05
strassen矩阵乘法的C代码 【问题描述】 从文件arr.in中读入一个m行k列的整数矩阵a和一个k行n列的整数矩阵b(1 < m, k, n < 200)，在标准输出上输出这两个矩阵的乘积。 【输入形式】 输入文件arr.in中有m+k行，前m行是矩阵a的元素aij，后k行是矩阵b的元素bij (-3000 < aij, bij < 3000)。 【输出形式】 输出结果为m行，每行n个元素，按整数左对齐方式输出，每个元素占相同的位数，且各个元素之间空格的最少数量应等于1。 【输入样例】 1 0 0 1 1 1 1 1 【输出样例】 1 1 1 1
5分钟掌握矩阵乘法的Strassen算法
TCP/IP协议栈学习ing
08-18 2253
By LongLuo 机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。 一、矩阵乘法 假设AAA为m×pm \times pm×p的矩阵，BBB为p×np \times np×n的矩阵，那么称m×nm \times nm×n的矩阵CCC为矩阵AAA与BBB的乘积，记作C=ABC = ABC=...
矩阵乘法--Strassen算法
Zhang_Qin123的博客
03-11 908
定义。
《算法导论》-分治策略，矩阵相乘Strassen算法(伪代码,Java)
qq_44242804的博客
11-24 1468
如果要计算上述矩阵，最简单的通用方法是通过三个循环也就是复杂度为O(n^3).而Strassen算法的特点是适用于比较大的矩阵，通过递归划分，再用上述公式解决,创建10个n/2小矩阵，递归计算7个矩阵。
减少乘法次数的优化算法（Gauss、Strassen、Winograd）
qq_57502075的博客
11-23 2047
在硬件设计中，乘法无论是在逻辑资源的使用上还是组合逻辑的延时上都要比加法高很多。从硬件方面考虑，我们都更倾向于将乘法转换成移位和加法，譬如乘以8，可以转换为左移3位。A*15可以转换为(A
Strassen：一种高效的矩阵相乘算法
weixin_40982849的博客
11-15 2982
Q1：如何提高矩阵相乘效率？ 矩阵乘法是种极其耗时的运算。 以C = A • B为例，其中A和B都是 n x n 的方阵。根据矩阵乘法的定义，计算过程如下： A1: 简单分治法 前提：假定A,B都是n等于2的次幂的方阵 基本思路：计算C=A*B时，将C,A,B矩阵进行分块操作，对每个分块的矩阵进行乘法运 算，运算完毕后重新对得到的C11,C12,C21,C22进行组合操作。 确定递归终止条件：当分块矩阵得到的阶数为1 时，得到的C即是A和B中两个元素的乘积。 每个公式需要计算两次矩阵乘法和一次矩阵加法，
【Strassen】矩阵乘法的Strassen算法，时间复杂度 O(n^2.81) （rust 语言实现）
wji15的博客
09-01 1418
按照矩阵乘法的定义不难写出算法1 由于三重 循环的每一重都恰好执行 步，因此该算法的时间复杂度为 O(n3)O(n^3)O(n3)为此我们尝试改进为简单起见，假定三个矩阵均为 n×nn \times nn×n 矩阵，nnn 是 222 的幂，矩阵 A,B,CA, B, CA,B,C 均分解为 444 个 n/2×n/2n / 2 \times n / 2n/2×n/2 的子矩阵，则计算公式等价于C11=A11⋅B11+A12⋅B21 C_{11} = A_{11} \cdot B_{11} + A_{1
C语言经典算法之Strassen矩阵乘法
最新发布
weixin_56154577的博客
03-26 828
Strassen矩阵乘法是一种利用分治策略优化传统矩阵乘法算法的方法，由Volker Strassen于1969年提出。这种方法通过递归地将矩阵分解成更小的块，并运用特定的公式减少乘法操作的数量，从而降低了计算大型矩阵乘积的时间复杂度。然而，由于分治和合并过程引入了额外的开销，对于较小的矩阵，Strassen算法可能不如直接乘法有效率。
Strassen 算法
07-28
Strassen算法是一种用于矩阵乘法的分治算法。它的基本思想是将两个大的矩阵分割成更小的子矩阵，然后通过一系列递归步骤来计算它们的乘积。相较于传统的矩阵乘法算法，Strassen算法在一定规模下具有更高的效率。 具体来说，Strassen算法将两个n × n的矩阵分割成四个n/2 × n/2的子矩阵，然后通过一系列计算来得到它们的乘积。这些计算包括7次乘法运算和18次加法或减法运算。通过递归地应用这些计算步骤，最终可以得到两个矩阵的乘积。 Strassen算法的时间复杂度为O(n^log2(7))，相较于传统矩阵乘法的时间复杂度O(n^3)有所改善。然而，由于Strassen算法在实际应用中存在常数因子较大和递归深度较大的问题，因此在一些情况下可能并不比传统算法更快。 总的来说，Strassen算法是一种用于矩阵乘法的高效分治算法，但在实际应用中需要综合考虑具体情况来选择是否使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值