分而治之算法

韩冰

<><b>分而治之算法</b></P>
' B' F! O% T& D3 g# k5 n: h< align=left>君主和殖民者们所成功运用的分而治之策略也可以运用到高效率的计算机算法的设计过程中。本章将首先介绍怎样在算法设计领域应用这一古老的策略，然后将利用这一策略解决如下问题：最小最大问题、矩阵乘法、残缺棋盘、排序、选择和计算一个几何问题——找出二维空间中距离最近的两个点。

本章给出了用来分析分而治之算法复杂性的数学方法，并通过推导最小最大问题和排序问题的复杂性下限来证明分而治之算法对于求解这两种问题是最优的（因为算法的复杂性与下限一致）。
+ i5 m9 B; d; s; ~< align=center><B> 算法思想</B></P>
<>
分而治之方法与软件设计的模块化方法非常相似。为了解决一个大的问题，可以： 1) 把它分成两个或多个更小的问题； 2) 分别解决每个小问题； 3) 把各小问题的解答组合起来，即可得到原问题的解答。小问题通常与原问题相似，可以递归地使用分而治之策略来解决。
9 ~! F6 J/ \% E
例2-1 [找出伪币] 给你一个装有1 6个硬币的袋子。1 6个硬币中有一个是伪造的，并且那个伪造的硬币比真的硬币要轻一些。你的任务是找出这个伪造的硬币。为了帮助你完成这一任务，将提供一台可用来比较两组硬币重量的仪器，利用这台仪器，可以知道两组硬币的重量是否相同。比较硬币1与硬币2的重量。假如硬币1比硬币2轻，则硬币1是伪造的；假如硬币2比硬币1轻，则硬币2是伪造的。这样就完成了任务。假如两硬币重量相等，则比较硬币3和硬币4。同样，假如有一个硬币轻一些，则寻找伪币的任务完成。假如两硬币重量相等，则继续比较硬币5和硬币6。按照这种方式，可以最多通过8次比较来判断伪币的存在并找出这一伪币。
# U7 V+ P# z' t, ^# Y) a' s( i
# }; Q4 R6 K6 X另外一种方法就是利用分而治之方法。假如把1 6硬币的例子看成一个大的问题。第一步，把这一问题分成两个小问题。随机选择8个硬币作为第一组称为A组，剩下的8个硬币作为第二组称为B组。这样，就把1 6个硬币的问题分成两个8硬币的问题来解决。第二步，判断A和B组中是否有伪币。可以利用仪器来比较A组硬币和B组硬币的重量。假如两组硬币重量相等，则可以判断伪币不存在。假如两组硬币重量不相等，则存在伪币，并且可以判断它位于较轻的那一组硬币中。最后，在第三步中，用第二步的结果得出原先1 6个硬币问题的答案。若仅仅判断硬币是否存在，则第三步非常简单。无论A组还是B组中有伪币，都可以推断这1 6个硬币中存在伪币。因此，仅仅通过一次重量的比较，就可以判断伪币是否存在。

现在假设需要识别出这一伪币。把两个或三个硬币的情况作为不可再分的小问题。注意如果只有一个硬币，那么不能判断出它是否就是伪币。在一个小问题中，通过将一个硬币分别与其他两个硬币比较，最多比较两次就可以找到伪币。这样，1 6硬币的问题就被分为两个8硬币（A组和B组）的问题。通过比较这两组硬币的重量，可以判断伪币是否存在。如果没有伪币，则算法终止。否则，继续划分这两组硬币来寻找伪币。假设B是轻的那一组，因此再把它分成两组，每组有4个硬币。称其中一组为B1，另一组为B2。比较这两组，肯定有一组轻一些。如果B1轻，则伪币在B1中，再将B1又分成两组，每组有两个硬币，称其中一组为B1a，另一组为B1b。比较这两组，可以得到一个较轻的组。由于这个组只有两个硬币，因此不必再细分。比较组中两个硬币的重量，可以立即知道哪一个硬币轻一些。较轻的硬币就是所要找的伪币。

