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

笔记

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

练习

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