【算法导论】第4章 分而治之 (1)

---

Introduction to Algorithms - Third Edition
Part I. Foundations
Chapter 4. Divide-and-Conquer

---

当子问题足够大以进行递归求解时，称其为递归情况（recursive case）。一旦子问题变得很小，以至不再递归的程度，就说递归“结束（bottom out）”了，已经回到了基本情况（base case）。

递归式

递归式与分治法范式提供了一种自然的方式来表征分治算法的运行时间。
递归式（recurrence）是一组等式或不等式，其描述的函数是用在更小的输入下该函数的值来定义的。

本章介绍三种解递归式的方法，即找出解的渐近 $\Theta$ 或 $O$ 界的方法。
代换法（substitution method）：先猜测一个界，再使用数学归纳法证明猜测的正确性。
递归树方法（recursion-tree method）：将递归式转化为树，树中的结点代表不同递归层次付出的代价。使用边界求和的技巧来解递归。
主方法（master method）：给出递归形式 $T(n) = aT(n/b) + f(n)$       (4.2)
的界，其中 $a\ge 1$，$b>1$，$f(n)$ 是给定的函数。

有时，递归式是不等式。例，$T(n) \le 2T(n) + \Theta(n)$，此时，递归式描述了 $T(n)$ 的上界，其解使用 $O$ 形式。相似地，$T(n) \ge 2T(n) + \Theta(n)$，此递归式给出 $T(n)$ 的下界，其解使用 $\Omega$ 形式。

递归式中的技术细节

在描述并解递归式时，常忽略上取整、下取整和边界条件。进行分析时先假设没有这些细节，而后再确定它们重要与否。但我们需要知道它们在什么情况下是重要的。经验和一些定理说明：这些细节不会影响许多递归式（表征分治算法）的渐近界（见定理 4.1）。但是，在本章中，我们将介绍其中一些细节，并说明递归解决方法的要点。

---

4.1 最大子数组问题（The maximum-subarray problem）

问题：允许购买一次股票，然后在以后的某个日期将其出售，目标是使利润最大化。
下表显示了 17 天股票的价格。

Day	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
Price	100	113	110	85	105	102	86	63	81	101	94	106	101	79	94	90	97
Change		13	-3	-25	20	-3	-16	-23	18	20	-7	12	-5	-12	-5	-4	7

图 4.1 表格的最后一行给出了较前一日的价格变化。

暴力解决方案（A brute-force solution）

尝试所有可能的购买和出售日期对，购买日期要早于出售日期。$n$ 天的时间段有 $\binom{n}{2}$ 个这样的日期对。$\binom{n}{2}$ 是 $\Theta(n^2)$，这种方法将花费 $\Omega(n^2)$ 时间。

转换

将图 4.1 中的表格的最后一行视为数组 $A$，找到 $A$ 的非空连续子数组，使其值之和最大。 我们将此连续子数组称为最大子数组（maximum subarray）。
股票价格的变化是最大子数组的问题。子数组 $A[8..11]$ 的和为 43，在数组 $A$ 的任何连续子数组中具有最大的和。因此，在第 7 日购买股票，在第 11 日售出，可以赚取最大利益为每股 43 美元。

分而治之解决方案

程序 FIND-MAX-CROSSING-SUBARRAY 找出子数组 $A[low..high]$ 中跨越中点（称为 $mid$）的最大子数组，运行时间可表示为 $\Theta(n)$，其中 $n$ 是子数组 $A[low..high]$ 的元素个数。

FIND-MAX-CROSSING-SUBARRAY$(A,low,mid,high)$
 1 $left\_sum = -\infty$
 2 $sum=0$
 3 for $i=mid$ downto $low$
 4  $sum = sum + A[i]$
 5  if $sum > left\_sum$
 6   $left\_sum = sum$
 7   $max\_left = i$
 8 $right\_sum = -\infty$
 9 $sum = 0$