例2-2 [金块问题] 有一个老板有一袋金块。每个月将有两名雇员会因其优异的表现分别被奖励一个金块。按规矩，排名第一的雇员将得到袋中最重的金块，排名第二的雇员将得到袋中最轻的金块。根据这种方式，除非有新的金块加入袋中，否则第一名雇员所得到的金块总是比第二名雇员所得到的金块重。如果有新的金块周期性的加入袋中，则每个月都必须找出最轻和最重的金块。假设有一台比较重量的仪器，我们希望用最少的比较次数找出最轻和最重的金块。

假设袋中有n 个金块。可以用函数M a x（程序1 - 3 1）通过n-1次比较找到最重的金块。找到最重的金块后，可以从余下的n-1个金块中用类似的方法通过n-2次比较找出最轻的金块。这样，比较的总次数为2n-3。程序2 - 2 6和2 - 2 7是另外两种方法，前者需要进行2n-2次比较，后者最多需要进行2n-2次比较。

下面用分而治之方法对这个问题进行求解。当n很小时，比如说， n≤2，识别出最重和最轻的金块，一次比较就足够了。当n 较大时（n＞2），第一步，把这袋金块平分成两个小袋A和B。第二步，分别找出在A和B中最重和最轻的金块。设A中最重和最轻的金块分别为HA 与LA，以此类推，B中最重和最轻的金块分别为HB 和LB。第三步，通过比较HA 和HB，可以找到所有金块中最重的；通过比较LA 和LB，可以找到所有金块中最轻的。在第二步中，若n＞2，则递归地应用分而治之方法。
! G3 K; T' L; l* v
假设n= 8。这个袋子被平分为各有4个金块的两个袋子A和B。为了在A中找出最重和最轻的金块，A中的4个金块被分成两组A1和A2。每一组有两个金块，可以用一次比较在A中找出较重的金块HA1和较轻的金块LA1。经过另外一次比较，又能找出HA 2和LA 2。现在通过比较HA1和HA2，能找出HA；通过LA 1和LA2的比较找出LA。这样，通过4次比较可以找到HA 和LA。同样需要另外4次比较来确定HB 和LB。通过比较HA 和HB（LA 和LB），就能找出所有金块中最重和最轻的。因此，当n= 8时，这种分而治之的方法需要1 0次比较。如果使用程序1 - 3 1，则需要1 3次比较。如果使用程序2 - 2 6和2 - 2 7，则最多需要1 4次比较。设c(n)为使用分而治之方法所需要的比较次数。为了简便，假设n是2的幂。当n= 2时，c(n) = 1。对于较大的n，c(n) = 2c(n/ 2 ) + 2。当n是2的幂时，使用迭代方法（见例2 - 2 0）可知

! h3 r6 R- t4 ]6 M! _$ @c(n) = 3n/ 2 - 2。在本例中，使用分而治之方法比逐个比较的方法少用了2 5％的比较次数。

, \* _3 Y# _$ X6 |- _: u例2-3 [矩阵乘法] 两个n×n 阶的矩阵A与B的乘积是另一个n×n 阶矩阵C，C可表示为假如每一个C(i, j) 都用此公式计算，则计算C所需要的操作次数为n3 m+n2 (n- 1) a，其中m表示一次乘法，a 表示一次加法或减法。

为了得到两个矩阵相乘的分而治之算法，需要： 1) 定义一个小问题，并指明小问题是如何进行乘法运算的； 2) 确定如何把一个大的问题划分成较小的问题，并指明如何对这些较小的问题进行乘法运算； 3) 最后指出如何根据小问题的结果得到大问题的结果。为了使讨论简便，假设n 是2的幂（也就是说， n是1，2，4，8，1 6，.）。

; p' f7 b# ?; Y5 ^首先，假设n= 1时是一个小问题，n&gt; 1时为一个大问题。后面将根据需要随时修改这个假设。对于1×1阶的小矩阵，可以通过将两矩阵中的两个元素直接相乘而得到结果。
5 v- v! ^' z, q
考察一个n&gt; 1的大问题。可以将这样的矩阵分成4个n/ 2×n/ 2阶的矩阵A1，A2，A3，和A4。当n 大于1且n 是2的幂时，n/ 2也是2的幂。因此较小矩阵也满足前面对矩阵大小的假设。矩阵Bi 和Ci 的定义与此类似.

