分治策略之矩阵乘法的几种实现

最新推荐文章于 2024-03-20 10:58:55 发布
最新推荐文章于 2024-03-20 10:58:55 发布
阅读量6.5k 收藏 37
点赞数 7
分类专栏： 算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30933859/article/details/78369719
版权

欢迎关注，定期更新算法问题

今天介绍一下分治算法的一个典型例子——矩阵乘法

如果以前了解过矩阵，应该知道矩阵的乘法公式C(m,n)=A(m,k)*B(k,n)，在这里我们只讨论方阵，假设A是n*n阶，B也是n*n阶，那么要计算乘积需要进行n^2个元素，看《算法导论》给出的伪码：



上边这个过程进行三次循环，每次循环执行n步，故花费时间是O(n^3)，下边是代码实现：

void Squre_Multiplay(int A[][n],int B[][n],int C[][n])
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            C[i][j]=0;
            for(int k=0;k<n;k++)
                C[i][j]=C[i][j]+A[i][k]*B[k][j];
        }
    }
}

当然我们学习了分治算法后可以考虑能否利用递归来降低时间复杂度，先来看一个简单的分治算法：

假设A，B，C都是n*n阶，n是2的幂，乘法公式C=A*B，我们可以将这三个矩阵分别化成4个（n/2)*(n/2)阶的矩阵，即


然后可以将乘法公式写成4个递归式：


有了递归式就可以设计算法了，思路即是进行分解，求解，合并这几个步骤，将大矩阵化为4个小矩阵直到足够小，然后进行简单的二阶矩阵的计算，以下是《算法导论》上的伪码：


这段伪码理解起来很简单，但是实现起来比较复杂，因为它隐藏了一个重要的细节，即如何划分矩阵的问题，我们常规做法可能是新建几个新的矩阵，然后在从原矩阵特定位置赋值过来，但这样实现起来复杂并且很容易出错，这里本人利用下标来进行划分和计算，代码看起来清晰：

void Squre_Multiplay_recursive(int A[][n],int B[][n],int C[][n],int A_flag[],int B_flag[])
{
    if(N==2)
    {
        C[A_flag[2]][B_flag[0]]=A[A_flag[2]][A_flag[0]]*B[B_flag[2]][B_flag[0]]+A[A_flag[2]][A_flag[1]]*B[B_flag[3]][B_flag[0]]+C[A_flag[2]][B_flag[0]];
        C[A_flag[2]][B_flag[1]]=A[A_flag[2]][A_flag[0]]*B[B_flag[2]][B_flag[1]]+A[A_flag[2]][A_flag[1]]*B[B_flag[3]][B_flag[1]]+C[A_flag[2]][B_flag[1]];
        C[A_flag[3]][B_flag[0]]=A[A_flag[3]][A_flag[0]]*B[B_flag[2]][B_flag[0]]+A[A_flag[3]][A_flag[1]]*B[B_flag[3]][B_flag[0]]+C[A_flag[3]][B_flag[0]];
        C[A_flag[3]][B_flag[1]]=A[A_flag[3]][A_flag[0]]*B[B_flag[2]][B_flag[1]]+A[A_flag[3]][A_flag[1]]*B[B_flag[3]][B_flag[1]]+C[A_flag[3]][B_flag[1]];
    }
       else
    {
       // int one[4],two[4],three[4],four[4];
       N=N/2;
        cout<<"N value:"<<N<<endl;
        int one_A[4],two_A[4],three_A[4],four_A[4];
        int one_B[4],two_B[4],three_B[4],four_B[4];
        //
        divide_array(A,A_flag,one_A,two_A,three_A,four_A);
        divide_array(B,B_flag,one_B,two_B,three_B,four_B);
        //
        Squre_Multiplay_recursive(A,B,C,one_A,one_B);
        Squre_Multiplay_recursive(A,B,C,two_A,three_B);
        //
        Squre_Multiplay_recursive(A,B,C,one_A,two_B);
        Squre_Multiplay_recursive(A,B,C,two_A,four_B);
        //
        Squre_Multiplay_recursive(A,B,C,three_A,one_B);
        Squre_Multiplay_recursive(A,B,C,four_A,three_B);
        //
        Squre_Multiplay_recursive(A,B,C,three_A,two_B);
        Squre_Multiplay_recursive(A,B,C,four_A,four_B);
    }
}
void divide_array(int Array[][n],int flag[],int one[],int two[],int three[],int four[])
{
    int left=flag[0];
    int right=flag[1];
    int top=flag[2];
    int bottom=flag[3];
        one[0]=left;
        one[1]=(left+right)/2;
         one[2]=top;
         one[3]=(top+bottom)/2;

        //
         two[0]=(left+right+1)/2;
         two[1]=right;
         two[2]=top;
         two[3]=(top+bottom)/2;

        //
         three[0]=left;
         three[1]=(left+right)/2;
         three[2]=(top+bottom+1)/2;
         three[3]=bottom;

        //
         four[0]=(left+right+1)/2;
         four[1]=right;
         four[2]=(top+bottom+1)/2;
         four[3]=bottom;
for(int i=0;i<4;i++)
    cout<<"划分边界："<<one[i]<<" "<<two[i]<<" "<<three[i]<<" "<<four[i]<<endl;
}
第一个函数是递归函数，内部层次很明确，当矩阵规模大于2时，进行划分4个子矩阵，然后每个子矩阵递归调用，当规模为2阶时，直接利用公式计算。第二个函数是划分函数，为了容易理解和避免引入指针，我们用表示矩形的方式表示矩阵，即表示出来矩阵的左、右、上、下位置保存到位置数组中。
上述算法运行时间的递归式：