10 for $j=mid+1$ to $high$
11  $sum = sum + A[j]$
12  if $sum > right\_sum$
13   $right\_sum = sum$
14   $max\_right = j$
15 return $(max\_left, max\_right, left\_sum+right\_sum)$

程序 FIND-MAX-CROSSING-SUBARRAY 通过分而治之策略解决最大子数组问题。

FIND-MAXIMUM-SUBARRAY$(A, low, high)$
 1 if $high == low$
 2  return $(low, high, A[low])$   // 基本情况：只包含一个元素
 3 else
 4  $mid = \lfloor low+high\rfloor / 2$
 5  $(left\_low,left\_high,left\_sum) =$ FIND-MAXIMUM-SUBARRAY$(A, low, mid)$
 6  $(right\_low,right\_high,right\_sum) =$ FIND-MAXIMUM-SUBARRAY$(A, mid+1, high)$
 7  $(cross\_low,cross\_high,cross\_sum) =$ FIND-MAX-CROSSING-SUBARRAY$(A,low,mid,high)$
 8 if $left\_sum \ge right\_sum$ and $left\_sum \ge cross\_sum$
 9  return $(left\_low,left\_high,left\_sum)$
10 elseif $right\_sum \ge left\_sum$ and $right\_sum \ge cross\_sum$
11  return $(right\_low,right\_high,right\_sum)$
12 else
13  return $(cross\_low,cross\_high,cross\_sum)$

Python 代码实现如下：

def FindMaxCrossingSubarray(A, low, mid, high):
    left_sum = float('-inf')
    ssum = 0
    for i in range(mid, low-1, -1):
        ssum += A[i]
        if ssum > left_sum:
            left_sum = ssum
            max_left = i
    right_sum = float('-inf')
    ssum = 0
    for j in range(mid+1, high+1):
        ssum += A[j]
        if ssum > right_sum:
            right_sum = ssum
            max_right = j
    return (max_left, max_right, left_sum + right_sum)

def FindMaximumSubarray(A, low, high):
    if high == low:
        return (low, high, A[low])
    else:
        mid = (low + high) / 2
        (left_low, left_high, left_sum) = FindMaximumSubarray(A, low, mid)
        (right_low, right_high, right_sum) = FindMaximumSubarray(A, mid+1, high)
        (cross_low, cross_high, cross_sum) = FindMaxCrossingSubarray(A, low, mid, high)
    if left_sum >= right_sum and left_sum >= cross_sum:
        return (left_low, left_high, left_sum)
    elif right_sum >= left_sum and right_sum >= cross_sum:
        return (right_low, right_high, right_sum)
    else:
        return (cross_low, cross_high, cross_sum)
        
if __name__ == "__main__":
    A = [13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-12,-5,-4,7]
    print FindMaximumSubarray(A, 0, len(A)-1)	# 打印 (7, 10, 43)

分析分治算法

在元素个数为 $n$ 的子数组中，FIND-MAXIMUM-SUBARRAY 的运行时间 $T(n)$ 可以用递归式表示为：
$T(n) = \begin{cases} \Theta(1) &\text{if } n=1 \\ 2T(n/2) + \Theta(n) &\text{if } n >1 \end{cases}$       (4.7)
这个递归式的解为 $T(n) = \Theta(n\lg n)$。

练习

4.1-1 当 $A$ 中的所有元素都是负数时，FIND-MAXIMUM-SUBARRAY 返回什么？
解： 返回 $A$ 中最大的元素及其下标。

4.1-2 写出使用暴力方法解决最大子数组问题的伪代码。运行时间为 $\Theta(n^2)$。
解： FIND-MAX-SUBARRAY($A$)
 1 $max\_sum = -\infty$
 2 for $i=1$ to $A.length$
 3  $sum = 0$
 4  for $j=i$ to $A.length$
 5   $sum = sum + A[j]$
 6   if $sum > max\_sum$
 7    $max\_sum = sum$
 8    $low = i$
 9    $high = j$