根据上述公式，经过8次n/ 2×n/ 2阶矩阵乘法和4次n/ 2×n/ 2阶矩阵的加法，就可以计算出A与B的乘积。因此，这些公式能帮助我们实现分而治之算法。在算法的第二步，将递归使用分而治之算法把8个小矩阵再细分（见程序2 - 1 9）。算法的复杂性为(n3 )，此复杂性与程序2 - 2 4直接使用公式（2 - 1）所得到的复杂性是一样的。事实上，由于矩阵分割和再组合所花费的额外开销，使用分而治之算法得出结果的时间将比用程序2 - 2 4还要长。

  e0 `5 t/ d5 u& a* Q- ^1 e* g* ]为了得到更快的算法，需要简化矩阵分割和再组合这两个步骤。一种方案是使用S t r a s s e n方法得到7个小矩阵。这7个小矩阵为矩阵D, E, ., J，矩阵D到J可以通过7次矩阵乘法， 6次矩阵加法，和4次矩阵减法计算得出。前述的4个小矩阵可以由矩阵D到J通过6次矩阵加法和两次矩阵减法得出.
9 C, O, J* G  M: z$ W# e
0 L( f: h; E  C9 h用上述方案来解决n= 2的矩阵乘法。将某矩阵A和B相乘得结果C，如下所示：

因为n&gt; 1，所以将A、B两矩阵分别划分为4个小矩阵，每个矩阵为1×1阶，仅包含一个元素。1×1阶矩阵的乘法为小问题，因此可以直接进行运算。利用计算D～J的公式，得：

9 u+ t6 ^0 Z) |! zD= 1（6-8）=-2
; P* E- V; j4 D/ U- |/ |
) U. u& m7 R& v! B: |9 ^# T- rE= 4（7-5）= 8
. Z' X7 A4 d* \+ A# N6 v
% v; D2 _: S0 l0 fF=（3 + 4）5 = 3 5
- P. t9 S, N$ i- b8 Z
' h9 w3 x) o6 E4 d3 }G=（1 + 2）8 = 2 4

3 M9 O; i# ?/ A) p8 UH=（3-1）（5 + 6）= 2 2
8 k+ _2 v4 q% K" r' y9 P, u
1 h; y% W- F0 O7 W6 ~9 nI=（2-4）（7 + 8）=-3 0
. G6 `9 ?) h0 I
# C: C1 J/ Q  NJ=（1 + 4）（5 + 8）= 6 5

# ^: z. l1 I" E2 G4 u" ~0 {根据以上结果可得：

  z9 R/ L8 A& e& p' Z8 [对于上面这个2×2的例子，使用分而治之算法需要7次乘法和1 8次加/减法运算。而直接使用公式（2 - 1），则需要8次乘法和7次加/减法。要想使分而治之算法更快一些，则一次乘法所花费的时间必须比11次加/减法的时间要长。