通过求解，可以看出T(n)=O(n^3)，与一般算法比较，并没有任何提高，反而增加了递归带来的开销。

下一篇介绍Strassen算法。

此篇全部源码如下：

#include <iostream>
#define n 4
int N=n;
using namespace std;
void divide_array(int Array[][n],int flag[],int one[],int two[],int three[],int four[]);
//一般方法，时间复杂度为O(n^3)，
void Squre_Multiplay(int A[][n],int B[][n],int C[][n]);
//普通分治算法，时间复杂度为O(n^2);
void Squre_Multiplay_recursive(int A[][n],int B[][n],int C[][n],int A_flag[],int B_flag[]);
//Stassen算法
int main()
{
    int A[4][4]={1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4};
    int B[4][4]={1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4};
    int C[4][4]={0};
    int A_flag[4]={0,3,0,3};
    int B_flag[4]={0,3,0,3};
   //Squre_Multiplay(A,B,C);
  Squre_Multiplay_recursive(A,B,C,A_flag,B_flag);
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
            cout<<C[i][j]<<"\t";
        cout<<endl;
    }
    return 0;
}

void Squre_Multiplay(int A[][n],int B[][n],int C[][n])
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            C[i][j]=0;
            for(int k=0;k<n;k++)
                C[i][j]=C[i][j]+A[i][k]*B[k][j];
        }
    }
}