10 return $(low, high, max\_sum)$

4.1-3 在计算机上分别使用暴力方法和递归算法实现最大子数组问题。什么问题规模 $n_0$ 给出递归算法优于暴力算法的交叉点？当问题规模小于 $n_0$ 时，将递归算法的基本情况改为使用暴力算法。这会改变交叉点吗？
解： 令 $\Theta(n\lg n) \ge \Theta(n^2)$ 的最小正解为 $m_0$，则有 $n_0 \ge m_0$。
当子问题规模小于 $n_0$ 时，使用暴力算法使得子问题花费时间减少，递归算法的总运行时间减少。会改变交叉点，交叉点会变小。

4.1-4 假设改变最大子数组的定义，允许结果为空子数组，其中空子数组的值的和为 0。如何更改不允许空子数组的任何算法，以允许结果为空子数组?
解： 方法一：将求出的最大子数组的和与 0 相比较，取较大的值。
方法二：将初始的 $max\_sum=-\infty$ 改为 $max\_sum = 0$，$left\_sum$ 等作同样处理。将标明子数组范围的索引也初始化为 -1（或其他可行的数字）。

4.1-5 针对最大子数组问题，使用下述思想开发一个非递归的，线性时间的算法。从数组的左端开始，向右移动，记录到目前为止的最大子数组。知道 $A[1..j]$ 的一个最大子数组，扩展一下，找到以索引 $j+1$ 结尾的子数组的最大子数组，可通过以下观察：$A[1..j+1]$ 的最大子数组要么是 $A[1..j]$ 的最大子数组，要么是子数组 $A[i..j+1]$，其中 $1 \le i \le j+1$。在知道索引 $j$ 结尾的最大子数组的基础上，在常数时间内，确定 $A[i..j+1]$ 形式的最大子数组。
解： LINEAR-FIND-MAX-SUBARRAY($A$)
 1 $max\_sum = A[1]$
 2 $sum = A[1]$
 3 $low = 1$
 4 $high = 1$
 5 $start = 1$
 6 for $i=2$ to $A.length$
 7  $sum = sum + A[i]$
 8  if $sum > max\_sum$
 9   $max\_sum = sum$
10   $low = start$
11   $high = i$
12  if $sum < 0$
13   $sum = 0$
14   $start = i$
15 return $(low, high, max\_sum)$

---

4.2 斯特拉森算法（Strassen’s algorithm）求解矩阵相乘

如果 $A=(a_{ij})$ 和 $B = (b_{ij})$ 是 $n \times n$ 矩阵，那么在乘积 $C = A\cdot B$ 中，定义其元素 $c_{ij}$ 为：
$C_{ij} = \sum_{k=1}^{n}a_{ik}\cdot b_{kj}$，      (4.8)
其中，$i,j = 1,2,\dots,n$。
假设每个矩阵有一个属性 $rows$，给出矩阵的行数。

SQUARE-MATRIX-MULTIPLY$(A, B)$
1 $n = A.rows$
2 let $C$ be a new $n \times n$ matrix
3 for $i=1$ to $n$
4  for $j=1$ to $n$
5   $c_{ij} = 0$
6   for $k = 1$ to $n$
7    $c_{ij} = c_{ij} + a_{ik} \cdot b_{kj}$
8 return $C$

程序 SQUARE-MATRIX-MULTIPLY 的运行时间为 $\Theta(n^3)$。
针对 $n \times n$ 矩阵相乘的 Strassen 递归算法的运行时间为 $\Theta(n^{\lg 7})$，所以其运行时间为 $o(n^{2.81})$。

一个简单的分治算法

