使用递归与分治法求解3.strassen矩阵乘法

如何应用分治算法求解问题分治算法，英文名为Divide and Conquer Algorithm，是一种高效的算法设计策略，在计算机科学中有着广泛的应用。

该算法将一个大问题分解成多个小问题，各自独立地解决，再将结果合并起来得到最终结果。

在本文中，我们将阐述如何应用分治算法求解问题，并通过几个实例来具体说明该算法的应用。

一、分治算法的原理分治算法的核心思想是将一个大问题分解成若干个小问题来解决，然后将这些小问题的解组合起来生成大问题的解。

其具体步骤如下：1. 分解：将原问题划分成若干个规模较小的子问题。

2. 解决：递归地解决每个子问题。

如果子问题足够小，则直接求解。

3. 合并：将所有子问题的解合并成原问题的解。

分治算法的主要优点在于它可以有效地缩小问题规模，从而缩短整个算法的执行时间。

另外，该算法天然适用于并行计算，因为每个子问题都是独立求解的。

二、分治算法的应用分治算法在各种领域都有广泛应用，包括数学、自然科学、计算机科学等。

以计算机科学领域为例，分治算法常常用于解决以下类型的问题：1. 排序问题2. 查找问题3. 字符串匹配问题4. 最大子序列和问题5. 矩阵乘法问题6. 图形问题下面我们将一一讲解这些问题的分治算法实现。

1. 排序问题排序问题是在一组数据中将其按指定规律进行排列的问题。

在计算机科学中，排序算法是十分重要的一类算法。

其中，分治算法由于其高效性和可并行性被广泛应用。

常用的分治排序算法包括归并排序和快速排序。

归并排序的基本思想是将待排序元素以中心点为界分成两个序列，对每个序列进行排序，然后将两个序列合并成一个有序序列；而快速排序则利用了分割的思想，通过每次选取一个元素作为“轴点”，将数组分成小于轴点和大于轴点的两部分，对这两部分分别进行快速排序。

2. 查找问题查找问题是在一组数据中寻找某个元素的问题。

分治算法在查找问题中的应用主要体现在二分查找中。

在二分查找中，我们首先将已排序的数组分成两半，在其中一半中查找目标值。

绪论单元测试1.山东师范大学的管教授在哪个问题上给出了比较好的解决方法。

A:邮递员问题B:背包问题C:装载问题D:最大团问题答案:A第一章测试1.算法具备的四个基本性质是（）A:输入B:有限性C:确定性D:输出答案:ABCD2.算法就是程序A:错B:对答案:A3.描述渐进上界的符号是（）A:ΩB:ωC:OD:θ答案:C4.f(n)=3n2+n+1,下面不正确的是()A:f(n)=O(n3)B:f(n)=O(n2)C:f(n)=O(2n)D:f(n)=O(3n2)答案:C5.在算法分析中，我们希望找到更加高阶的上界函数A:错B:对答案:A第二章测试1.Strassen 矩阵乘法是利用（）实现的算法。

A:贪心法B:分治策略C:动态规划法D:回溯法答案:B2.使用分治法求解不需要满足的条件是（）A:子问题不能够重复B:子问题的解可以合并C:子问题必须是一样的D:原问题和子问题使用相同的方法解答案:C3.实现棋盘覆盖算法利用的算法是（）。

A:分治法B:回溯法C:动态规划法D:贪心法答案:A4.实现循环赛日程表利用的算法是（）。

A:贪心法B:回溯法C:分治策略D:动态规划法答案:C5.从分治法的一般设计模式可以看出，用它设计出的程序一般是递归算法A:对B:错答案:A第三章测试1.动态规划算法一般分成（）三个阶段。

A:求解B:分析C:分段D:汇总答案:ABC2.动态规划的基本要素有（）？A:备忘录方法B:最优子结构C:子问题的重叠性质答案:ABC3.用动态规划法求解的问题都可以分解为相互重叠的子问题。

A:对B:错答案:A4.动态规划法利用递推关系式（）计算，实现动态规划过程。

A:循环B:递归C:自底向上D:自顶向下答案:C5.最优子结构是问题可以用动态规划法求解的前提。