void Squre_Multiplay_recursive(int A[][n],int B[][n],int C[][n],int A_flag[],int B_flag[])
{
    if(N==2)
    {
        C[A_flag[2]][B_flag[0]]=A[A_flag[2]][A_flag[0]]*B[B_flag[2]][B_flag[0]]+A[A_flag[2]][A_flag[1]]*B[B_flag[3]][B_flag[0]]+C[A_flag[2]][B_flag[0]];
        C[A_flag[2]][B_flag[1]]=A[A_flag[2]][A_flag[0]]*B[B_flag[2]][B_flag[1]]+A[A_flag[2]][A_flag[1]]*B[B_flag[3]][B_flag[1]]+C[A_flag[2]][B_flag[1]];
        C[A_flag[3]][B_flag[0]]=A[A_flag[3]][A_flag[0]]*B[B_flag[2]][B_flag[0]]+A[A_flag[3]][A_flag[1]]*B[B_flag[3]][B_flag[0]]+C[A_flag[3]][B_flag[0]];
        C[A_flag[3]][B_flag[1]]=A[A_flag[3]][A_flag[0]]*B[B_flag[2]][B_flag[1]]+A[A_flag[3]][A_flag[1]]*B[B_flag[3]][B_flag[1]]+C[A_flag[3]][B_flag[1]];
    }
       else
    {
       // int one[4],two[4],three[4],four[4];
       N=N/2;
        cout<<"N value:"<<N<<endl;
        int one_A[4],two_A[4],three_A[4],four_A[4];
        int one_B[4],two_B[4],three_B[4],four_B[4];
        //
        divide_array(A,A_flag,one_A,two_A,three_A,four_A);
        divide_array(B,B_flag,one_B,two_B,three_B,four_B);
        //
        Squre_Multiplay_recursive(A,B,C,one_A,one_B);
        Squre_Multiplay_recursive(A,B,C,two_A,three_B);
        //
        Squre_Multiplay_recursive(A,B,C,one_A,two_B);
        Squre_Multiplay_recursive(A,B,C,two_A,four_B);
        //
        Squre_Multiplay_recursive(A,B,C,three_A,one_B);
        Squre_Multiplay_recursive(A,B,C,four_A,three_B);
        //
        Squre_Multiplay_recursive(A,B,C,three_A,two_B);
        Squre_Multiplay_recursive(A,B,C,four_A,four_B);
    }
}
void divide_array(int Array[][n],int flag[],int one[],int two[],int three[],int four[])
{
    int left=flag[0];
    int right=flag[1];
    int top=flag[2];
    int bottom=flag[3];
        one[0]=left;
        one[1]=(left+right)/2;
         one[2]=top;
         one[3]=(top+bottom)/2;

        //
         two[0]=(left+right+1)/2;
         two[1]=right;
         two[2]=top;
         two[3]=(top+bottom)/2;

        //
         three[0]=left;
         three[1]=(left+right)/2;
         three[2]=(top+bottom+1)/2;
         three[3]=bottom;

        //
         four[0]=(left+right+1)/2;
         four[1]=right;
         four[2]=(top+bottom+1)/2;
         four[3]=bottom;
for(int i=0;i<4;i++)
    cout<<"划分边界："<<one[i]<<" "<<two[i]<<" "<<three[i]<<" "<<four[i]<<endl;
}


