分治策略

1 引言

  《算法导论》第四章的标题是分治策略，这章先讲了最大子数组问题和矩阵乘法的Strassen算法，然后讲了求解递归式的方法，带入法、递归树法和主定理法。不过在之前也提到过使用分治策略的归并排序，之后的快速排序也是采用的分治策略，因为快速排序涉及的内容比较复杂，后续博客会单独介绍。

2 分治策略

2.1 分治策略的递归式

  分治策略是将问题分解为小问题，然后将小问题解决了，合并小问题的解，得到问题的解。
  由上面简单的描述可以看出分治策略主要的三个步骤——分解、解决、合并。
  若问题规模被划分的足够小，即对于某个常量$c,n\le c有T(n)=\Theta (1)$。假设把原问题分解为$a$个子问题，每个子问题的规模是原问题的$\frac{1}{b}$。那么，为了求解一个$\frac{n}{b}$的子问题，需要$aT(\frac{n}{b})$来求解$a$个子问题。如果分解问题需要时间$D(n)$，合并问题的解为原问题的解需要时间$C(n)$，那么递归式为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & 若n\le c\\ aT(\frac{n}{b})+D(n)+C(n)& & & & 其他\end{array}$$
若令$f(n)=D(n)+C(n)$，那么递归式为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & 若n\le c\\ aT(\frac{n}{b})+f(n)& & & & 其他\end{array}$$

2.2 归并排序

  分解： 归并排序的分解是数组下标运算，是常量时间。
  合并： 在考虑最坏情况下，例如合并$[1,3,5,7,9][2,4,6,8,10]$（参考伪代码），归并排序的合并时间跟合并序列长度有关，为序列长度的二倍。
  合并操作伪代码：

func merge(A, p, q, r):
	n1=q-1+1
	n2=r-q
	let L[1...n1+1] and R[1...n2+1] be new arrays
	for i = 1 to n1
		L[i]=A[p+i-1]
	for j = 1 to n2
		R[j]=A[q+j]
	max = 9999
	L[n1+1]=max
	L[n2+1]=max
	i=1
	j=1
	for k=p to r
		if L[i]R[j]
			A[k]=R
			j++
	return 

附： 在函数merge(A,p,q,r)中，A为排序的数组，函数的功能是合并已经排序好的子数组A[p:q]和A[q+1:r]。

  解决： 归并排序划分为最小问题的时候是单个元素，对单个元素只有一次访问，因此也是常数时间。
  归并排序伪代码：
MERGE-SORT(A,p,r)

if p

  归并排序的递归式:
  由之前的分析可以知道，归并排序的递归式为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & n=1\\ 2T(\frac{n}{2})+n& & & & n>1\end{array}$$
  归并排序的运行时间: $\Theta (nlogn)$

2.3 查找最小子数组

  求数组$A=[13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7]$中的最大子数组，即求$i,j$使得$maxA[i:j]$。书中给了两种解法，并分析了其运行时间。一种是暴力破解，另外一种是根据分治策略设计的算法。

2.3.1 暴力求解

  暴力求解是穷举所有可能的子数组，然后比较得到其最大的数组值。因此总共有$\left(\genfrac{}{}{0ex}{}{n}{2}\right)$种子数组组合，之后还要比较求出其中最大值。因此，暴力求解的下界为$\Omega (n^2)$。

2.3.2 分治策略求解最大子数组问题

  假如要寻找子数组$A[low:high]$的最大子数组，使用分治策略意味尽量将数组分为等长的两个子数组（分治策略一般将问题分为等长情况，也有不等长的情况，后面求解分治策略的Akra-Bazzi方法就是解决这一类问题的）。若数组的中央为$mid$，那么子数组为$A[low:mid]$和$A[mid+1:high]$，那么任意一连续子数组$A[i:j]$必然属于下列三种情况之一：

• 完全位于子数组$A[low:mid]$中，因此有$low\le i\le j\le mid$
• 完全位于子数组$A[mid+1:high]$中，因此有$mid+1\le i\le j\le high$
• 跨越了中点，因此$low\le i\le mid<j\le high$

  那么最小子数组必然处于上述三种情况中的一种。
  先考虑第三种情况，最大子数组跨越了中点的情况。因为子数组必定跨越重点$mid$，那么分别扫描计算$low$到$mid$和$mid+1$到$high$就可以得到跨越中点的最大子数组。因为遍历了两个子数组，因此所用时间相当于两个子数组长度之和。伪代码如下：
FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)

// 扫描左子数组
left-sum=-9999
sum = 0
for i = mid downto low
	sum = sum + A[i]
	if sum>left-sum
		left-sum = sum
		max-left = i
// 扫描右子数组
right-sum=-9999
sum = 0
for j = mid downto low
	sum = sum + A[j]
	if sum>right-sum
		right-sum = sum
		max-right= j
return (max-left, max-right, left-sum+right-sum)

该伪代码的输入是一个数组，以及其子数组范围及中点坐标。输出是最大子数组范围以及最大子数组中元素之和。
  有了解决最大子数组跨越中点的函数，现在就可以采用分治策略求解最大子数组问题了，伪代码如下：
FIND-MAXIMUM-SUBARRAY(A, low, high)

if high == low
	return (low, high, A[low])         //数组只有一个元素的情况
else mid=(low+high)/2                  //求数组的中点并赋值
	(left-low, left-high, left-sum) = FIND-MAXIMUM-SUBARRAY(A, low, mid)			//求左子数组的最大子数组
	(right-low, right-high, right-sum) = FIND-MAXIMUM-SUBARRAY(A, low, mid)			//求右子数组的最大子数组
	(cross-low, cross-high, cross-sum) = FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)	//求跨越中点的最大子数组
	if left-sum >= right-sum and left-sum >= cross-sum			//当最大子数组在左子数组中
		return (left-low, left-high, left-sum) 
	elseif right-sum >= left-sum and right-sum >= cross-sum		//当最大子数组在右子数组中
		return (right-low, right-high, right-sum)
	else
		return (cross-low, cross-high, cross-sum)			//当最大子数组跨越中点

分治策略求解最大子数组递归式：
  分解：最小子数组问题分解过程是数组下标运算（将数组分为两个子数组），时间是常数时间。
  合并： 将子问题合并的过程也是常数时间。
  解决： 解决过程左右子数组为递归调用，跨越中点的算法为子数组长度的两倍。
  分析FIND-MAXIMUM-SUBARRAY(A, low, high)伪代码，对于$n=1$的情况下，即数组只有一个元素的情况下，一行代码就完成了，即时间花费为$T(1)=\Theta (1)$。
  当$n>1$的情况下，只看非常数时间的几行代码，若总时间为$T(n)$，求最大子数组在左右子数组的代码花费时间$2T(\frac{n}{2})$，求跨越中点的最大子数组花费的时间为$\Theta (n)$。那么有：
$T(n)=2T(\frac{n}{2})+\Theta (n)$
  综合上述分析得到递归式为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & n=1\\ 2T(\frac{n}{2})+n& & & & n>1\end{array}$$
  运行时间为: $\Theta (nlogn)$

2.4 矩阵乘法Stressen算法

2.4.1 直接计算

  考虑问题两个$n\ast n$的方阵$A,B$相乘。$C=AB$，$C$中的任意元素$c_{ij}={\sum }_{k=1}^n{a}_{ik}\ast b_{kj}$。直接计算的伪代码如下：
SQUARE-MATRIX-MULTIPLY

n=A.rows
let C be a new n*n matrix
for i = 1 to n
	for j = 1 to n
		cij = 0
		for k=1 to n
			cij = cij + aik*bkj

很明显，直接计算的代码所用的时间为$\Theta (n^3)$

2.4.2 简单分治策略计算

   矩阵$A,B,C$均为$n\ast n$的方阵，且$C=AB$，假设$n$为2的幂，那么$n\ast n$的矩阵可以被划分为四个$\frac{n}{2}\ast \frac{n}{2}$的子矩阵，因为$n$为2的幂，则只要$n\ge 2$即可以保证能分解为子矩阵。
   假定将矩阵$A,B,C$均分解为四个$\frac{n}{2}\ast \frac{n}{2}$的子矩阵：
$$A=\left[\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right]B=\left[\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right]C=\left[\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right]$$

因此$C=AB$可以表示为：
$$\left[\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right]=\left[\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right]\ast \left[\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right]$$
等价于：
$$\begin{gathered} C_{11}=A_{11}\ast B_{11}+A_{12}\ast B_{21} \\ {C}_{12}=A_{11}\ast B_{12}+A_{12}\ast B_{22} \\ {C}_{21}=A_{21}\ast B_{11}+A_{22}\ast B_{21} \\ {C}_{22}=A_{21}\ast B_{12}+A_{22}\ast B_{22} \end{gathered}$$
上述每个公式对应一个$\frac{n}{2}\ast \frac{n}{2}$的加法和两个$\frac{n}{2}\ast \frac{n}{2}$的乘法。
有了这些只是的铺垫，递归分治算法为：
SQUARE-MATRIX-MULTIPLY-RECURSIVE(A,B)

