Divide and Conquer

Divide and Conquer
当输入数据的规模很小时，比如只有一个或两个数字，则绝大多数的问题都很容易解。

可是当输入规模增大时，问题往往变得很难。

因此，算法设计的一个基本方法就是寻找大规模问题解与小规摸问题解之间的关系。

分治术(Divide and Conquer)是这种方法之一。

后面要讲的贪心法和动态规划也是基于这种方法但技巧上有不同之处。

简单地说，分治术的做法是将一个规模为n的问题分解为整数个规模小些的子问题，然后找出这些子问题或者一部分子问题的解并由此得到原问题的解。

在解决这些子问题时，分治术要求用同样的方法递归解出。

那就是说，我们必须把这些子问题再分为更小的问题直至问题的规模小到可以直接解出。

这个不断分解的过程看起来很复杂，但用递归的算法表达出来却往往简洁明了。

通常，在用分治术的算法中只要讲明三件事：
(1)底(bottom case)：对足够小的输入规模，如何直接解出。

(2)分(divide)：如何将一个规模为n的输入分为整数个规模小些的子问题。

(3)合(conquer) ：如何从子问题的解中获得原规模为n的解。

下面我们看一个例子。

1第一个例子−二元搜索
假定有一个已排好序的数组A[1] ≤A[2] ≤…≤A[n]。

现在我们要在这n个数字中查找是否有一个数等于要找的数x。

如果是A[i] = x, 则报告序号i，否则报告无(nil)。

我们可以用以下的算法。

输入：A[p], A[p+1], …, A[r], x
输出: i如果A[i] = x否则nil。

BinarySearch (A, p, r, x);
1. if p > r
2. then return (nil)
3. midpoint ←⎣(p+r)/2⎦
4. if A[midpoint] = x
5. then return (midpoint)
6. else if x < A[midpoint]
7. then BinarySearch (A, p, midpoint-1, x)
8. else BinarySearch (A, midpoint+1, r, x)
9. End
注意，上面的算法只是一个子程序，要搜索数组A[1], A[2], …, A[n]时，主程序需要调用BinarySearch(A, 1, n, x)。

很清楚，上面算法用的是分治术。

它先找出序列的中值(即位于序列中间的数字) A[midpoint]，如果它等于x，则问题解决。

否则，原序列一分为二，前一半为数值小的子序列而后一半为数值大的子序列。

如果x < A[midpoint]，则只需要搜索数值小的子序列，否则搜索数值大的子序列。

搜索子序列的算法是递归进行的。

如果存在某个数A[i] = x, 则在某一步递归时会发现。

否则，要搜索的子序列在某一步递归时变为空集。

这时算法遇到了底(bottom case)而报告nil。

我们注意到，在上面算法中，输入的序列是从A[p] 到A[r], 而不是A[1] 到A[n]。

这是因为分治或递归过程中，子序列的长短以及在原序列中的位置是变化的，而用的算法是一样的。

我们必须用变量而不是常量耒指明搜索的范围，这是在写递归算法时要注意的地方。

对一个用分治术设计的算法，该如何计算其复杂度呢？一般来说，我们可以先建立一个表示复杂度的递推关系并求解得到。

例如，对二元搜索算法，我们可以这样分析：我们把序列A中的数和x之间的比较作为主要的基本运算，把序列A中数字的个数作为输入的规模。

假设在最坏情况下，对一个规模为n的序列，二元搜索算法所需的比较次数为T(n). 那么我们可以有以下的递推关系：
T(0) = 0
T(n) = T(⎣n/2⎦) + 1 (1)
它的解可用求和法得到。

令n = 2k，则有T(2k) = T(2k-1) + 1。

令S(k) = T(2k)，我们有
S(k) = S(k-1) + 1
= S(k-2) + 1 + 1
= …
= S(0) + 1 + 1 + … + 1 (共k个1)
= k+1
= lg n + 1
对于n≠ 2k，我们有2k < n < 2k+1。