假设 $n$ 是 2 的幂次，把 $A$，$B$ 和 $C$ 都分成四个 $n/2 \times n/2$ 矩阵。则等式 $C = A \cdot B$ 可以写成：
$\begin{pmatrix} C_{11} & C_{12} \\ C_{21} & C_{22} \end{pmatrix} = \begin{pmatrix} A_{11} & A_{12} \\ A_{21} & A_{22} \end{pmatrix} \cdot \begin{pmatrix} B_{11} & B_{12} \\ B_{21} & B_{22} \end{pmatrix}$       (4.10)
等式（4.10）对应四个等式：
$C_{11} = A_{11}\cdot B_{11} + A_{12} \cdot B_{21}$，     (4.11)
$C_{12} = A_{11}\cdot B_{12} + A_{12} \cdot B_{22}$，     (4.12)
$C_{21} = A_{21}\cdot B_{11} + A_{22} \cdot B_{21}$，     (4.13)
$C_{22} = A_{21}\cdot B_{12} + A_{22} \cdot B_{22}$。     (4.14)

SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A,B)$
 1 $n = A.rows$
 2 let $C$ be a new $n\times n$ matrix
 3 if $n==1$
 4  $c_{11} = a_{11} \cdot b_{11}$
 5 else partition $A$, $B$ and $C$ into $n/2 \times n/2$ matrices
 6  $C_{11} =$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{11},B_{11})$
      $+$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{12},B_{21})$
 7  $C_{12} =$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{11},B_{12})$
      $+$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{12},B_{22})$
 8  $C_{21} =$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{21},B_{11})$
      $+$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{22},B_{21})$
 9  $C_{22} =$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{21},B_{12})$
      $+$ SQUARE-MATRIX-MULTIPLY-RECURSIVE$(A_{22},B_{22})$
10 return $C$

在第 5 行如何划分矩阵？① 创建 12 个新的 $n/2 \times n/2$ 矩阵，需要花费 $\Theta(n^2)$ 时间来复制元素；② 使用索引计算来指定子矩阵，第 5 行运行时间则只有 $\Theta(1)$。
第 6 - 9 行矩阵相加所用时间为 $\Theta(n^2)$。
程序 SQUARE-MATRIX-MULTIPLY-RECURSIVE 运行时间的递归式表示为：
$T(n) = \begin{cases} \Theta(1) &\text{if } n=1, \\ 8T(n/2) + \Theta(n^2) &\text{if } n >1. \end{cases}$       (4.17)
递归式的解为 $T(n) = \Theta(n^3)$。
记住：虽然渐近符号包含常数乘法的因子，但递归式，比如 $T(n/2)$ 不包含。

Strassen 方法

四个步骤：

1. 将输入矩阵 $A$，$B$ 和输出矩阵 $C$ 分解成 $n/2 \times n/2$ 子矩阵。使用索引计算花费 $\Theta(1)$ 时间。
2. 创建 10 个 $n/2 \times n/2$ 矩阵 $S_1,S_2,\dots,S_{10}$，它们是步骤 1 中创建的两个矩阵的和或者差。创建 10 个矩阵花费时间 $\Theta(n^2)$。
3. 使用步骤 1 创建的子矩阵和步骤 2 中的 10 个矩阵，递归计算 7 个矩阵积 $P_1,P_2,\dots,P_7$。矩阵 $P_i$ 是 $n/2 \times n/2$ 的。
4. 通过加减矩阵 $P_i$ 的各种组合，计算出结果矩阵 $C$ 所需的子矩阵 $C_{11}$，$C_{12}$，$C_{21}$，$C_{22}$。计算 4 个矩阵花费时间 $\Theta(n^2)$。

Strassen 算法运行时间 $T(n)$ 的递归式表示为：
$T(n) = \begin{cases} \Theta(1) &\text{if } n=1, \\ 7T(n/2) + \Theta(n^2) &\text{if } n >1. \end{cases}$       (4.18)
递归式（4.18）的解为 $T(n) = \Theta(n^{\lg7})$。