A:错B:对答案:B第四章测试1.贪心算法中每次做出的贪心选择都是全局最优选择。

A:对B:错答案:B2.下面问题不能使用贪心法解决的是A:N皇后问题B:最小花费生成树问题C:背包问题D:单源最短路径问题答案:A3.背包问题的贪心算法所需的计算时间为A:O（n2n）B:O（n）C:O（nlogn）D:O（2n）答案:C4.哈夫曼编码是自底向上构造的A:错B:对答案:B5.Kruskal算法的时间复杂度是A:O（eloge）B:O（n）C:O（nlogn）D:O（2n）答案:A第五章测试1.回溯法就是穷举法A:错B:对答案:A2.回溯法使用的是广度优先遍历A:对B:错答案:B3.回溯法必须寻找一个限界函数A:对B:错答案:B4.使用回溯法时可以考虑以下哪些方面()A:约束函数B:解空间结构C:解的向量形式D:解的最优子结构性质答案:ABC5.回溯法在处理n皇后问题时，必须把解空间组织成子集树。

4-2.矩阵乘法的Strassen 算法详解题⽬描述请编程实现矩阵乘法，并考虑当矩阵规模较⼤时的优化⽅法。

思路分析根据wikipedia 上的介绍：两个矩阵的乘法仅当第⼀个矩阵B 的列数和另⼀个矩阵A 的⾏数相等时才能定义。

如A 是m×n 矩阵和B 是n×p 矩阵，它们的乘积AB 是⼀个m×p 矩阵，它的⼀个元素其中 1 ≤ i ≤ m,1 ≤ j ≤ p 。

值得⼀提的是，矩阵乘法满⾜结合律和分配率，但并不满⾜交换律，如下图所⽰的这个例⼦，两个矩阵交换相乘后，结果变了：下⾯咱们来具体解决这个矩阵相乘的问题。

解法⼀、暴⼒解法其实，通过前⾯的分析，我们已经很明显的看出，两个具有相同维数的矩阵相乘，其复杂度为O （n^3），参考代码如下：解法⼆、Strassen 算法在解法⼀中，我们⽤了3个for 循环搞定矩阵乘法，但当两个矩阵的维度变得很⼤时，O （n^3）的时间复杂度将会变得很⼤，于是，我们需要找到⼀种更优的解法。

⼀般说来，当数据量⼀⼤时，我们往往会把⼤的数据分割成⼩的数据，各个分别处理。

遵此思路，如果丢给我们⼀个很⼤的两个矩阵呢，是否可以考虑分治的⽅法循序渐进处理各个⼩矩阵的相乘，因为我们知道⼀个矩阵是可以分成更多⼩的矩阵的。

如下图，当给定⼀个两个⼆维矩阵A B 时：这两个矩阵A B 相乘时，我们发现在相乘的过程中，有8次乘法运算，4次加法运算：矩阵乘法的复杂度主要就是体现在相乘上，⽽多⼀两次的加法并不会让复杂度上升太多。

故此，我们思考，是否可以让矩阵乘法的运算过程中乘法的运算次数减少，从⽽达到降低矩阵乘法的复杂度呢？答案是肯定的。

1969年，德国的⼀位数学家Strassen 证明O （N^3）的解法并不是矩阵乘法的最优算法，他做了⼀系列⼯作使得最终的时间复杂度降低到了O(n^2.80)。

他是怎么做到的呢？还是⽤上⽂A B 两个矩阵相乘的例⼦，他定义了7个变量：如此，Strassen算法的流程如下：；表⾯上看，Strassen 算法仅仅⽐通⽤矩阵相乘算法好⼀点，因为通⽤矩阵相乘算法时间复杂度是，⽽Strassen 算法复杂度只是。

大整数乘法和strassen矩阵乘法大整数乘法和Strassen矩阵乘法是计算机科学中两个非常重要的算法。

在我们的日常生活中，我们经常需要比较大的数字，例如，考虑到我们的身份证号码或者信用卡号码中的位数就很大。

对于这些大数字的计算，实现乘法运算的标准方法导致了效率低下。

这就要依靠大整数乘法的算法来完成。