n = A.rows
let C be a new n*n matrix
if n==1
	c11=a11*b11 //矩阵只有一个元素的时候
else 分解 A,B,C三个矩阵
	C11 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A11,B11) +SQUARE-MATRIX-MULTIPLY-RECURSIVE(A12,B21)
	C11 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A11,B12) +SQUARE-MATRIX-MULTIPLY-RECURSIVE(A12,B22)
	C11 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A21,B11) +SQUARE-MATRIX-MULTIPLY-RECURSIVE(A22,B21)
	C11 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A21,B12) +SQUARE-MATRIX-MULTIPLY-RECURSIVE(A22,B22)

当$n=1$时，只计算一个元素，即一次标量乘法，因此有：$T(1)=\Theta (1)$
当$n>1$的时候是递归情况，在一次递归调用总共计算了8次$\frac{n}{2}\ast \frac{n}{2}$的乘法，花费时间为$8T(\frac{n}{2})$，除此之外，还计算了四次$\frac{n}{2}\ast \frac{n}{2}$的加法，由于每个矩阵有$\frac{n^2}{4}$，因此花费时间为$\Theta (n^2)$。因此递归式可以表达为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & n=1\\ 8T(\frac{n}{2})+\Theta (n^2)& & & & n>1\end{array}$$
根据主定理计算此递归式的运行时间为$T(n)=\Theta (n^3)$。

2.4.3 Strassen 方法求矩阵乘法

   在2.4.2节的简单的分治策略中分成了八个长度为原矩阵一半的矩阵乘法和四次矩阵加法。而Strassen方法是利用数学技巧，减少了一次乘法运算，增加了矩阵的加法运算。Strassen算法步骤具体如下：

1. 按2.4.2中的方法，将输入矩阵$A,B$和输出矩阵$C$分别分解为四个$\frac{n}{2}\ast \frac{n}{2}$的子矩阵（分解矩阵若采用下标运算花费时间为$\Theta (1)$）.
2. 创建10个$\frac{n}{2}\ast \frac{n}{2}$的矩阵$S_1,S_2,S_3,S_4,S_5,S_6,S_7,S_8,S_9,S_{10}$，每个矩阵保存步骤1中矩阵$A,B$的子矩阵的和或差。
3. 利用步骤1和步骤2的矩阵，递归的计算7个矩阵之积,$P_1,P_2,P_3,P_4,P_5,P_6,P_7$.
4. 通过组合不同的$P_i$矩阵计算结果子矩阵$C_{11},C_{12},C_{21},C_{22}$.

  一开始说了strassen方法是相比于2.4.2的算法少了一次乘法，多了几次$\frac{n}{2}\ast \frac{n}{2}$的加法，具体多了几次对算法的效率影响不大，若有兴趣可以根据后续的具体步骤去计算，即有限次加法均可以表示为$\Theta (n^2)$，得到Strassen算法的的递归式为：