在步骤 2 中，创建了下面 10 个矩阵：
$S_1 = B_{12} - B_{22}$，$S_2 = A_{11} + A_{12}$，$S_3 = A_{21} + A_{22}$，$S_4 = B_{21} - B_{11}$，
$S_5 = A_{11} + A_{22}$，$S_6 = B_{11} + B_{22}$，$S_7 = A_{12} - A_{22}$，
$S_8 = B_{21} + B_{22}$，$S_9 = A_{11} - A_{21}$，$S_{10} = B_{11} + B_{12}$。
在步骤 3 中，
$P_1 = A_{11}\cdot S_1$，$P_2 = S_2 \cdot B_{22}$，$P_3 = S_3 \cdot B_{11}$，$P_4 = A_{22} \cdot S_4$，
$P_5 = S_5 \cdot S_6$，$P_6 = S_7 \cdot S_8$，$P_7 = S_9 \cdot S_{10}$。
在步骤 4 中，
$C_{11} = P_5 + P_4 - P_2 + P_6$，
$C_{12} = P_{1} + P_{2}$，
$C_{21} = P_{3} + P_4$，
$C_{22} = P_5 + P_1 - P_3 - P_7$。

练习

4.2-1 使用 Strassen 算法计算矩阵积 $\begin{pmatrix} 1 & 3 \\ 7 & 5 \end{pmatrix} \begin{pmatrix} 6 & 8 \\ 4 & 2 \end{pmatrix}$。
解： $A_{11} = (1)$，$A_{12} = (3)$，$A_{21} = (7)$，$A_{22} = (5)$，
$B_{11} = (6)$，$B_{12} = (8)$，$B_{21} = (4)$，$B_{22} = (2)$。
$S_1 = (6)$，$S_2 = (4)$，$S_3 = (12)$，$S_4 = (-2)$，$S_5 = (6)$，
$S_6 = (8)$，$S_7 = (-2)$，$S_8 = (6)$，$S_9 = (-6)$，$S_{10} = (14)$。
$P_1 = (6)$，$P_2 = (8)$，$P_3 = (72)$，$P_4 = (-10)$，$P_5 =(48)$，$P_6 = (-12)$，$P_7 = (-84)$。
$C_{11} = (18)$，$C_{12} = (14)$，$C_{21} = (62)$，$C_{22} = (66)$。
所以，所求结果为 $C = \begin{pmatrix} 18 & 14 \\ 62 & 66 \end{pmatrix}$。

4.2-2 写出 Strassen 算法的伪代码。
解： SQUARE-MATRIX-MULTIPLY-STRASSEN$(A, B)$
$n = A.rows$
let $C$ be a new $n\times n$ matrix
if $n==1$
 $c_{11} = a_{11} \cdot b_{11}$
else partition $A$, $B$ and $C$ into $n/2 \times n/2$ matrices
 $S_1 = B_{12} - B_{22}$
 $S_2 = A_{11} + A_{12}$
 $S_3 = A_{21} + A_{22}$
 $S_4 = B_{21} - B_{11}$
 $S_5 = A_{11} + A_{22}$
 $S_6 = B_{11} + B_{22}$
 $S_7 = A_{12} - A_{22}$
 $S_8 = B_{21} + B_{22}$
 $S_9 = A_{11} - A_{21}$
 $S_{10} = B_{11} + B_{12}$
 $P_1 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(A_{11}, S_1)$
 $P_2 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(S_2, B_{22})$
 $P_3 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(S_3, B_{11})$
 $P_4 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(A_{22},S_4$)
 $P_5 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(S_5,S_6)$
 $P_6 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(S_7, S_8)$
 $P_7 =$ SQUARE-MATRIX-MULTIPLY-STRASSEN$(S_9, S_{10})$
 $C_{11} = P_5 + P_4 - P_2 + P_6$
 $C_{12} = P_{1} + P_{2}$
 $C_{21} = P_{3} + P_4$
 $C_{22} = P_5 + P_1 - P_3 - P_7$