同样的，矩阵乘法是人们常用的数据分析和机器学习等领域的基础算法之一，Strassen矩阵乘法则是一种可以在更短时间内完成的矩阵乘法算法。

在接下来的文档中，我将详细讲解大整数乘法和Strassen矩阵乘法。

一、大整数乘法大整数乘法是指对于两个比较大的数字，我们如何快速且准确的计算它们的乘积。

在介绍大整数乘法的算法之前，先考虑乘法的基本方法。

在日常乘法中，乘法运算是通过对乘数和被乘数的每一位进行相乘并将结果相加而得到的。

例如，计算96 ×57，我们将乘数96 和被乘数57 的每一位相乘，去得到：``` 96 × 57 ------- 672 (6 x 7) 480 (9 x 5) <<1> +57600 (9 x 5 << 2> ) ------- 5472 ```我们在这个过程中需要进行至Less 2次的延时计算，6次的加法，这在数字比较小时的时候是可行的。

但是，如果数字的位数变得更大，传统的乘法算法就会非常不切实际，执行效率非常慢。

在大整数乘法中，我们需要考虑实现优化的算法以处理大量位数的数字，其中最流行和普遍使用的算法有以下两种：1.传统的分治算法2.卡拉茨巴乘法1.传统的分治算法传统的分治算法涉及将大的数字分解为更小的数字部分进行乘法运算，并且在计算此过程之间能够快速地进行组合。

该算法需要依靠递归算法的思想，在整个运算过程中采用分治策略。

如果给定两个长度为n的数字，我们可以将这些数字分成两个较小，长度为 n/2 的数字，然后将它们相乘。

在递归调用中，相同的方法会被重复递归调用。

《计算机算法设计与分析》习题及答案一．选择题1、二分搜索算法是利用（ A ）实现的算法。

A、分治策略B、动态规划法C、贪心法D、回溯法2、下列不是动态规划算法基本步骤的是（ A ）。

A、找出最优解的性质B、构造最优解C、算出最优解D、定义最优解3、最大效益优先是（ A ）的一搜索方式。

A、分支界限法B、动态规划法C、贪心法D、回溯法4. 回溯法解旅行售货员问题时的解空间树是（ A ）。

A、子集树B、排列树C、深度优先生成树D、广度优先生成树5．下列算法中通常以自底向上的方式求解最优解的是（ B ）。

A、备忘录法B、动态规划法C、贪心法D、回溯法6、衡量一个算法好坏的标准是（ C ）。

A 运行速度快B 占用空间少C 时间复杂度低D 代码短7、以下不可以使用分治法求解的是（ D ）。

A 棋盘覆盖问题B 选择问题C 归并排序D 0/1背包问题8. 实现循环赛日程表利用的算法是（ A ）。

A、分治策略B、动态规划法C、贪心法D、回溯法9．下面不是分支界限法搜索方式的是（ D ）。

A、广度优先B、最小耗费优先C、最大效益优先D、深度优先10．下列算法中通常以深度优先方式系统搜索问题解的是（ D ）。

A、备忘录法B、动态规划法C、贪心法D、回溯法11.备忘录方法是那种算法的变形。

（ B ）A、分治法B、动态规划法C、贪心法D、回溯法12．哈夫曼编码的贪心算法所需的计算时间为（ B ）。

A、O（n2n）B、O（nlogn）C、O（2n）D、O（n）13．分支限界法解最大团问题时，活结点表的组织形式是（ B ）。

A、最小堆B、最大堆C、栈D、数组14．最长公共子序列算法利用的算法是（ B ）。

A、分支界限法B、动态规划法C、贪心法D、回溯法15．实现棋盘覆盖算法利用的算法是（ A ）。

A、分治法B、动态规划法C、贪心法D、回溯法16.下面是贪心算法的基本要素的是（ C ）。

A、重叠子问题B、构造最优解C、贪心选择性质D、定义最优解17.回溯法的效率不依赖于下列哪些因素（ D ）A.满足显约束的值的个数B. 计算约束函数的时间C.计算限界函数的时间D. 确定解空间的时间18.下面哪种函数是回溯法中为避免无效搜索采取的策略（ B ）A．递归函数 B.剪枝函数 C。

