Strassen矩阵算法分析及其C++实现 递归分治法（转）

最新推荐文章于 2022-07-26 19:02:24 发布
最新推荐文章于 2022-07-26 19:02:24 发布
阅读量167 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/yangquanhui/p/4937512.html
版权

对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示：

从上图可以看出这种分块相乘总共用了8次乘法，当然对于子矩阵相乘（如A0×B0），还可以继续递归使用分块相乘。对于中小矩阵来说，很适合使用这种分块乘法，但是对于大矩阵来说，递归的次数较多，如果能减少每次分块乘法的次数，那么性能将可以得到很好的提高。

Strassen矩阵乘法就是采用了一个简单的运算技巧，将上面的8次矩阵相乘变成了7次乘法，看别小看这减少的1次乘法，因为每递归1次，性能就提高了1/8，比如对于1024*1024的矩阵，第1次先分解成7次512*512的矩阵相乘，对于512*512的矩阵，又可以继续递归分解成256*256的矩阵相乘，…，一直递归下去，假设分解到64*64的矩阵大小后就不再递归，那么所花的时间将是分块矩阵乘法的(7/8) * (7/8) * (7/8) * (7/8) = 0.586倍，提高了快接近一倍。当然这是理论上的值，因为实际上strassen乘法增加了其他运算开销，实际性能会略低一点。

由上可见，Strassen矩阵乘法是通过递归实现的，它将一般情况下二阶矩阵乘法（可扩展到n阶，但Strassen矩阵乘法要求n是2的幂）所需的8次乘法降低为7次，其C++实现代码如下：

下面就是Strassen矩阵乘法的实现方法，

M1 = (A0 + A3) × (B0 + B3)

M2 = (A2 + A3) × B0

M3 = A0 × (B1 - B3)

M4 = A3 × (B2 - B0)

M5 = (A0 + A1) × B3

M6 = (A2 - A0) × (B0 + B1)

M7 = (A1 - A3) × (B2 + B3)

C0 = M1 + M4 - M5 + M7

C1 = M3 + M5

C2 = M2 + M4

C3 = M1 - M2 + M3 + M6

在求解M1,M2,M3,M4,M5,M6,M7时需要使用7次矩阵乘法，其他都是矩阵加法和减法。

下面看看Strassen矩阵乘法的串行实现伪代码：

Serial_StrassenMultiply(A, B, C)

{

T1 = A0 + A3;

T2 = B0 + B3;

StrassenMultiply(T1, T2, M1);

T1 = A2 + A3;

StrassenMultiply(T1, B0, M2);

T1 = (B1 - B3);

StrassenMultiply (A0, T1, M3);



T1 = B2 - B0;

StrassenMultiply(A3, T1, M4);

T1 = A0 + A1;

StrassenMultiply(T1, B3, M5); 

T1 = A2 – A0;

T2 = B0 + B1;

StrassenMultiply(T1, T2, M6);

T1 = A1 – A3;

T2 = B2 + B3;

StrassenMultiply(T1, T2, M7);

C0 = M1 + M4 - M5 + M7

C1 = M3 + M5

C2 = M2 + M4

C3 = M1 - M2 + M3 + M6

}

#include <iostream>  

using namespace std;   

const int N = 6;     //Define the size of the Matrix  

template<typename T>   
void Strassen(int n, T A[][N], T B[][N], T C[][N]);   

template<typename T>   
void input(int n, T p[][N]);   

template<typename T>   
void output(int n, T C[][N]);   

int main() {   
    //Define three Matrices  
    int A[N][N],B[N][N],C[N][N];       

    //对A和B矩阵赋值，随便赋值都可以，测试用  
    for(int i=0; i<N; i++) {   
       for(int j=0; j<N; j++) {   
           A[i][j] = i * j;   
           B[i][j] = i * j;      
        }           
     }   

    //调用Strassen方法实现C=A*B  
     Strassen(N, A, B, C);   

    //输出矩阵C中值  
     output(N, C);   

     system("pause");   
    return 0;   
}   