clearlove推理能手
关注
  • 7
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【算法】04 分治
liangyling3的博客
09-16 316
分治 本章不考编程，考时间复杂度（函数计算） 矩阵乘法 考虑n×n的矩阵A、B 一般算法 for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { result[i][j] = 0; for (int k = 0; k < n; ++k) { result[i][j] += A[i][k] + B[k]...
矩阵乘法（分治法）
11-17
利用分治法求解矩阵乘法，可以使复杂度降低
分治法实现矩阵相乘
03-13
分治法实现矩阵相乘
使用分治法解决矩阵乘法的Strassen算法及C代码示例
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-20 1606
在计算机科学中，矩阵乘法是一种基本的运算，广泛应用于图像处理、机器学习、线性代数、物理模拟等领域。然而，传统的矩阵乘法算法的时间复杂度较高，为O(n^3)，在处理大规模矩阵时效率低下。为了降低矩阵乘法的计算成本，研究者们提出了多种优化方法，其中Strassen算法便是一种基于分治法的有效算法。 Strassen算法于1969年由德国数学家Volker Strassen提出，它将矩阵乘法的时间复杂度降低到了O(n^log2(7))≈O(n^2.807)，相较于传统算法有了显著的提升。尽管后来有更高效的算法被
五、分治法应用--矩阵乘法
runing
01-17 2454
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)，没有什么进步，不过这里分割思路是没有问题
分治法之矩阵乘法
weixin_44778719的博客
02-06 4547
分治法及Strassen方法做矩阵乘法 矩阵乘法：我们先约定用于乘法的矩阵与结果矩阵都是nn的矩阵 比较直观的算法就是<算法导论>中给出的伪代码使用三个循环来完成: SQUARE-MATRIX-MULTIPLY（A，B） 1 n = A.rows 2 let C be a new n×n matrix 3 for i = 1 to n 4 for j = 1 to n 5 ...
分治算法---矩阵乘法
weixin_51339377的博客
04-06 7937
[实验目的] 掌握分治策略的基本思想以及用分治法解决问题的技巧，运用分治法解决矩阵乘法的复杂度过高的问题。 【问题描述】设A和B是两个n*n阶矩阵，求它们的乘积矩阵C。（假设n=2k）。 【提示】A和B是两个n*n阶矩阵，它们的乘积C=A*B也是一个n*n阶矩阵，用传统方法计算矩阵C中的元素的公式如下： 由公式（1）可以知道，每计算一个C[i][j]，需要做n次乘法和n-1次加法。因此计算C的n*n个元素需要n3次乘法和n3-n2次加法，因此算法的时间复杂...
分治法解决矩阵乘法问题
qq_53364137的博客
06-06 1851
一、实验目的及要求1、掌握分治法的基本思想；2、掌握大整数乘法的分治法实现方法；3、学会用分治法解决实际问题的时间效率。二、实验内容编写程序实现：1、输于两个n×n的矩阵A和B,实现乘积运算，并输出运算结果和计算时间；2、逐渐增大矩阵A和B的规模，分析运算时间的变化。3、用分治法的实现矩阵乘积运算，比较使用分治法前后的计算量差异。...
算法分析与设计：分治递归实现斯特拉森（Strassen）矩阵乘法
SongXJ的博客
10-14 5912
分治问题 分治法的基本思想是将一个规模很大的问题分解为许多规模较小的子问题，这些子问题互相独立且与原问题相同。对这些子问题递归地进行求解后合并，得到原问题的解。 斯特拉森（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)
《算法导论》-分治策略，矩阵相乘Strassen算法(伪代码,Java)
qq_44242804的博客
11-24 1409
如果要计算上述矩阵，最简单的通用方法是通过三个循环也就是复杂度为O(n^3).而Strassen算法的特点是适用于比较大的矩阵，通过递归划分，再用上述公式解决,创建10个n/2小矩阵，递归计算7个矩阵。
矩阵乘法分治法c语言,分治法举例之矩阵乘法
weixin_42373103的博客
05-17 965
分治法举例之矩阵乘法前言矩阵按定义直接实现是比较直接简单的。时间复杂度也可以直接得出来是(O(n^3))直接实现class matrix:'''为了简单起见，没有对数据做校验。假设矩阵就是nxn的。'''def __init__(self, data):if not data or not hasattr(data, '__getitem__'):raise ValueError("data no...
python实现矩阵乘法的方法
12-24
本文实例讲述了python实现矩阵乘法的方法。分享给大家供大家参考。具体实现方法如下： def matrixMul(A, B): res = [[0] * len(B[0]) for i in range(len(A))] for i in range(len(A)): for j in range(len(B[0]...
Strassen矩阵乘法—分治法实现代码
12-13
Strassen’s 矩阵乘法—分治法实现代码，能输出最终结果矩阵和每一次递归的S1~S7。
矩阵相乘（分治法）
热门推荐
哦o7575 的博客
04-21 1万+
一个简单的分治算法求矩阵相乘 C=A * B ，假设三个矩阵均为n×n，n为2的幂。可以对其分解为4个n/2×n/2的子矩阵分别递归求解。算法中一个重要的细节就是在分块的时候，采用的是下标的方式。
用分治策略实现Strassen矩阵乘法
amzlyh的博客
02-25 1011
对于每个矩阵的子矩阵 A11, A12, A21, A22, B11, B12, B21, B22，每个子矩阵的大小都是原始矩阵的一半。假设原始矩阵的大小为 N x N，那么递归到一阶矩阵的情况下，子矩阵的最大大小为 (N/2) x (N/2)。假设现在有一个rows x cols 的矩阵（记为矩阵 A）和一个 other.rows x other.cols 的矩阵（记为矩阵 B），要求矩阵 A 的列数（cols）必须等于矩阵 B 的行数（other.rows）才能进行乘法操作。首先，设置递归终止条件。
递归与分治之Srassen矩阵乘法
weixin_44952817的博客
11-25 304
Srassen矩阵乘法 矩阵乘法的传统做法的复杂度：O（n^3） 使用分治法的方法跟处理大整数乘法的做法一致，就是拆分矩阵，最后合并。只不过这次我们是将矩阵分割为几个大小相等的子矩阵，具体如下： 这里的A,B,C都代指矩阵块，而非矩阵中的元素。 显然其复杂度仍然是O（n^3） 为了降低复杂度我们仍选择用加法来替代乘法，只不过这次的元素将比大整数乘法中复杂得多。 此时的复杂度O（n^(log7)）=O(n^(2.81)) 据研究，目前最好的计算时间上界是O（n^2.376） ...
009-矩阵乘法-分治法-《算法设计技巧与分析》M.H.A学习笔记
luciozhang的博客
06-27 9344
A、B是两个n*n的矩阵，计算C=A*B。
fzu 1692 Key problem(循环同构矩阵o(n^2)优化乘法)
yjCola
04-24 1031
fzu 1692 Key problem
分治策略实现斯特拉森矩阵乘法
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。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值