. }& k  b( u: [2 k8 d& ~$ m. z# G
6 a( Z/ A  Z& |$ J. n5 @( }) E假定S t r a s s e n矩阵分割方案仅用于n≥8的矩阵乘法，而对于n&lt;8的矩阵乘法则直接利用公式（2 - 1）进行计算。则n= 8时，8×8矩阵相乘需要7次4×4矩阵乘法和1 8次4×4矩阵加/减法。每次矩阵乘法需花费6 4m+ 4 8a次操作，每次矩阵加法或减法需花费1 6a次操作。因此总的操作次数为7 ( 6 4m+ 4 8a) + 1 8 ( 1 6a) = 4 4 8m+ 6 2 4a。而使用直接计算方法，则需要5 1 2m+ 4 4 8a次操作。要使S t r a s s e n方法比直接计算方法快，至少要求5 1 2-4 4 8次乘法的开销比6 2 4-4 4 8次加/减法的开销大。或者说一次乘法的开销应该大于近似2 . 7 5次加/减法的开销。
& G# b! m2 G" H3 a' t. {
! p5 X0 D% h3 T$ u0 D' [假定n&lt;1 6的矩阵是一个“小”问题，S t r a s s e n的分解方案仅仅用于n≥1 6的情况，对于n&lt;1 6的矩阵相乘，直接利用公式（ 2 - 1）。则当n= 1 6时使用分而治之算法需要7 ( 5 1 2m+ 4 4 8a) +1 8 ( 6 4a) = 3 5 8 4m+ 4 2 8 8a次操作。直接计算时需要4 0 9 6m+ 3 8 4 0a次操作。若一次乘法的开销与一次加/减法的开销相同，则S t r a s s e n方法需要7 8 7 2次操作及用于问题分解的额外时间，而直接计算方法则需要7 9 3 6次操作加上程序中执行f o r循环以及其他语句所花费的时间。即使直接计算方法所需要的操作次数比St r a s s e n方法少，但由于直接计算方法需要更多的额外开销，因此它也不见得会比S t r a s s e n方法快。

n 的值越大，Strassen 方法与直接计算方法所用的操作次数的差异就越大，因此对于足够大的n，Strassen 方法将更快。设t (n) 表示使用Strassen 分而治之方法所需的时间。因为大的矩阵会被递归地分割成小矩阵直到每个矩阵的大小小于或等于k（k至少为8，也许更大，具体值由计算机的性能决定）. 用迭代方法计算，可得t(n) = (nl og27 )。因为l og27 ≈2 . 8 1，所以与直接计算方法的复杂性(n3 )相比，分而治之矩阵乘法算法有较大的改进。

注意事项

分而治之方法很自然地导致了递归算法的使用。在许多例子里，这些递归算法在递归程序中得到了很好的运用。实际上，在许多情况下，所有为了得到一个非递归程序的企图都会导致采用一个模拟递归栈。不过在有些情况下，不使用这样的递归栈而采用一个非递归程序来完成分而治之算法也是可能的，并且在这种方式下，程序得到结果的速度会比递归方式更快。解决金块问题的分而治之算法（例2 - 2）和归并排序方法（ 2 . 3节）就可以不利用递归而通过一个非递归程序来更快地完成。
' M. g+ S1 j4 c6 p5 H3 I+ w
例2-4 [金块问题] 用例2 - 2的算法寻找8个金块中最轻和最重金块的工作可以用二叉树来表示。这棵树的叶子分别表示8个金块（a, b,., h)，每个阴影节点表示一个包含其子树中所有叶子的问题。因此，根节点A表示寻找8个金块中最轻、最重金块的问题，而节点B表示找出a,b,c 和d 这4个金块中最轻和最重金块的问题。算法从根节点开始。由根节点表示的8金块问题被划分成由节点B和C所表示的两个4金块问题。在B节点，4金块问题被划分成由D和E所表示的2金块问题。可通过比较金块a 和b 哪一个较重来解决D节点所表示的2金块问题。在解决了D和E所表示的问题之后，可以通过比较D和E中所找到的轻金块和重金块来解决B表示的问题。接着在F，G和C上重复这一过程，最后解决问题A。
8 S3 L) i3 U% C- x* r; U
* M% l. n5 d) ]. k6 g$ o可以将递归的分而治之算法划分成以下的步骤：
( q/ F7 [; r$ V, u( o5 m! Z
1) 从图2 - 2中的二叉树由根至叶的过程中把一个大问题划分成许多个小问题，小问题的大小为1或2。

3 ]6 |) ~5 ]8 G2) 比较每个大小为2的问题中的金块，确定哪一个较重和哪一个较轻。在节点D、E、F和G上完成这种比较。大小为1的问题中只有一个金块，它既是最轻的金块也是最重的金块。
6 E% e& m; q7 ?2 ]5 X, f
6 p! D" L* T& R# ?* t& Q. _3) 对较轻的金块进行比较以确定哪一个金块最轻，对较重的金块进行比较以确定哪一个金块最重。对于节点A到C执行这种比较。
1 O' W' x* D2 E1 z- ?6 Q
根据上述步骤，可以得出程序1 4 - 1的非递归代码。该程序用于寻找到数组w [ 0 : n - 1 ]中的最小数和最大数，若n &lt; 1，则程序返回f a l s e，否则返回t r u e。