实验2 Strassen矩阵乘法一、 实验目的1.理解Strassen矩阵乘法的分治思想Strassen矩阵乘法的分治法设计模式是：半分+混合2.改进Strassen矩阵乘法对内存的需求若按Strassen矩阵乘法的直接表述实现，则空间复杂度将是O(3n2)，本实验将试图改进这个方面。

3.Strassen矩阵乘法的性能问题改进Strassen矩阵乘法的内存需求，并不一定能改进Strassen矩阵乘法的效率，本实验将试图测试一些较大规模(n>=1024)的n阶方阵的Strassen矩阵乘，探讨其效率问题。

二、 实验环境C/C++编程环境或任何编程语言环境三、 实验内容1． Strassen矩阵乘法描述尽管Strassen矩阵乘法的实用价值在当今的多核计算环境下可能不是那么显著，但其理论价值仍值得我们研究。

Strassen矩阵乘法体现了一类重要的分治算法设计模式，即半分+混合，同样具有这种算法设计模式的是FFT(Fast Fourier Transform)-“由于FFT这个卓越算法在实践上的重要意义，有些人把它看作是有史以来人们发明的最重要的算法之一。

”[1]Strassen 矩阵乘法的基本思想，可由下述矩阵乘法概括：输入：两个n=2k 维方阵A 和B （若A 和B 的维度不是2k ，则通过增加元素为0的行和列，以使A 和B 均为2k 维的方阵）输出：n 维方阵C(1)1+41+443-11+24134.12-43+4113.123-11+224.3424.1314.11.2412.4-4344+=A B =A B =A B =A B =A B M =A B M =A M M B M M M(2)为方便表示，这里采用与书本不同的下标表示法，如对于1个n/2维矩阵14.14M ，下标14.14表示其由两个矩阵A 1+4和B 1+4乘积而成，A 1+4表示A1+A4，同理B 1+4表示B1+B4，同理12.4M 表示A1+2与B4的乘积。

算法设计与分析实验报告二、模型拟制、算法设计和正确性证明：设A和B是两个n*n阶矩阵，求他们两的成绩矩阵C。

这里假设n是2的幂次方；A和B是两个n*n的矩阵，他们的乘积C=AB也是一个n*n的矩阵，矩阵C中的元素C[i][j]定义为C[i][j]= ，则每计算一个C[i][j]，需要做n次乘法和n-1次加法。

因此计算C的n2个元素需要n3次乘法和n3- n2次加法。

因此，所需的时间复杂度是O(n3)。

但是使用分治法可以改进算法的时间复杂度。

这里，假设n是2的幂。

将矩阵A,B,C中每一矩阵都分成4个大小相等的子矩阵，每个子矩阵是（n/2）*（n/2）的方阵。

由此，可将方阵C=AB重写为因此可得：C11=A11B11+A12B21C12=A11B12+A12B22C21=A21B11+A22B22C22=A21B12+A22B22这样就将2个n阶矩阵的乘积变成计算8个n/2阶矩阵的乘积和4个n/2阶矩阵的加法。

当n=1时，2个1阶方阵的乘积可直接算出，只需要做一次乘法。

当子矩阵阶n>1时，为求两个子矩阵的乘积，可继续对两个子矩阵分块，直到子矩阵的阶为1。

由此，便产生了分治降阶的递归算法。

但是这个算法并没有降低算法的时间复杂度。