$$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & n=1\\ 7T(\frac{n}{2})+\Theta (n^2)& & & & n>1\end{array}$$
根据主定理可以算出递归式的解为：$T(n)=\Theta (n^{lg7})$
现在说明每一步矩阵的创建过程。
第二步中创建的10个矩阵为：
$$\begin{gathered} 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} \end{gathered}$$
第三步中递归计算的7个$\frac{n}{2}\ast \frac{n}{2}$矩阵的乘法，如下所示：
$$\begin{gathered} P_1=A_{11}\ast S_1=A_{11}\ast B_{12}-A_{11}\ast B_{22} \\ {P}_2=S_2\ast B_{22}=A_{11}\ast B_{22}+A_{12}\ast B_{22} \\ {P}_3=S_3\ast B_{11}=A_{21}\ast B_{11}+A_{22}\ast B_{11} \\ {P}_4=A_{22}\ast S_4=A_{22}\ast B_{21}-A_{22}\ast B_{11} \\ {P}_5=S_5\ast S_6=A_{11}\ast B_{11}+A_{11}\ast B_{22}+A_{22}\ast B_{11}+A_{22}\ast B_{22} \\ {P}_6=S_7\ast S_8=A_{12}\ast B_{21}+A_{12}\ast B_{22}-A_{22}\ast B_{21}-A_{22}\ast B_{22} \\ {P}_7=S_9\ast S_{10}=A_{11}\ast B_{11}+A_{11}\ast B_{12}-A_{21}\ast B_{11}-A_{21}\ast B_{12} \end{gathered}$$
第四步，通过组合$P_i$矩阵得到$C$的四个$\frac{n}{2}\ast \frac{n}{2}$子矩阵：
$$\begin{gathered} 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 \end{gathered}$$
  总结：在步骤四中共执行了8次$\frac{n}{2}\ast \frac{n}{2}$加减法，在步骤三中执行了10次$\frac{n}{2}\ast \frac{n}{2}$加减法，因此Strassen方法共执行7次$\frac{n}{2}\ast \frac{n}{2}$乘法，18次$\frac{n}{2}\ast \frac{n}{2}$加法（不过其时间仍然是$\Theta (n^2)$），执行时间为$\Theta (n^{lg7})$；简单的分治策略执行了8次$\frac{n}{2}\ast \frac{n}{2}$乘法，4次$\frac{n}{2}\ast \frac{n}{2}$加法，执行时间为$\Theta (n^3)$。

2.5 分治策略递归式的求解

2.5.1 代入法

  代入法步骤有两步：