当n≥1时，程序1 4 - 1给M i n和M a x置初值以使w [ M i n ]是最小的重量，w [ M a x ]为最大的重量。
; k8 @& s6 R+ D+ r
首先处理n≤1的情况。若n&gt;1且为奇数，第一个重量w [ 0 ]将成为最小值和最大值的候选值，因此将有偶数个重量值w [ 1 : n - 1 ]参与f o r循环。当n 是偶数时，首先将两个重量值放在for 循环外进行比较，较小和较大的重量值分别置为Min和Max，因此也有偶数个重量值w[2:n-1]参与for循环。

/ u$ n; e  o' a& e2 y$ ]) c( K& M在for 循环中，外层if 通过比较确定( w [ i ] , w [ i + 1 ] )中的较大和较小者。此工作与前面提到的分而治之算法步骤中的2) 相对应，而内层的i f负责找出较小重量值和较大重量值中的最小值和

最大值，这个工作对应于3 )。for 循环将每一对重量值中较小值和较大值分别与当前的最小值w [ M i n ]和最大值w [ M a x ]进行比较，根据比较结果来修改M i n和M a x（如果必要）。
+ f2 Y; U6 y# J; R
# K# P$ w# t8 l6 ]3 J1 t. W8 |# G下面进行复杂性分析。注意到当n为偶数时，在for 循环外部将执行一次比较而在f o r循环内部执行3 ( n / 2 - 1 )次比较，比较的总次数为3 n / 2 - 2。当n 为奇数时，f o r循环外部没有执行比较，而内部执行了3(n-1)/2次比较。因此无论n 为奇数或偶数，当n&gt;0时，比较的总次数为「3n/2ù-2次。
. I) k, @  Q; E
程序14-1 找出最小值和最大值的非递归程序
8 R' h' k0 a+ V: R
template<CLASS T>
+ j3 P& R5 X' D! ~% f2 _8 N0 ^
bool MinMax(T w[], int n, T&amp; Min, T&amp; Max)
0 G8 k, j3 U/ @5 S4 K1 s
{// 寻找w [ 0 : n - 1 ]中的最小和最大值
$ n7 T! ~. v0 }& Y. g; D
// 如果少于一个元素，则返回f a l s e
, n' W6 v. {5 ~- j
4 d" b7 C3 S4 g! B; u/ f// 特殊情形： n &lt;= 1

