矩阵乘法分治法
矩阵乘法快速算法
矩阵乘法快速算法矩阵乘法是计算机科学中一个重要的基本运算，涉及到大量的计算和内存访问。
在求解线性方程组、图形学、机器学习和科学计算等领域中，经常需要对矩阵进行乘法运算。
然而，传统的矩阵乘法算法的时间复杂度较高，无法满足大规模矩阵乘法的要求。
为了提高矩阵乘法的效率，人们提出了许多快速算法。
传统的矩阵乘法算法的时间复杂度为O(n^3)，其中n表示矩阵的维度。
这是因为按照定义，矩阵C的第i行第j列的元素等于A的第i行与B的第j列对应元素的乘积之和。
在传统算法中，我们需要计算矩阵C的每个元素，需要进行大量的乘法和加法运算，导致时间复杂度较高。
为了提高矩阵乘法的效率，人们提出了多种快速算法，如分治法和Strassen算法。
分治法是一种将问题分解为子问题然后逐个解决的方法。
在矩阵乘法中，我们可以将两个n×n的矩阵A和B分别分解为四个n/2×n/2的子矩阵。
然后，我们可以通过递归地计算子矩阵的乘积，并将它们合并为最终的矩阵乘积。
这种方法的时间复杂度为O(n^3)。
Strassen算法是一种更高效的矩阵乘法算法，它的时间复杂度为O(n^log2(7))。
该算法基于分治法的思想，但是在进行矩阵的加法和减法时使用了一些技巧，从而减少了乘法运算的次数。
具体而言，Strassen算法将两个n×n的矩阵A和B分别分解为四个n/2×n/2的子矩阵，并计算出这些子矩阵的七个乘积。
然后，通过组合这些乘积，我们可以计算出矩阵C的四个子矩阵。
最后，我们将这些子矩阵组合起来，得到最终的矩阵乘积。
Strassen算法的关键在于如何进行子矩阵的组合和计算。
该算法使用了四个中间矩阵P1、P2、P3和P4，通过计算这些中间矩阵的和并减去一些乘积，我们可以得到最终的矩阵乘积。
由于中间矩阵的规模较小，所需的乘法运算次数较少，从而减少了算法的时间复杂度。
除了分治法和Strassen算法，还有其他一些矩阵乘法的快速算法，如Coppersmith-Winograd算法和Schonhage-Strassen算法。
用分治法实现矩阵乘法总结归纳
用分治法实现矩阵乘法总结归纳一、概述分治法是一种用来处理复杂问题的数学方法，它包括将一个难以处理的问题分解成若干个分支问题，再用这些子问题的解逐一求解原问题的过程。
分治法通常用在递归算法中，可以帮助解决一些复杂的问题。
矩阵乘法是一种基本的数学操作，在计算机科学领域中有广泛的应用。
由于基本的矩阵乘法算法的算法时间复杂度为O(n ^ 3)，不支持并行的，存在计算效率较低的缺点。
因此，分治法可以有效地提高运算效率，达到O(n ^ 2.37)的地步。
二、实现步骤1、分解：矩阵A的大小为M*N，矩阵B的大小为N*P，将矩阵A 和B分解为m*n矩阵A1，A2，A3，A4，B1，B2，B3，B4，其中m=M/2，n=N/2，P=P/2。
2、计算：计算C的7个矩阵块C11、C12、C21、C22、C31、C32、C41，其中C11=A1*B1，C12=A1*B2，C21=A2*B1，C22=A2*B2，C31=A3*B3，C32=A3*B4，C41=A4*B3。
3、合并：将计算结果合并成一个M*P的矩阵C，C=C11+C12+C21+C22+C31+C32+C41。
4、递归：对矩阵A1和B1重复以上步骤，直到矩阵大小不超过阈值，最后使用基本矩阵乘法求解即可。
三、优点1、分治法能够有效地提高矩阵乘法的计算效率，达到O(n ^ 2.37)的地步。
2、通过分治法并行计算，可以有效地降低矩阵乘法的计算时间。
3、分治法的算法更加简洁，容易理解，更容易实现。
四、缺点1、分治法的子问题的解并不是独立的，所以需要计算额外的开销来合并结果。
2、分治法是一种递归的方法，容易发生栈溢出的情况。
3、分治法的算法仍然依赖于基本的矩阵乘法算法，提升的效率并不明显。
矩阵n次方通用解法
矩阵n次方通用解法矩阵n次方通用解法矩阵是线性代数中的重要概念，它在数学、物理、计算机科学等领域都有广泛的应用。
矩阵的n次方也是一个重要的问题，因为它涉及到很多实际问题中的计算。
本文将介绍矩阵n次方通用解法。
一、矩阵乘法在介绍矩阵n次方通用解法之前，我们需要先了解矩阵乘法。
对于两个矩阵A和B，它们的乘积C为：C(i,j) = ∑(k=1 -> n)A(i,k)*B(k,j)其中C(i,j)表示C矩阵第i行第j列元素，n表示A和B的列数相同。
二、暴力求解最简单的方法是通过暴力求解来计算矩阵n次方。
例如，对于一个2x2的矩阵A和一个正整数n，我们可以通过以下方式计算A^n：result = Afor i in range(n-1):result = result * A这种方法可以得到正确的结果，但是时间复杂度为O(n^3)，当n较大时会非常耗时。
三、分治法分治法是一种常见的优化算法，在计算矩阵n次方时也可以使用。
假设我们要计算A^n，我们可以将其分解为两个子问题：计算A^(n/2)和(A^(n/2))^2。
然后再通过矩阵乘法将两个子问题的结果合并起来即可得到A^n。
该算法的时间复杂度为O(n^3logn)，比暴力求解要快很多。
四、矩阵快速幂矩阵快速幂是一种更加高效的算法，它可以将时间复杂度降低到O(n^3logn)。
具体来说，我们可以先将指数n转换为二进制形式，例如：n = 13 -> 1101然后根据二进制形式中1的位置来计算矩阵的乘积。
以计算A^13为例，我们可以这样做：result = Ibase = Afor i in range(k):if n & (1 << i):result = result * basebase = base * base其中I表示单位矩阵，k表示二进制位数。
该算法的时间复杂度为O(n^3logn)，比分治法还要快一些。
五、应用举例矩阵n次方通用解法在实际问题中有广泛应用。
求矩阵的n次方的方法
求矩阵的n次方的方法简介矩阵的n次方是指将一个矩阵连乘n次的结果。
求矩阵的n次方是在很多数学和工程问题中都会遇到的核心计算任务之一。
本文将介绍几种常见的求矩阵的n次方的方法，包括矩阵乘法运算的定义、直接求解法、分治法以及特征分解法等。
不同的方法有不同的适用场景和时间复杂度，我们将对每种方法进行详细的探讨。
1. 矩阵乘法运算的定义在开始讨论求矩阵的n次方之前，我们首先需要了解矩阵乘法运算的定义。
给定两个矩阵A和B，它们的乘积AB定义为：这里的AB是一个n行p列的矩阵，其中第i行第j列的元素可以通过矩阵A的第i行和矩阵B的第j列的对应元素相乘并求和得到。
2. 直接求解法直接求解法是最直观也最容易理解的一种方法。
我们可以通过连乘n次矩阵A自身来求得矩阵的n次方，即。
具体的求解步骤如下： 1. 初始化一个单位矩阵I，它的大小与矩阵A相同。
2. 循环进行n次矩阵乘法运算，每次将结果保存在I中。
3. 当循环结束后，I即为矩阵A的n次方。
以下是使用直接求解法求解矩阵的n次方的示例代码：def matrix_power(A, n):I = [[1 if i == j else 0 for j in range(len(A))] for i in range(len(A))]for _ in range(n):I = matrix_multiply(I, A)return Idef matrix_multiply(A, B):n, m, p = len(A), len(A[0]), len(B[0])result = [[0 for _ in range(p)] for _ in range(n)]for i in range(n):for j in range(p):for k in range(m):result[i][j] += A[i][k] * B[k][j]return result直接求解法的时间复杂度为O(n^3)。
分治算法之矩阵相乘
分治算法之矩阵相乘矩阵相乘是一种常见的计算问题，它在许多领域中都有重要的应用，如图形学、线性代数和机器学习等。
当需要计算大型矩阵的乘积时，传统的方法可能会遇到时间和空间复杂度过高的问题。
而分治算法可以提供一种高效的解决方案。
分治算法是一种将问题划分成多个子问题来解决的方法。
它将原始问题划分为更小的子问题，然后递归地解决这些子问题，最后将子问题的解合并起来得到原始问题的解。
对于矩阵相乘问题，可以使用分治算法将两个大型矩阵划分为多个子矩阵，然后递归地计算子矩阵的乘积，最后将子矩阵的乘积合并起来得到原始矩阵的乘积。
首先，我们需要定义两个矩阵A和B，它们的乘积记为C。
假设A是一个m×n的矩阵，B是一个n×p的矩阵，C是一个m×p的矩阵。
我们可以将矩阵A划分为四个子矩阵A11、A12、A21和A22，其中A11和A22的大小都是m/2×n/2，A12和A21的大小分别是m/2×n/2和n/2×p/2、同样，我们将矩阵B划分为四个子矩阵B11、B12、B21和B22，它们的大小分别与A11、A12、A21和A22相同。
然后，我们可以使用如下的公式计算C的四个子矩阵：C11=A11×B11+A12×B21C12=A11×B12+A12×B22C21=A21×B11+A22×B21C22=A21×B12+A22×B22最后，我们将这些子矩阵合并起来得到矩阵C。
上述过程可以通过递归的方式进行。
首先，递归地计算A11、A12、A21、A22、B11、B12、B21和B22的乘积，然后将这些乘积子矩阵合并得到C11、C12、C21和C22、最后，将这些子矩阵合并起来得到矩阵C。
分治算法的关键在于将问题划分为更小的子问题，并且递归地解决这些子问题。
在矩阵相乘问题中，通过将矩阵划分为四个子矩阵，可以将原问题划分为更小的子问题，然后递归地计算子问题的解，最后将子问题的解合并起来得到原始问题的解。
实验二Strassen矩阵乘法
实验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。
使用递归与分治法求解3.strassen矩阵乘法
一、概述1.介绍矩阵乘法的概念和意义2.引出递归与分治法在矩阵乘法中的应用二、传统矩阵乘法算法1.介绍传统的矩阵乘法算法原理2.分析传统算法的时间复杂度和空间复杂度3.讨论传统算法在大规模矩阵计算中的局限性三、Strassen矩阵乘法算法原理1.介绍Strassen算法的基本思想和原理2.引出递归与分治法在Strassen算法中的运用3.分析Strassen算法的时间复杂度和空间复杂度四、递归与分治法在Strassen算法中的运用1.详细解释递归与分治法在Strassen算法中的具体应用过程2.分析递归与分治法对算法性能的影响3.讨论递归与分治法在其他算法中的推广应用五、实例分析1.通过具体实例演示Strassen算法和传统算法的计算过程2.对比分析两种算法的计算效率和精度3.总结实例分析结果，展示递归与分治法在Strassen算法中的优势六、改进和优化1.讨论现有Strassen算法的局限性和不足2.提出改进和优化的方案，探讨递归与分治法在算法优化中的作用3.展望递归与分治法在矩阵计算领域的未来发展方向七、结论1.总结文中讨论的内容，强调递归与分治法在Strassen算法中的重要性和价值2.展望递归与分治法在矩阵计算领域的广阔应用前景3.对读者提出建议，鼓励更多的研究者投身于这一领域的研究和探索。
六、改进和优化1. Strassen算法的局限性和不足尽管Strassen算法在理论上具有较低的时间复杂度，但实际应用中也存在一些局限性和不足。
Strassen算法中涉及到的矩阵分块操作会引入额外的运算开销和存储开销，使得在小规模矩阵计算中，并不能体现出明显的优势。
Strassen算法要求矩阵的维度必须为2的幂次方，而实际场景中的矩阵往往难以满足这一条件，限制了算法的适用范围。
另外，由于Strassen算法引入了额外的递归调用，对于小规模矩阵，递归调用会使得算法的性能反而不如传统的矩阵乘法算法。
2. 改进和优化的方案针对Strassen算法的局限性和不足，可以考虑一些改进和优化的方案。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
当n=1时，2个1阶方阵的乘积可直接算出，只需要做一次乘法。当子矩阵阶n>1时，为求两个子矩阵的乘积，可继续对两个子矩阵分块，直到子矩阵的阶为1。由此，便产生了分治降阶的递归算法。
但是这个算法并没有降低算法的时间复杂度。由strassen矩阵乘法，
算法设计与分析实验报告
实验名称：矩阵乘法(分冶法)
一、问题陈述和分析：
1.实验目的：掌握分总冶策略的基本思想以及用分冶法解决问题的一般技巧．运用编程工具，并运用分冶法来解* n阶矩阵，求它们两的乘积矩阵C。这里，假设n是2的幂次方；
3.实验要求：编制程序并对其时间复杂度和空间复杂度进行分析.
4.voidAdd(int n,int **A,int **B,int **C)
函数的功能是：实现C=A+B，A，B，C都是n*n矩阵。
3.voidMul(int n,int **A,int **B,int **M)
函数的功能是：将n*n的矩阵A，B相乘，结果存放在n*n的矩阵M中。
算法设计：
整个算法的大致思想是：在函数Mul(int n,int **A,int **B,int **M)中先判断n的值，若n==1，表示A，B，C均为一阶方阵。则M[0][0]=A[0][0]*B[0][0]；否则，调用Divide(n,A,A11,A12,A21,A22);和Divide(n,B,B11,B12,B21,B22);将A和B都分为四个（n/2）*(n/2)的子矩阵。然后递归调用
正确性证明：
由矩阵乘法的计算方法可知，上述计算方法显然正确
三、时间和空间复杂性分析：
时间复杂性：
Strassen矩阵乘法中，用了7次对于n/2阶矩阵乘法的递归调用和18次n/2阶矩阵的加减运算。由此可知，该算法所需的计算时间T（n）满足如下递归方程
解此递归方程得 。
由此可见，strassen矩阵乘法的计算时间复杂性比普通乘法有较大改进。
int i,j;
for(i=0;i<n;i++)
{
A[i]=new int[n];
B[i]=new int[n];
C[i]=new int[n];
}
程序中定义的函数：
1.voidDivide(int n,int **A,int **A11,int **A12,int **A21,int **A22)
M1=A11（B12-B22）
M2=（A11+A12）B22
M3=（A21+A22）B11
M4=A22（B21-B11）
M5=（A11+A22）（B11+B22）
M6=（A12-A22）（B21+B22）
M7=(A11-A21)(B11+B12)
C11=M5+M4-M2+M6
C12=M1+M2
C21=M3+M4
Add(n,M1,M2,M12);M12=M1+M2
Add(n,M3,M4,M21);M21=M3+M4
Add(n,M5,M1,T1);
Sub(n,T1,M3,T2);
Sub(n,T2,M7,M22);M22=M5+M1-M3-M7
Unit(n,M,M11,M12,M21,M22);
将上面得到的四个矩阵组合成一个n*n矩阵。则这个n*n矩阵就是AB的结果C。
二、模型拟制、算法设计和正确性证明：
设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)。
Mul(n,T1,T2,M6);M6=(A12-A22)(B21+B22)
Sub(n,A11,A21,T1);
Sub(n,B11,B12,T2);
Mul(n,T1,T2,M7);M7=(A11-A21)(B11+B12)
Add(n,M5,M4,T1);
Sub(n,T1,M2,T2);
Add(n,T2,M6,M11);M11=M5+M4-M2+M6
Sub(n,B12,B22,T1);T1=B12-B22
Mul(n, A11,T1,M1);M1=A11(B12-B22)
Add(n,A11,A12,T2);
Mul(n,T2,B22,M2);M2=(A11+A12)B22
Add(n,A21,A22,T1);
Mul(n,T1,B11,M3);M3=(A21+A22)B11
函数实现的功能是：将n*n的矩阵A分块成四个大小相等的（n/2）*(n/2)的子矩阵A11,A12,A21,A22。
2.voidUnit(int n,int **A,int **A11,int **A12,int **A21,int **A22)
函数实现的功能是：将四个（n/2）*(n/2)的矩阵A11,A12,A21,A22合并成一个n*n的矩阵A。
C22=M5+M1-M3-M7
算法共进行7次举证乘法，算法效率得到降低
主要数据的定义：
int n；n是方阵A,B,C的阶
int **A=new int*[n];//矩阵A，B，C的定义，并为它们分配空间。这里A，B是用//于相乘的矩阵，C用于存放AB的结果
int **B=new int*[n];
int **C=new int*[n];
Sub(n,B21,B11,T1);
Mul(n, A22,T1 ,M4);M4=A22(B21-B11)
Add(n,A11,A22,T1);
Add(n,B11,B22,T2);
Mul(n,T1,T2,M5);M5=(A11+A22)(B11+B22)
Sub(n,A12,A22,T1);
Add(n,B21,B22,T2);
但是使用分治法可以改进算法的时间复杂度。这里，假设n是2的幂。将矩阵A,B,C中每一矩阵都分成4个大小相等的子矩阵，每个子矩阵是（n/2）*（n/2）的方阵。由此，可将方阵C=AB重写为
因此可得：
C11=A11B11+A12B21
C12=A11B12+A12B22
C21=A21B11+A22B22
C22=A21B12+A22B22