template<typename T>   
void input(int n, T p[][N]) {   
     for(int i=0; i<n; i++) {   
         cout<<"Please Input Line "<<i+1<<endl;   
        for(int j=0; j<n; j++) {   
            cin>>p[i][j];   
         }           
      }   
}   


template<typename T>   
void output(int n, T C[][N]) {   
      cout<<"The Output Matrix is :"<<endl;   
     for(int i=0; i<n; i++) {   
        for(int j=0; j<n; j++) {   
            cout<<C[i][j]<<""<<endl;           
         }           
      }        
}   


template<typename T>   
void Matrix_Multiply(T A[][N], T B[][N], T C[][N]) {  //Calculating A*B->C  
     for(int i=0; i<2; i++) {   
        for(int j=0; j<2; j++) {   
            C[i][j] = 0;         
           for(int t=0; t<2; t++) {   
               C[i][j] = C[i][j] + A[i][t]*B[t][j];           
            }     
         }           
      }   
}   


template <typename T>   
void Matrix_Add(int n, T X[][N], T Y[][N], T Z[][N]) {   
     for(int i=0; i<n; i++) {   
        for(int j=0; j<n; j++) {   
            Z[i][j] = X[i][j] + Y[i][j];           
         }           
      }        
}   


template <typename T>   
void Matrix_Sub(int n, T X[][N], T Y[][N], T Z[][N]) {   
     for(int i=0; i<n; i++) {   
        for(int j=0; j<n; j++) {   
            Z[i][j] = X[i][j] - Y[i][j];           
         }           
      }        
}   



template <typename T>   
void Strassen(int n, T A[][N], T B[][N], T C[][N]) {   
      T A11[N][N], A12[N][N], A21[N][N], A22[N][N];   
      T B11[N][N], B12[N][N], B21[N][N], B22[N][N];        
      T C11[N][N], C12[N][N], C21[N][N], C22[N][N];   
      T M1[N][N], M2[N][N], M3[N][N], M4[N][N], M5[N][N], M6[N][N], M7[N][N];   
      T AA[N][N], BB[N][N];   

     if(n == 2) {  //2-order  
         Matrix_Multiply(A, B, C);        
      } else {   
        //将矩阵A和B分成阶数相同的四个子矩阵，即分治思想。  
        for(int i=0; i<n/2; i++) {   
           for(int j=0; j<n/2; j++) {   
               A11[i][j] = A[i][j];   
               A12[i][j] = A[i][j+n/2];   
               A21[i][j] = A[i+n/2][j];   
               A22[i][j] = A[i+n/2][j+n/2];   

               B11[i][j] = B[i][j];   
               B12[i][j] = B[i][j+n/2];   
               B21[i][j] = B[i+n/2][j];   
               B22[i][j] = B[i+n/2][j+n/2];       
            }           
         }     

        //Calculate M1 = (A0 + A3) × (B0 + B3)  
         Matrix_Add(n/2, A11, A22, AA);   
         Matrix_Add(n/2, B11, B22, BB);   
         Strassen(n/2, AA, BB, M1);   

        //Calculate M2 = (A2 + A3) × B0  
         Matrix_Add(n/2, A21, A22, AA);   
         Strassen(n/2, AA, B11, M2);   

        //Calculate M3 = A0 × (B1 - B3)  
         Matrix_Sub(n/2, B12, B22, BB);   
         Strassen(n/2, A11, BB, M3);   

        //Calculate M4 = A3 × (B2 - B0)  
         Matrix_Sub(n/2, B21, B11, BB);   
         Strassen(n/2, A22, BB, M4);   

        //Calculate M5 = (A0 + A1) × B3  
         Matrix_Add(n/2, A11, A12, AA);   
         Strassen(n/2, AA, B22, M5);   

        //Calculate M6 = (A2 - A0) × (B0 + B1)  
         Matrix_Sub(n/2, A21, A11, AA);   
         Matrix_Add(n/2, B11, B12, BB);   
         Strassen(n/2, AA, BB, M6);   

        //Calculate M7 = (A1 - A3) × (B2 + B3)  
         Matrix_Sub(n/2, A12, A22, AA);   
         Matrix_Add(n/2, B21, B22, BB);   
         Strassen(n/2, AA, BB, M7);   

        //Calculate C0 = M1 + M4 - M5 + M7  
         Matrix_Add(n/2, M1, M4, AA);   
         Matrix_Sub(n/2, M7, M5, BB);   
         Matrix_Add(n/2, AA, BB, C11);   

        //Calculate C1 = M3 + M5  
         Matrix_Add(n/2, M3, M5, C12);   

        //Calculate C2 = M2 + M4  
         Matrix_Add(n/2, M2, M4, C21);   

        //Calculate C3 = M1 - M2 + M3 + M6  
         Matrix_Sub(n/2, M1, M2, AA);   
         Matrix_Add(n/2, M3, M6, BB);   
         Matrix_Add(n/2, AA, BB, C22);   

        //Set the result to C[][N]  
        for(int i=0; i<n/2; i++) {   
           for(int j=0; j<n/2; j++) {   
               C[i][j] = C11[i][j];   
               C[i][j+n/2] = C12[i][j];   
               C[i+n/2][j] = C21[i][j];   
               C[i+n/2][j+n/2] = C22[i][j];           
            }           
         }   
      }   
}

