算法导论 — 4.2 矩阵乘法的Strassen算法

笔记

给定两个$n\times n$正方矩阵$A$和$B$，这两个矩阵的乘法定义为
　　　　　　
　　其中
　　　　　　
　　下面是矩阵乘法的伪代码。
　　
　　很显然，执行SQUARE-MATRIX-MULTIPLY需要花费$\Theta (n^3)$时间。然而，有一种方法可以花费更少的时间，这就是Strassen算法，它本质上也是一种分治法，它的时间复杂度为$\Theta (n^{\mathrm{l}\mathrm{g}7})=O(n^{2.81})$。
　　在介绍Strassen算法之前，我们先尝试简单的分治法来计算矩阵乘法$C=A•B$。假定三个矩阵均为$n\times n$正方矩阵。并且为简化分析，假定$n$为$2$的幂。我们将$A、B$和$C$均分解为$4$个$(n/2)\times (n/2)$的子矩阵。
　　　　
　　于是矩阵乘法可以表示为
　　　　
　　上面的矩阵乘法等价于下面$4$个式子。
　　　　　　
　　上面每个式子都对应$2$次$(n/2)\times (n/2)$矩阵乘法，以及$1$次$(n/2)\times (n/2)$矩阵加法。根据以上分析，可以给出一个递归的分治算法。
　　
　　现在分析这个简单分治法的时间复杂度。调用SQUARE-MATRIX-MULTIPLY-RECURSIVE计算两个$n\times n$矩阵乘法的运行时间用$T(n)$表示。对于$n=1$的初始情况，我们只需计算一次标量乘法，因此$T(1)=\Theta (1)$。当$n>1$时，根据上面的伪代码，$T(n)$包含$8$次$(n/2)\times (n/2)$矩阵乘法的时间和$4$次$(n/2)\times (n/2)$矩阵加法的时间，所以$T(n)=8T(n/2)+\Theta (n^2)$，这里忽略了分解子矩阵的时间。于是，我们得到SQUARE-MATRIX-MULTIPLY-RECURSIVE的运行时间的递时式为
　　　　
　　求解这个递归式得到$T(n)=\Theta (n^3)$。可以看到，这个简单的分治法并没有带来渐近运行时间的提升。
　　下面介绍Strassen算法。Strassen算法同样要将每个矩阵分解为$4$个$(n/2)\times (n/2)$子矩阵。而与简单分治法不同，Strassen算法只需要递归为$7$次，而不是$8$次。下面直接给出Strassen算法的流程。
　　(1) 将输入矩阵$A、B$以及输出矩阵$C$各分解为$4$个$(n/2)\times (n/2)$子矩阵。
　　(2) 创建$10$个$(n/2)\times (n/2)$矩阵$S_1,S_2,\dots ,S_{10}$，如下所示。由于需要进行$10$次$(n/2)\times (n/2)$矩阵的加减法，所以这一步花费$\Theta (n^2)$时间。
　　　　
　　(3) 用步骤(1)分解得到的子矩阵和步骤(2)中创建的$10$个矩阵，递归地计算$7$个矩阵乘积$P_1,P_2,\dots ,P_7$，如下所示。
　　　　
　　(4) 利用矩阵$P_1,P_2,\dots ,P_7$进行加减运算，得到输出矩阵$C$的子矩阵$C_{11},C_{12},C_{21},C_{22}$，如下所示。这一步需要进行$8$次$(n/2)\times (n/2)$矩阵的加减法，所以花费时为$\Theta (n^2)$。
　　　　
　　由于Strassen算法只需要递归为$7$次，因此它的运行时间的递归式为
　　　　
　　求解这个递归式，可以得到Strassen算法的运行时间$T(n)=\Theta (n^{\mathrm{l}\mathrm{g}7})$。

练习