由strassen矩阵乘法，M1=A11（B12-B22）M2=（A11+A12）B22M3=（A21+A22）B11M4=A22（B21-B11）M5=（A11+A22）（B11+B22）M6=（A12-A22）（B21+B22）M7=(A11-A21)(B11+B12)C11=M5+M4-M2+M6C12=M1+M2C21=M3+M4C22=M5+M1-M3-M7四、程序实现和测试过程：程序测试过程（1）测试过程（2）源程序：#include<iostream>#include<math.h>#include<fstream>using namespace std;ifstream infile("123.txt",ios::in);void Input(int n,int **A){//infile>>n;for(int i=0;i<n;i++)for(int j=0;j<n;j++)infile>>A[i][j];}void Output(int n,int **A){for(int i=0;i<n;i++){for(int j=0;j<n;j++)cout<<A[i][j]<<'\t';cout<<endl;}cout<<endl;}void Divide(int n,int **A,int **A11,int **A12,int **A21,int **A22) {int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++){A11[i][j]=A[i][j];A12[i][j]=A[i][j+n];A21[i][j]=A[i+n][j];A22[i][j]=A[i+n][j+n];}}void Unit(int n,int **A,int **A11,int **A12,int **A21,int **A22) {int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++){A[i][j]=A11[i][j];A[i][j+n]=A12[i][j];A[i+n][j]=A21[i][j];A[i+n][j+n]=A22[i][j];}}void Sub(int n,int **A,int **B,int **C){int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++)C[i][j]=A[i][j]-B[i][j];}void Add(int n,int **A,int **B,int **C){int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++)C[i][j]=A[i][j]+B[i][j];}void Mul(int n,int **A,int **B,int **M){if(n==1)M[0][0]=A[0][0]*B[0][0];else{n=n/2;int **A11,**A12,**A21,**A22;int **B11,**B12,**B21,**B22;int **M11,**M12,**M21,**M22;int **M1,**M2,**M3,**M4,**M5,**M6,**M7;int **T1,**T2;A11=new int*[n];A12=new int*[n];A21=new int*[n];A22=new int*[n];B11=new int*[n];B12=new int*[n];B21=new int*[n];B22=new int*[n];M11=new int*[n];M12=new int*[n];M21=new int*[n];M22=new int*[n];M1=new int*[n];M2=new int*[n];M3=new int*[n];M4=new int*[n];M5=new int*[n];M6=new int*[n];M7=new int*[n];T1=new int*[n];T2=new int*[n];int i;for(i=0;i<n;i++){A11[i]=new int[n];A12[i]=new int[n];A21[i]=new int[n];A22[i]=new int[n];B11[i]=new int[n];B12[i]=new int[n];B21[i]=new int[n];B22[i]=new int[n];M11[i]=new int[n];M12[i]=new int[n];M21[i]=new int[n];M22[i]=new int[n];M1[i]=new int[n];M2[i]=new int[n];M3[i]=new int[n];M4[i]=new int[n];M5[i]=new int[n];M6[i]=new int[n];M7[i]=new int[n];T1[i]=new int[n];T2[i]=new int[n];}Divide(n,A,A11,A12,A21,A22);Divide(n,B,B11,B12,B21,B22);// cout<<"A11,A12,A21,A22"<<endl;// Output(n,A11);Output(n,A12);Output(n,A21);Output(n,A22); Sub(n,B12,B22,T1);// cout<<"B12-B22"<<endl;// Output(n,T1);Mul(n,A11,T1,M1);Add(n,A11,A12,T2);Mul(n,T2,B22,M2);Add(n,A21,A22,T1);Mul(n,T1,B11,M3);Sub(n,B21,B11,T1);Mul(n,A22,T1,M4);Add(n,A11,A22,T1);Add(n,B11,B22,T2);Mul(n,T1,T2,M5);Sub(n,A12,A22,T1);Add(n,B21,B22,T2);Mul(n,T1,T2,M6);Sub(n,A11,A21,T1);Add(n,B11,B12,T2);Mul(n,T1,T2,M7);Add(n,M5,M4,T1);Sub(n,T1,M2,T2);Add(n,T2,M6,M11);Add(n,M1,M2,M12);Add(n,M3,M4,M21);Add(n,M5,M1,T1);Sub(n,T1,M3,T2);Sub(n,T2,M7,M22);Unit(n,M,M11,M12,M21,M22);}}int main(){int n;cout<<"please input number n"<<endl;cin>>n;int **A,**B,**C;A=new int*[n];B=new int*[n];C=new int*[n];for(int i=0;i<n;i++){A[i]=new int[n];B[i]=new int[n];C[i]=new int[n];}Input(n,A);cout<<"A Matrix is"<<endl;Output(n,A);Input(n,B);cout<<"B Matrix is"<<endl;Output(n,B);Input(n,C);//Output(n,C);Mul(n,A,B,C);cout<<"The Product of A and B is"<<endl;Output(n,C);// cout<<n<<endl;in();return 0;}1 / 1。