转载于:https://www.cnblogs.com/yangquanhui/p/4937512.html

weixin_30394333
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设A和B是两个n*n阶的矩阵，用分治法求他们的乘积矩阵C。写出C++的完整代码。使算法复杂度降到最低
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-22 199
设A和B是两个n*n阶的矩阵，用分治法求他们的乘积矩阵C。写出C++的完整代码。使算法复杂度降到最低
基于C++的矩阵乘法计算函数
10-08
//本程序功能为实现两个矩阵相乘并将乘积输出 //本程序定义了一个矩阵相乘的成员函数，该函数需要输入三个参数，分别是要作乘积的两个矩阵和需要一个接收乘积的矩阵 //该成员函数能够对这三个矩阵的维数进行判断，若不符合矩阵的乘法则返回错误信息 //由于本程序使用vector向量作为容器存储矩阵，因此改变矩阵的维数只需要更改矩阵本身即可，无需更改维度参数 //本程序输出结果正确（已将本程序的多组矩阵乘积结果与该两矩阵MATLAB乘积结果进行对比，确保无误）
Strassen矩阵乘法(C++)
阳young的博客
04-29 4881
思路 两个矩阵A,B相乘时.有以下三种方法 暴力计算法. 三个for循环, 这时候时间复杂度为O(n^3).因为Cij=∑(k=1->n)Aik*Bkj,需要一个循环, 且C中有n^2个元素, 所以时间复杂度为O(n^3) 分治法. 首先将A,B,C分成相等大小的方块矩阵. 所以C11=A11*B11+A12*B21, C12=A11*B12+A12*B22, C21=A21*B11+A22*B21, C22=A21*B12+A22*B22 用T(n)表示n*n矩阵的乘法, 所以有T(
分治法解决矩阵乘法问题
山风不打咩的博客
05-11 2515
分治法解决矩阵乘法问题 传统for循环： #include<iostream> #include<cstdio> #include <vector> #include<algorithm> using namespace std; int n, m, p; int main() { printf("第一个n×m矩阵？\n"); cin >> n >> m; vector<vector<int>> A(n,
Strassen矩阵 分治算法 递归 C++
07-28
Strassen是采用分治算法的思想，将所给矩阵分成2阶矩阵 分治的方法循序渐进处理各个小矩阵的相乘，一个矩阵可以分成更多小的矩阵的。
Strassen矩阵乘法—分治法实现代码
12-13
在提供的"Strassen’s 矩阵乘法—分治法实现代码.txt"文件中，应该包含了用某种编程语言（如C++, Python等）实现的上述逻辑。代码可能会包括以下部分：矩阵的定义和操作，矩阵的分割与合并函数，递归的Strassen乘法...
分治法实现矩阵相乘
03-13
分治法实现矩阵相乘的关键在于，我们可以将两个矩阵A和B各自划分为四个小矩阵，然后对这些小矩阵进行递归的相乘操作。这个过程可以表示为以下步骤： 1. 将A矩阵分为四个子矩阵：A11, A12, A21, A22，同样将B矩阵...
01_比较矩阵相乘的常规法和Strassen方法.zip_01矩阵算法_C++_VS2012
最新发布
09-21
本文将深入探讨两种矩阵相乘算法：常规方法和Strassen方法，以及它们在C++编程环境（如Visual Studio 2012）中的实现。 常规的矩阵相乘算法，也称为学校方法或直接乘法，是最直观的方法。对于两个大小为n×n的矩阵A...
递归思想和案列和分治法思想的案例
07-03
递归思想和案列(阶乘函数,Fibonacci数列,Ackerman函数,整数划分问题,Hanoi塔问题)分治法思想的介绍(大整数的乘法,Strassen矩阵乘法,棋盘覆盖问题,二分搜索,快速排序,合并排序,线性时间选择)。算法课使用的ppt,可结合...
矩阵相乘（分治法）
哦o7575 的博客
04-21 1万+
一个简单的分治算法求矩阵相乘 C=A * B ，假设三个矩阵均为n×n，n为2的幂。可以对其分解为4个n/2×n/2的子矩阵分别递归求解。算法中一个重要的细节就是在分块的时候，采用的是下标的方式。
矩阵乘法（分治法）
11-17
利用分治法求解矩阵乘法，可以使复杂度降低
矩阵乘法的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）矩阵乘法
SongXJ的博客
10-14 6557
分治问题 分治法的基本思想是将一个规模很大的问题分解为许多规模较小的子问题，这些子问题互相独立且与原问题相同。对这些子问题递归地进行求解后合并，得到原问题的解。 斯特拉森（Strassen）矩阵乘法 设A和B是两个n×nn \times nn×n的矩阵，其中nnn可以写成2k2^k2k。将A和B分别等分成4个小矩阵，此时如果把A和B都当成2×22 \times 22×2矩阵来看,每个元素就是一个 (n/2)×(n/2)(\mathrm{n} / 2) \times(\mathrm{n} / 2)(n/2)
矩阵乘法 C++
m0_56075632的博客
07-12 713
暴力法： #include<iostream> using namespace std; int main() { int a[2][2]; int b[2][2]; int c[2][2]; cout << "输入矩阵a：" << endl; for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) {
《算法导论》第四章-矩阵乘法的Strassen算法（含C++代码）
Toby的博客
07-26 2359
本文为《算法导论》第四章-4.2-矩阵乘法的Strassen方法笔记，欢迎大家参考。
分治算法 php,c++ - 矩阵乘法的分治算法实现思路
weixin_35476698的博客
04-03 483
迷茫2017-04-17 13:30:351楼转载自这里，稍有改动。与原书中的伪代码思路是相同的。// C++#include #include templatestruct Matrix {Matrix(size_t r, size_t c) {Data.resize(c, std::vector(r, 0));}void SetSubMatrix(const int r, const int ...
递归与分治策略：Strassen矩阵乘法
憧憬，思考，奋斗，飞翔
06-22 7511
辅助函数 为了便于代码的编写，以及在函数参数中传二维数组的方便，写了以下三个辅助函数。 //数组寻址辅助函数 int& GetArrayVal( int* pMatrix, int nCol, int i, int j ) { return *( pMatrix + i * nCol + j); } //创建矩阵 void CreateMatrix( int** pMatrix, int
C++实现两个矩阵相乘
热门推荐
cxcbupt
04-29 3万+
#include using namespace std; #define SIZE_M 2 #define SIZE_N 3 #define SIZE_S 4 int main(){ int matrix_a[SIZE_M] [SIZE_N]={{1,2,3},{4,5,6}};//a矩阵2X3 int matrix_b[SIZE_N] [SIZE_S]={{1,2,3,4},{5,6,
分治算法--矩阵乘法
ljz2016的博客
11-09 1623
public class Matrix { private double[][] a; private double[][] b; private double[][] c; public Matrix(int aRows,int aCols,int bRows,int bCols){ if (aCols!=bRows){ th

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值