1. 猜测解的形式；
2. 用数学归纳法证明其形式；
   例如，归并排序的递归式为：
   $$T(n)=\{\begin{array}{rlrlr}\Theta (1)& & & & n=1\\ 2T(\frac{n}{2})+n& & & & n>1\end{array}$$

   猜想此递归式的上界为$O(nlgn)$，假设问题的规模为2的幂，则

1. 当n=4时，有
   $T(4)=2T(2)+8=4c+12,O(nlgn)=c4lg4=8c$，因此当$c\ge 3$使得边界条件成立
2. 假设当$n=k$时成立则有式子：$\Theta (T(k))\le \Theta (klgk)成立，即:T(k)\le cklgk成立$
3. 当$n=2k$时
   $T(2k)=2T(k)+4k\le 2cklgk+4k$
   而$c\ast 2klg2k=2ck+2cklg2k$
   因此，$\exists c\ge 2$使得不等式成立。

由上可知，只要存在一个足够大的$c$值，均可以使得不等式$\Theta (T(n))\le \Theta (nlgn)$成立。
  代入法在第一猜测中非常依赖经验，在证明过程中也会容易踩坑。

2.5.2 递归树法

  递归树是一种很形象的求解递归式的方法，以递归式$T(n)=3T(\lfloor n/4\rfloor )+\Theta (n^2)$ 为例子。递归树如图所示：

递归树的构建过程如上图所示，计算每一层之和就可以得到总的运算时间；
  首先看树高，算法每一次递归分成3个子问题，而每个子问题是原问题的$\frac{1}{4}$，因此树的高度为$lo{g}_{4}n$。比如：当n为16时，第一次递归分为3个规模为4的子问题，第二次计算前面的子问题即问题规模为4的问题，此时分为3个规模为1的子问题。因此树高与递归子问题的规模有对数关系$lo{g}_{4}n$。
  第一层：第一层由于分解成了三个子问题，问题本身分解和合并的代价（在最开始分治策略的递归式说明了除了子问题的描述之外，其余的代价就是子问题的合并与分解所产生的）为$\Theta (n^2)$，即$c{n}^2$；
  第二层：第二层有三个子问题被分解了，每个子问题本身的分解和合并的代价为$\frac{1}{16}c{n}^2$，总共有三个子问题，因此总代价为$\frac{3}{16}c{n}^2$；
  第三层：每一层都是被分成三个规模为原问题规模$\frac{1}{4}$的问题，因此，每一层的代价为之前层代价的$\frac{3}{4^2}$；第三层的代价和为$(\frac{3}{16}{)}^{2}c{n}^2$；
  倒数第二层：这一层就已经将问题划分为最小的单位了，但是这一层求解的代价依然为问题的合成与分解的代价，因此需要最后一层求解最小子问题的代价和，这一层代价和为$(\frac{3}{16}{)}^{lo{g}_{4}n-1}c{n}^2$
  最后一层：最后一层具有特殊性，因为是划分的最小单位，每个代价都为$\Theta (1)$即任意常数，因此代价和为$个数\ast \Theta (1)$;现在问题就在于求解这个"个数"。
计算个数的过程为：假设$n$为4的幂，即：$n=4^k$则：
$$\begin{array}{rl}T(4^k)& =3T(4^{k-1})+\Theta (n^2)\\ & =3^{2}T(4^{k-2})+...\\ & ...\\ & =3^{k}T(1)...\end{array}$$
$3^k$为最后一层问题的个数，其中$k=lo{g}_{4}n$，因此个数为$3^{lo{g}_{4}n}=n^{lo{g}_{4}3}$，所以最后一层的代价为$\Theta (n^{lo{g}_{4}3})$。
综上总代价为：
$$\begin{array}{rl}T(n)& =c{n}^2+\frac{3}{16}c{n}^2+(\frac{3}{16}{)}^{2}c{n}^2...+(\frac{3}{16}{)}^{lo{g}_{4}n-1}c{n}^2+\Theta (n^{lo{g}_{4}3})\\ & =\frac{(\frac{3}{16}{)}^{lo{g}_{4}n}-1}{\frac{3}{16}-1}c{n}^2+\Theta (n^{lo{g}_{4}3})\end{array}$$
当$n\to \infty$时，
$$\begin{array}{rl}T(n)& =\frac{-1}{\frac{3}{16}-1}c{n}^2+\Theta (n^{lo{g}_{4}3})\\ & =\frac{1}{1-\frac{3}{16}}c{n}^2+\Theta (n^{lo{g}_{4}3})\\ & =\frac{16}{13}c{n}^2+\Theta (n^{lo{g}_{4}3})\\ & =\Theta (n^2)\end{array}$$

2.5.3 主定理法

  相比于前面两种求解递归式的方法，主定理算一种非常方便的方法。主定理如下：
  主定理：令$a\ge 1,b>1$为常数，$f(n)$为渐进正函数，$T(n)$是定义在非负整数上的递归式：$$T(n)=aT(\frac{n}{b})+f(n)$$
其中将$\frac{n}{b}$解释为$\lfloor \frac{n}{b}\rfloor$或$\lceil \frac{n}{b}\rceil$。那么$T(n)$有如下渐进界：

1. 若对某个常数$\epsilon >0$有$f(n)=O(n^{lo{g}_{b}a-\epsilon })$，则有：$T(n)=\Theta (n^{lo{g}_{b}a})$；
2. 若$f(n)=O(n^{lo{g}_{b}a})$，则$T(n)=\Theta (n^{lo{g}_{b}a}lgn)$；
3. 若对某个常数$\epsilon >0$有$f(n)=O(n^{lo{g}_{b}a+\epsilon })$，且对某个常数$c<1$和所有足够大的$n$有$af(\frac{n}{b})\le cf(n)$，则有：$T(n)=\Theta (f(n))$；

这里先引入两个概念：
多项式大于： 若$f(n)$多项式大于$g(n)$，则：$\exists e>0,n_0,使得当n>n_0，有f(n)>g(n)n^e$
多项式小于： 若$f(n)$多项式小于$g(n)$，则：$\exists e>0,n_0,使得当n>n_0，有f(n)<g(n)n^e$
主定理的第一条的条件的含义是，$f(n)$多项式小于$n^{lo{g}_{b}a}$，而不是普普通通的小于，例如：$n<nlgn$，但是并不是多项式小于，因为没有满足条件的$\epsilon >0$使得不等式$n^{\epsilon }>lgn$；
主定理的第三条条件的含义是多项式大于，而第二个条件的含义是分成的子问题使得，存在足够大的常量$c,n$使得子问题的代价小于子问题合并和分解的代价。
例：求解Strassen方法的递归式，Strassen方法满足主定理第一条，因此有：$T(n)=\Theta (n^{lg7})$

2.5.4 Akra-Bazzi方法求解递归式

  这篇博客从一开始到现在写的内容都是关于均等划分的，当遇到例如：$T(n)=T(\lfloor \frac{n}{3}\rfloor )+T((\lfloor \frac{2n}{3}\rfloor )+O(n)$这一类非均等划分的分治策略的时候，就应该采用Akra-Bazzi方法，具体方法不做叙述。

3 总结

  本篇博客简单的将《算法导论》中分治策略以及设计分治策略的部分进行总结，以供以后参考，若有错误欢迎提出。