return $C$

4.2-3 两个 $n \times n$ 矩阵相乘，其中 $n$ 不是 2 的幂次，如何修改 Strassen 算法？证明得到的算法的运行时间是 $\Theta(n ^{\lg7})$。
解： 将输入矩阵 $A$，$B$ 和输出矩阵 $C$ 分解成 $\lfloor n/2\rfloor \times \lfloor n/2\rfloor$ 子矩阵、$\lfloor n/2\rfloor \times \lceil n/2\rceil$ 子矩阵、$\lceil n/2\rceil \times \lfloor n/2\rfloor$ 子矩阵和 $\lceil n/2\rceil \times \lceil n/2\rceil$ 子矩阵。

证明：使用主方法证明（见章节 4.5）。
描述 Strassen 算法运行时间的递归式为递归式 (4.18)，$T(n) = 7T(n/2) + \Theta(n^2)$。
有 $a = 7$，$b = 2$，$f(n) = \Theta(n^2)$。
所以 $n^{\log_b a} = n^{\log_2 7} = n^{\lg 7}$，又 $2.80 < \lg7 <2.81$，
所以，存在 $\epsilon = 0.8$，有 $f(n) = O(n^{\lg7 - \epsilon})$，符合主定理的情况①。
所以，$T(n) = \Theta(n^{\lg7})$。

4.2-4 如果可以使用 $k$ 次乘法操作完成 $3 \times 3$ 矩阵相乘（不考虑乘法的可交换性），那么可以在 $o(n^{\lg 7})$ 时间内完成 $n\times n$ 矩阵相乘，在这种情况下，$k$ 的最大值是多少？这个算法的运行时间是多少？

解： 如果可以使用 $k$ 次乘法操作完成 $3 \times 3$ 矩阵相乘，那么可以通过递归地进行 $n/3 \times n/3$ 矩阵相乘，完成 $n\times n$ 矩阵相乘，其运行时间是 $T(n) = kT(n/3) + \Theta(n^2)$。
例如，等式 $C = A \cdot B$ 可以写成
$\begin{pmatrix} C_{11} & C_{12} & C_{13} \\ C_{21} & C_{22} & C_{23} \\ C_{31} & C_{32} & C_{33} \end{pmatrix} = \begin{pmatrix} A_{11} & A_{12} & A_{13} \\ A_{21} & A_{22} & A_{23} \\ A_{31} & A_{32} & A_{33} \end{pmatrix} \cdot \begin{pmatrix} B_{11} & B_{12} & B_{13} \\ B_{21} & B_{22} & B_{23} \\ B_{31} & B_{32} & B_{33} \end{pmatrix}$

使用主方法解这个递归式，考虑 $n^{\log_3 k}$ 和 $n^2$ 的比值：
如果 $\log_3 k = 2$，符合情况②，$T(n) = \Theta(n^2\lg n)$。这种情况下，$k=9$，且 $T(n) = o(n^{\lg7})$。
如果 $\log_3k < 2$，符合情况③，$T(n) = \Theta(n^2)$。这种情况下，$k < 9$，且 $T(n) = o(n^2)$。
如果 $\log_3k > 2$，符合情况①，$T(n) = \Theta(n^{\log_3 k})$。这种情况下，$k > 9$。当 $\log_3k < \lg7$ 时（即 $k < 3^{\lg7} \approx 21.85$），$T(n) = o(n^2)$。$k$ 的最大值为 21。

因此，$k=21$，运行时间为 $\Theta(n^{\log_3k}) = \Theta(n^{\log_3 21}) = O(n^{2.80})$。（因为 $\log_3 21 \approx 2.77$）