4.2-1 使用Strassen算法计算如下矩阵乘法：
　　　　
　　给出计算过程。
　　解
　　(1) 分解输入矩阵
　　　　
　　(2) 计算矩阵$S_1,S_2,\dots ,S_{10}$
　　　　
　　(3) 计算矩阵$P_1,P_2,\dots ,P_7$
　　　　
　　(4) 计算输出矩阵的$4$个子矩阵
　　　　
　　最终结果为
　　　　
　　
4.2-2 为Strassen算法编写伪代码。
　　解
　　这里还是假设了矩阵的宽高$n$为$2$的幂。下面给出伪代码。
　　
　　
4.2-3 如何修改Strassen算法，使之适应矩阵规模$n$不是$2$的幂的情况？证明：算法的运行时间为$\Theta (n_{\mathrm{l}\mathrm{g}7})$。
　　解
　　为了保证算法的通用性，需要考虑矩阵的宽高$n$不为$2$的幂的情况。分两种情况讨论。
　　(1) $n$为偶数
　　这种情况下$n\times n$矩阵可以直接分解为$4$个$(n/2)\times (n/2)$的子矩阵，因此可以直接应用Strassen算法。为了计算矩阵乘法$C_{n\times n}=A_{n\times n}•B_{n\times n}$，令$m=n/2$，需要将矩阵分解为
　　　　
　　这种情况下，矩阵乘法所花费的时间$T(n)=7T(n/2)+\Theta (n^2)$。
　　(2) $n$为奇数
　　这种情况不能直接应用Strassen算法。为了计算矩阵乘法$C_{n\times n}=A_{n\times n}•B_{n\times n}$，令$m=n-1$，将矩阵做如下分解
　　　　
　　如上所示，每个$n\times n$矩阵被分解为一个$(n-1)\times (n-1)$矩阵、一个$(n-1)\times 1$矩阵、一个$1\times (n-1)$矩阵和一个$1\times 1$矩阵。相应地，矩阵乘法$C_{n\times n}=A_{n\times n}•B_{n\times n}$可以分解为下面$4$个式子。
　　　　
　　上面4个式子包含了8个不同规模的矩阵乘法，下面逐个进行分析。
　　1) $A11_{m\times m}•B11_{m\times m}$：由于$m=n-1$是偶数，所以这个矩阵乘法可以直接应用Strassen算法。
　　这一矩阵乘法所花费的时间为$T(n-1)=7T((n-1)/2)+\Theta ((n-1{)}^2)=7T(\lfloor n/2\rfloor )+\Theta (n^2)$。
　　2) $A12_{m\times 1}•B21_{1\times m}$：采用朴素算法，需要做$(n-1{)}^2$次乘法，因此运行时间为$\Theta (n^2)$。
　　3) $A11_{m\times m}•B12_{m\times 1}$：采用朴素算法，需要做$(n-1{)}^2$次乘法和$(n-1)(n-2)$次加法，因此运行时间也为$\Theta (n^2)$。
　　4) $A12_{m\times 1}•B22_{1\times 1}$：采用朴素算法，需要做$(n-1)$次乘法，运行时间为$\Theta (n)$。
　　5) $A21_{1\times m}•B11_{m\times m}$：采用朴素算法，需要做$(n-1{)}^2$次乘法，以及$(n-1)(n-2)$次加法，运行时间为$\Theta (n^2)$。
　　6) $A22_{1\times 1}•B21_{1\times m}$：采用朴素算法，需要做$(n-1)$次乘法，运行时间为$\Theta (n)$。
　　7) $A21_{1\times m}•B12_{m\times 1}$：采用朴素算法，需要做$(n-1)$次乘法，以及$(n-2)$次加法，运行时间为$\Theta (n)$。
　　8) $A22_{1\times 1}•B22_{1\times 1}$：这仅仅是两个元素的相乘，只花费$\Theta (1)$时间。
　　根据以上分析，除去$A11_{m\times m}•B11_{m\times m}$之外，其他$7$个矩阵乘法加起来的运行时间为$\Theta (n^2)$。因此，当$n$为奇数时，$n\times n$矩阵乘法的运行时间为
　　　　$T(n)=7T(\lfloor n/2\rfloor )+\Theta (n^2)$
　　综合以上两种情况，无论$n$为奇数还是偶数，矩阵乘法的运行时间都为$T(n)=7T(\lfloor n/2\rfloor )+\Theta (n^2)$。忽略其中的⌊ ⌋符号，这与之前分析的Strassen算法的运行时间是一样的。
　　下面给出具备通用性的Strassen算法的伪代码。
　　
　　
　　
4.2-4 如果可以用$k$次乘法操作（假定乘法的交换律不成立）完成两个$3\times 3$矩阵相乘，那么你可以在$o(n^{\mathrm{l}\mathrm{g}7})$时间内完成$n\times n$矩阵相乘，满足这一条件的最大$k$是多少？此算法的运行时间是怎样的？
　　解
　　仍然采用Strassen算法。我们现在分析该算法运行时间的递归式，不过在这里需要以$T(3)$作为边界条件，递归式如下所示。
　　　　
　　如果我们画出递归树，该递归树一共有$lg(n/3)$层。叶结点对应子问题$T(3)$。由于每层的结点数是上一层的$7$倍，因此第$i$层包含$7^i$个结点。因此，叶结点一共有$7^{\mathrm{l}\mathrm{g}(n/3)}=7^{\mathrm{l}\mathrm{g}n-\mathrm{l}\mathrm{g}3}=7^{\mathrm{l}\mathrm{g}n}/7^{\mathrm{l}\mathrm{g}3}=n^{\mathrm{l}\mathrm{g}7}/7^{\mathrm{l}\mathrm{g}3}$个。因此所有叶结点的代价之和为$(n^{\mathrm{l}\mathrm{g}7}/7^{\mathrm{l}\mathrm{g}3})•T(3)=k•(n^{\mathrm{l}\mathrm{g}7}/7^{\mathrm{l}\mathrm{g}3})$。
　　如果要在$o(n_{\mathrm{l}\mathrm{g}7})$时间内完成$n\times n$矩阵相乘，那么必然有$k•(n^{\mathrm{l}\mathrm{g}7}/7^{\mathrm{l}\mathrm{g}3})<n^{\mathrm{l}\mathrm{g}7}$，于是得到$k<7^{\mathrm{l}\mathrm{g}3}\approx 21.85$。所以$k$的最大值为$21$。
　　
4.2-5 V.Pan发现一种方法，可以用$132464$次乘法操作完成$68\times 68$的矩阵相乘，发现另一种方法，可以用$143640$次乘法操作完成$70\times 70$的矩阵相乘，还发现一种方法，可以用$155424$次乘法操作完成$72\times 72$的矩阵相乘。当用于矩阵相乘的分治算法时，上述哪种方法会得到最佳的渐近运行时间？与Strassen算法相比，性能如何？
　　解
　　对于采用分治法的矩阵乘法算法来说，其运行时间都为$\Theta (n^d)$，其中$d$为一个正常数。现在分析题目所给的$3$种方法，其渐近运行时间中的$d$分别为多少。为方便起见，假设$3$种方法的运行时间分别为$T_1(n)=n^{d_1}，T_2(n)=n^{d_2}$和$T_3(n)=n^{d_3}$。
　　用$132464$次乘法操作完成$68\times 68$的矩阵相乘，于是有
　　　　$T_1(68)=68^{d_1}=132464$
　　得到$d_1={\mathrm{l}\mathrm{o}\mathrm{g}}_{68}132464\approx 2.795128$。
　　用$143640$次乘法操作完成$70\times 70$的矩阵相乘，于是有
　　　　$T_2(70)=70^{d_2}=143640$
　　得到$d_2={\mathrm{l}\mathrm{o}\mathrm{g}}_{70}143640\approx 2.795122$。
　　用$155424$次乘法操作完成$72\times 72$的矩阵相乘，于是有
　　　　$T_3(72)=72^{d_3}=155424$
　　得到$d_3={\mathrm{l}\mathrm{o}\mathrm{g}}_{72}155424\approx 2.795147$。
　　根据以上分析，第(2)种方法的渐近运行时间的指数$d_2$是最小的，所以第(2)种方法会得到最佳的渐近运行时间。
　　Strassen算法的渐近运行时间为$\Theta (nlg7)$，$\mathrm{l}\mathrm{g}7\approx 2.807355>d_2$，因此上述第(2)种方法的性能是优于Strassen算法的。
　　
4.2-6 用Strassen算法作为子过程来进行一个$kn\times n$矩阵和一个$n\times kn$矩阵相乘，最快需要花费多长时间？对两个输入矩阵规模互换的情况，回答相同的问题。
　　解
　　两个矩阵$A_{kn\times n}$和$B_{n\times kn}$相乘，得到矩阵$C_{kn\times kn}$。如果要利用Strassen算法，则需要将矩阵$A、B$和$C$按下面的方式分解
　　　　
　　矩阵$C$的任意一个子矩阵$C_{ij}=A_i•B_j$, 这是一个$n\times n$矩阵乘法，采用Strassen算法，运行时间为$\Theta (n^{\mathrm{l}\mathrm{g}7})$。一共有$k^2$个这样的$n\times n$矩阵乘法，所以总的运行时间为$\Theta (k^2•n^{\mathrm{l}\mathrm{g}7})$。
　　如果将输入矩阵的规模互换，即矩阵$A_{n\times kn}$和$B_{kn\times n}$相乘，得到矩阵$Cn\times n$，那么需要将矩阵$A$和$B$按下面的方式分解
　　　　
　　矩阵$C=A1•B1+A2•B2+\dots +Ak•Bk$。一共有$k$个$n\times n$矩阵乘法，并且还有$(k-1)$个$n\times n$矩阵加法，所以总的运行时间为$\Theta (k•n^{\mathrm{l}\mathrm{g}7})$。
　　
4.2-7 设计算法，仅使用三次实数乘法即可完成复数$a+bi$和$c+di$相乘。算法需接收$a、b、c$和$d$为输入，分别生成实部$ac-bd$和虚部$ad+bc$。
　　解
　　借鉴Strassen算法的思想，该问题可以按以下步骤解决。
　　(1) 计算$P_1、P_2$和$P_3$
　　　　$P_1=ad$
　　　　$P_2=bc$
　　　　$P_3=(a–b)(c+d)=ac–bd+ad–bc$
　　(2) 计算实部和虚部
　　　　实部：$P_3–P_1+P_2=ac-bd$
　　　　虚部：$P_1+P_2=ad+bc$
　　该算法只需要$3$次乘法即可。
　　
　　本节代码链接：
　　https://github.com/yangtzhou2012/Introduction_to_Algorithms_3rd/tree/master/Chapter04/Section_4.2