2k-1≤⎣n/2⎦ < 2k,
2k-2≤⎣⎣n/2⎦ /2⎦ < 2k-1,
……
1 ≤⎣⎣n/2⎦ /2…⎦ < 2。

可見T(n) = ⎣lg n⎦ + 1 = ⎡lg(n+1)⎤。

2第二个例子
用分治术设计一个算法同时找出数组A[1..n]中的最大和第二大的数，n≥2，并分析所需的比较次数。

解：
以下分治术的算法是作用在数组A[p, r]上的, p≤ r。

在调用该算法时，只须置p = 1，r = n即可。

Largest-and-second-largest (A[p.. r], L, S) //L和S分别为最大和第二大的数
1.if p = r
2.then { L←A[p]
3.S ← - ∞//表示没有第二大数
4.}
5.q←⎣(p+r)/2⎦
rgest-and-second-largest (A[p.. q], L1, S1)
rgest-and-second-largest (A[q+1.. r], L2, S2)
8.if L1 > L2
9.then { L ←L1
10.S ← Max{L2, S1}
11.}
12.else { L ←L2
13.S ← Max{L1, S2}
14.}
15.End
我们用T(n)表示数组中数的比较次数，则有以下递推关系：
T(n) = T(⎣n/2⎦) + T(⎡n/2⎤) + 2 (2)
T(1) = 0
它的解可用主方法得到。

令n = 2k，则有
T(n) = 2T(n/2) + 2
= Θ(n)。

如果想知道更为准确的常数因子，我们可用归纳法证明T(n) = 2n– 2。

归纳基础
因为T(1) = 0所以T(n) = 2n– 2显然在n = 1 时正确。

归纳步骤
由递推关系和归纳假设有以下推导：
T(n ) = T(⎣n /2⎦) + T(⎡n /2⎤) + 2
= (2⎣n /2⎦ -2) + (2⎡n /2⎤ -2) + 2
= (2n -4) + 2
= 2n – 2。

归纳成功。

3 第三个例子
设A 和 B 是两个 n ⨯ n 矩阵。

众所周知，计算其乘积C = AB 通常须要做 θ(n 3) 乘法 和加法。

基於分治术的Strassen 算法可以改进这个复杂度。

下面是这个算法。

为简化起见，我们假设 n = 2k 。

Strassen’s algorithm (A , B , n ) ;
Step 1. 将A 和B 各自划分为4个n /2 ⨯ n /2 的矩阵如下。

A = ⎥⎦⎤⎢⎣⎡A A A A 22211211
， B = ⎥⎦
⎤⎢⎣⎡B B B B 22211211 Step 2. 按下面公式递归计算出7个n /2 ⨯ n /2 的矩阵。

P = (A 11 + A 22)(B 11+ B 22);
Q = (A 21 + A 22)B 11; R = A 11(B 12- B 22);
S = A 22(B 21- B 11);
T = (A 11 + A 22)B 22; U = (A 21 - A 11)(B 11+ B 12); V = (A 12 - A 22)(B 21+ B 22);
Step 3. 按下面公式计算出4个n /2 ⨯ n /2 的矩阵。

C 11 = P + S – T + V ; C 12 = R + T ; C 21 = Q + S ; C 22 = P + R – Q + U ;
Step 4. 输出结果如下。

C = AB = ⎥⎦
⎤⎢⎣⎡C C C C 22211211。

请分析Strassen 算法的复杂度。

你不必证明其正确性。

解:
将A 和B 各自划分为4个n /2 ⨯ n /2 的矩阵后，第2步和第3步递归地进行7 次n /2 ⨯ n /2 矩阵之间的乘法和18 次n /2 ⨯ n /2 矩阵间的加法。

所以，我们可以有以下的递推关系：
T(n ) = 7T(n /2) + 18 ⎪⎭⎫ ⎝⎛22n = Θ(n 7lg ) = Θ(n 81.2).。