3 I; P5 Z( J4 U, m. l" dif (n &lt; 1) return false;
( h4 N( L2 F8 r. \3 X% k% n" X
if (n == 1) {Min = Max = 0;

return true;}
! H- \3 `$ @9 h7 c" i2 \+ j- x
6 M5 g, U0 H3 M4 ^2 _! p/ /对Min 和M a x进行初始化
$ H! r: c( b7 W& M9 _
  w9 p6 b- _% j3 mint s; // 循环起点
% l4 ]- ]# j. z5 T- p! ~
if (n % 2) {// n 为奇数
( j3 p) C% l8 L3 F  F
Min = Max = 0;

3 X$ }* o; r5 v" E- l1 \s = 1;}
3 w2 D1 K- B. Q: ^
else {// n为偶数，比较第一对

+ S( }5 I9 A0 i; V; G0 g! r! |if (w[0] &gt; w[1]) {

Min = 1;

Max = 0;}
# O5 }: \1 h' b  @; M
. v% c+ n: \4 zelse {Min = 0;

5 z4 e, e# P" t" d% u, LMax = 1;}

s = 2;}
/ @: h" f4 f- g6 G
" r! }2 `3 u) l// 比较余下的数对
6 \: G: S# o# C5 g& ^3 U( f
for (int i = s; i &lt; n; i += 2) {

// 寻找w 和w [ i + 1 ]中的较大者
7 t% i: g. ?6 q. @1 Z* ^
7 v% ^8 [4 f. E& _5 Y// 然后将较大者与w [ M a x ]进行比较

, Q- v+ f6 A7 D! j' l  M// 将较小者与w [ M i n ]进行比较
* s* X7 T" o- ?: P0 E! |( v
% ]# K; |% ]5 |9 d5 d& Xif (w &gt; w[i+1]) {

5 Z  Y7 N7 I5 z7 n( @& m$ |if (w &gt; w[Max]) Max = i;

if (w[i+1] &lt; w[Min]) Min = i + 1;}

else {
; n2 d1 C/ u7 b" K( B
6 V6 u% b4 Q: o. r, Bif (w[i+1] &gt; w[Max]) Max = i + 1;

if (w &lt; w[Min]) Min = i;}

+ @/ q( @8 X5 f, m+ d}

return true;
$ C% A1 b! n9 p$ K  [# h
}

练习

1. 将例1 4 - 1的分而治之算法扩充到n&gt; 1个硬币的情形。需要进行多少次重量的比较？

+ M: q  U1 @0 Q8 Y2. 考虑例1 4 - 1的伪币问题。假设把条件“伪币比真币轻”改为“伪币与真币的重量不同”，同样假定袋中有n 个硬币。
0 O% M& T' T+ x! W9 W4 {! R
1) 给出相应分而治之算法的形式化描述，该算法可输出信息“不存在伪币”或找出伪币。算法应递归地将大的问题划分成两个较小的问题。需要多少次比较才能找到伪币（如果存在伪币）？
. Y+ h9 J- B: p0 k8 Q$ @
2) 重复1) ，但把大问题划分为三个较小问题。
9 \' o7 f5 A0 ]" V( Q
/ T) V8 h9 I' I+ j5 u7 O3. 1) 编写一个C++ 程序，实现例1 4 - 2中寻找n 个元素中最大值和最小值的两种方案。使用递归来完成分而治之方案。
4 i6 R/ L: M) V7 Y! n0 @  c
2) 程序2 - 2 6和2 - 2 7是另外两个寻找n 个元素中最大值和最小值的代码。试分别计算出每段程序所需要的最少和最大比较次数。
! P2 N3 T; H0 Y8 P
3) 在n 分别等于1 0 0，1 0 0 0或10 000的情况下，比较1）、2）中的程序和程序1 4 - 1的运行时间。对于程序2 - 2 7，使用平均时间和最坏情况下的时间。1）中的程序和程序2 - 2 6应具有相同的平均时间和最坏情况下的时间。

) _8 q0 ^1 r- k: E) D4) 注意到如果比较操作的开销不是很高，分而治之算法在最坏情况下不会比其他算法优越，为什么？它的平均时间优于程序2 - 2 7吗？为什么？
2 I* C% X6 k/ G3 v  o
4. 证明直接运用公式（1 4 -2）~（1 4 - 5）得出结果的矩阵乘法的分而治之算法的复杂性为(n3 )。因此相应的分而治之程序将比程序2 - 2 4要慢。

& x6 f9 `$ }* t5 u0 i5. 用迭代的方法来证明公式（1 4 - 6）的递归值为(n l og27)。
, I4 s3 Q7 b2 F( Q+ T+ s
*6. 编写S t r a s s e n矩阵乘法程序。利用不同的k 值（见公式（1 4 - 6））进行实验，以确定k 为何值时程序性能最佳。比较程序及程序2 - 2 4的运行时间。可取n 为2的幂来进行比较。

- n! Z" C& _3 f; u. B! S% J) Y7. 当n 不是2的幂时，可以通过增加矩阵的行和列来得到一个大小为2的幂的矩阵。假设使用最少的行数和列数将矩阵扩充为m 阶矩阵，其中m 为2的幂。
1 i" |( S2 h/ G3 y0 s0 V
1) 求m / n。

7 V( e* \: R3 I6 L7 `' r" E- D2) 可使用哪些矩阵项组成新的行和列，以使新矩阵A' 和B' 相乘时，原来的矩阵A和B相乘的结果会出现在C' 的左上角？

; d2 ?' a" |( e1 D( M9 ]# f# n, ^8 k8 u5 d1 K3) 使用S t r a s s e n方法计算A' * B' 所需要的时间为(m2.81 )。给出以n 为变量的运行时间表达式。 </P>