4.2-5 V. Pan 发现了一个使用 132,464 次乘法操作完成 $68 \times 68$ 矩阵相乘的方式，一个使用 143,640 次乘法操作完成 $70 \times 70$ 矩阵相乘的方式，一个使用 155,424 次乘法操作完成 $72 \times 72$ 矩阵相乘的方式。当使用在分治的矩阵相乘算法中，哪个方法产生最好的渐近运行时间？与 Strassen 算法相比如何？
解： 这 3 种方法的运行时间的递归式分别为：
$T(n) = 132464T(n/68) + \Theta(n^2)$；
$H(n) = 143640S(n/70) + \Theta(n^2)$；
$Q(n) = 155424Q(n) + \Theta(n^2)$。
使用主方法解递归式，得
$T(n) = \Theta(n^{\log_{68} 132464})$，（$\log_{68} 132464 \approx 2.79512848$）
$H(n) = \Theta(n^{\log_{70} 143640})$，（$\log_{70} 143640 \approx 2.79512268$）
$Q(n) = \Theta(n^{\log_{72} 155424})$。（$\log_{68} 132464 \approx 2.79514739$）
所以，第 2 个方法产生最好的渐近运行时间。比 Strassen 算法的渐近运行时间好。

4.2-6 使用 Strassen 算法作为子程序，一个 $kn \times n$ 矩阵与一个 $n \times kn$ 矩阵相乘有多快？将输入矩阵交换位置，回答相同的问题。
解： 本题中两个矩阵相乘示例如下，
$\begin{pmatrix} C_{11} & C_{12} & \dots & C_{1k} \\ C_{21} & C_{22} & \dots & C_{2k} \\ \dots \\C_{k1} & C_{k2} & \dots & C_{kk} \end{pmatrix} = \begin{pmatrix} A_{11} \\ A_{21} \\ \dots \\ A_{k1} \end{pmatrix} \cdot \begin{pmatrix} B_{11} & B_{12} & \dots & B_{1k} \end{pmatrix}$
上面的 $A_{ij}$、$B_{ij}$ 和 $C_{ij}$ 都是 $n \times n$ 矩阵。
$C_{11} = A_{11} \cdot B_{11}，C_{12} = A_{11} \cdot B_{12}$，$\dots$， $C_{1k} = A_{11} \cdot B_{1k}$，
$C_{21} = A_{21} \cdot B_{11}$，$C_{22} = A_{21} \cdot B_{12}$，$\dots$， $C_{2k} = A_{21} \cdot B_{1k}$，
……
$C_{k1} = A_{k1} \cdot B_{11}$，$C_{k2} = A_{k1} \cdot B_{12}$，$\dots$， $C_{kk} = A_{k1} \cdot B_{1k}$。

因为使用 Strassen 算法作为子程序，所以每次进行 $C_{ij}$ 的计算的运行时间为 $\Theta(n^{\lg7})$，一共计算 $k^2$ 次。
所以本题矩阵相乘的运行时间为 $\Theta(k^2 n^{\lg7})$。

将输入矩阵交换位置，运行时间相同，是 $\Theta(k^2 n^{\lg7})$。

4.2-7 设计算法，仅使用 3 次实数乘法，实现复数 $a+bi$ 和 $c+di$ 的相乘。这个算法接受 $a$，$b$，$c$ 和 $d$ 作为输入，分别生成实数部分 $ac-bd$ 和虚数部分 $ad+bc$。
解： MULTIPLY-COMPLEX($a,b,c,d$)
$mult1 = (a+b)\cdot(c+d)$   // 结果为 ac + ad + bc + bd
$mult2 = a\cdot c$
$mult3 = b\cdot d$
$ans1 = mult2 - mult3$
$ans2 = mult1 - mult2 - mult3$
return $(ans1,ans2)$

---

本章节的其他内容：
【算法导论】第4章 分而治之 (2)
【算法导论】第4章 分而治之 (3)

来源：CSDN

作者：阿瑚

链接：https://blog.csdn.net/HPP_CSDN/article/details/103935244