算法导论（二）：渐进符号、递归及解法

麻省理工学院公开课：算法导论。B站地址，网易公开课也有对应的资源。
https://www.bilibili.com/video/av1149902/?p=2

第二集的内容比较多（虽然视频比第一集短了大概10分钟），讲的都是数学的内容，不涉及算法。主要内容是渐近符号、递归及其解法。内容比较难，而且都是数学相关的，从毕业之后就不怎么接触了，所以理解起来有难度。

渐近符号

基本的渐近符号：
O 表示上界，即小于等于 ≤
Ω 表示下界，即大于等于 ≥
Θ 表示渐近等于 =（上一集也有使用这个符号）

还有几个严格符号：
o 表示小于 <
ω 表示大于 >

渐近符号O

主要详细讲解了渐近符号O
对于f(n) = O(g(n))，表示存在适当的常数c>0,n₀>0，使得f(n) ≤ c·g(n)，对于所有的n≥n₀

f(n)可以说是属于g(n)构成的函数集，可以定义O(g(n))为一个函数集
O(g(n)) = { f(n)：存在c>0、n₀>0，使得0≤f(n)≤cg(n)，其中n≥n₀ }

严格意义上来讲，f(n) = O(g(n))中的等号=是不对称的，即不能从右边推算到左边。这里表达的意思是属于某个集合，即相当于f(n) ∈ O(g(n))

有一些关于O符号的精妙用法，把它当作宏来用，
例子：f(n) = n³ + O(n²)
表示f(n)主要是n³，但是还有个低阶项O(n²)。即存在某函数h(n)=O(n²)，使得f(n) = n³ + h(n)。O(n²)是一个误差项

例子：n² + O(n) = O(n²)
表示对所有f(n)∈O(n)，存在h(n)∈O(n²)，使得n²+f(n)=h(n)

渐近符号Ω

f(n) = Ω(g(n)) 这里比较简单带过，Ω的集合版定义为：
Ω(g(n)) = { f(n)：存在c>0、n₀>0，使得0≤cg(n)≤f(n)，其中n≥n₀ }

渐近符号Θ

Θ(g(n)) = O(g(n)) ∩ Ω(g(n))

解递归式

解递归式没有通用的方法（没有万金油），但是有三种主要的方法：代换法、递归树法、主方法。

代换法

代换法和解积分类似，主要有三个步骤：

猜答案，不需要非常精确
验证
找出常数系数，使问题成立

注：代换法的验证是使用数学归纳法，在这一步不能使用O符号。

一个错误的证明：
要证明n=O(1)【显然是不成立的，不然所有算法都是常数复杂度了】
因为
1 = O(1)
...（逐步归纳）
n-1 = O(1)
所以n = (n-1)+1 = O(1) + O(1) = O(1)

上面的证明是错误的，不能在归纳中使用O，因为这里的常数是变化的。如果是有穷数量的常数加倍，没太大问题，这依然是一个常数。但如果是2^k次的这种加倍就有问题了，常数是依赖于n变化的。在归纳过程中，要保证常数系数是不变的。

练习一

T(n) = 4T(n/2) + n
T(1) = Θ(1)

猜测①：T(n) = O(n³)
验证：T(k) ≤ c(k³)，其中k

验证过程如下：
T(n) = 4T(n/2)+n
....... ≤ 4c(n/2)³+n
....... = (1/2)cn³+n
....... = cn³-[(1/2)cn³-n]
其中，cn³为理想情况，余项=[(1/2)cn³-n]
T(n) ≤ cn³, if 余项=[(1/2)cn³-n]≥0
这里的c是一个常数系数，可以设定任何想要的值。比如设置c=2，猜测成立。

猜测②：T(n)=O(n²)
验证：T(k) ≤ c(k²)，其中k

验证过程如下：
T(n) = 4T(n/2)+n
....... ≤ 4c(n/2)²+n
....... = cn²+n
....... = cn²-(-n)
其中，cn²为理想情况，余项=-n
T(n) ≤ cn², if 余项=-n ≥ 0
因为n≥1，所以显然不成立。

猜测③：T(n) = O(c₁n²-c₂n)
验证：T(k) ≤ c₁k²-c₂k，其中k

验证过程如下：
T(n) = 4T(n/2)+n
....... ≤ 4[c₁(n/2)²-c₂(n/2)]+n
....... = c₁n² - 2c₂n + n
....... = c₁n² - c₂n - (c₂n-n)

其中，c₁n²为理想情况，余项=c₂n-n
so，T(n) ≤ c₁n²-c₂n，if 余项=c₂n-n ≥ 0，即c₂≥1。
当n=1，T(1) ≤ c₁ - c₂，又因为T(1) = Θ(1)，故c₁>c₂。

一般大家都比较关心上界，所以只求O，不过偶尔也会求一下下界Ω。

递归树法

在上一集讲归并排序的时候，讲了一点递归树法。这节课找了个稍微复杂点的例子。

练习二

T(n) = T(n/4) + T(n/2) + n²
....... = n² + T(n/4) +T(n/2)
....... = n² + (n/4)² + T(n/16) + T(n/8) + (n/2)² + T(n/8) + T(n/4)
....... = n² + (n/4)² + (n/2)² + [(n/16)²] + [(n/8)²] + [(n/8)²] + [(n/4)²]
....... = ...

注：为了简洁书写，表示[(n/8)²]表示T(n/8)的展开形式

用脑图来表示递归树
第一次展开：T(n) = T(n/4) + T(n/2) + n²，如下图：

T(n) = T(n/4) + T(n/2) + n^2

第二次展开：T(n) = n² + (n/4)² + T(n/16) + T(n/8) + (n/2)² + T(n/8) + T(n/4)，如下图：

T(n) = n^2 + (n/4)^2 + T(n/16) + T(n/8) + (n/2)^2 + T(n/8) + T(n/4)

继续展开：

...

观察得到，算法的初始规模为T(n)，每次递归分解为一个T(n/4)和T(n/2)，每次都会比上一级减少1/4的n，所以可推断最后的叶节点数量 < n

一直递归到T(1)，即常数。观察可得，递归树每层n²的系数是一个等比级数，如第一层为1，第二层为5/16，第三层为25/256......
可得n²的系数总和=1 + 5/16 + 5²/16² + ... + 5^k/16^k ≤ 2

也就是T(n) ≤ 2n² +n = O(n²)

主方法

主方法是递归树法的一个应用，但是比递归树法更精确。但只能应用到特定的递归式上。
特定的递归式：
T(n) = aT(n/b)+f(n)，其中a≥1，b>1，f(n)渐近趋正。
对于规模为n的算法，每次递归可以转化为a个规模为n/b的算法，以及一个非递归的代价f(n)。

渐近趋正：对于足够大的n，f(n)是正的。即存在n0，当n≥n0，f(n)>0。

主方法有个简单的思路：比较非递归函数f(n)和函数n^log_ba（表示递归树叶节点的数量）的大小，比较的结果有三种情况：小于，等于，大于。

情况一：小于
对于第一种情况，f(n) < n^log_ba。
即：f(n) = O(n^{log_ba - ε})，ε>0
==> T(n) = Θ(n^log_ba)，即由n^log_ba作为主导，忽略f(n)。
情况二：等于
第二种情况，f(n) = n^log_ba
注意：这里的等于不是完全等于，而是基本等于。
即：f(n) = Θ(n^log_ba · lg^kn)，k≥0
==> T(n) = Θ(n^log_ba · lg^k+1n)，即f(n)·h，h=lgn。
情况三：大于
第三种情况，f(n) > n^log_ba
即：f(n) = Ω(n^{log_ba + ε})，ε>0
还需要考虑f(n)是如何增长的，需要确保在递归的过程中，f是不断减小的，否则可能得到无限大的值。。
即要求【下一层的总代价af(n/b)】 ≤ 【小于当前层的代价(1-ε')f(n)】，ε' > 0，(1-ε')表示严格<1
==> T(n) = Θ(f(n))，即由f(n)作主导，忽略n^log_ba。

练习三

T(n) = 4T(n/2)+n
代入以上的公式【T(n)=aT(n/b)+f(n)】可得：a=4,b=2,f(n)=n
计算可得n^log_ba = n²
接下来比较 f(n)=n 和 n^log_ba=n²
因为n ≤ n²，所以符合第一种情况，故T(n) = Θ(n²)

练习四

T(n) = 4T(n/2)+n²
代入以上的公式【T(n)=aT(n/b)+f(n)】可得：a=4,b=2,f(n)=n²
计算可得n^log_ba = n²
接下来比较 f(n)=n² 和 n^log_ba=n²
因为n² == n²，所以符合第二种情况，故T(n) = Θ(n²lg^k+1n)
即T(n) = Θ(n²lgn)，设定k=0

练习五

T(n) = 4T(n/2)+n³
省略一下推算，符合第三种情况
即T(n) = Θ(n³)

主方法的证明

下面用递归树法证明主方法是成立的
T(n) = aT(n/b) + f(n)
...... = f(n) + f(n/b) + f(n/b) + ... + f(n/b) -------------------- a个f(n/b)
...... = f(n/b²) + f(n/b²) + ... + f(n/b²)----------------a²个f(n/b)
...... = 常数 ----------Θ(1)

用脑图来表示递归树
第一次展开：T(n) = aT(n/b) + f(n)，如下图：

T(n) = aT(n/b) + f(n)

第二次展开：T(n) = f(n) + af(n/b) + a²T(n/b²)，如下图：

T(n) = f(n) + af(n/b) + a^2T(n/b^2)

继续展开如图：

...

求取最后叶节点的数量leaves，以及递归树的高度height。

高度 height = log_bn【这个比较好求，等下在后面补充一下】
叶节点leaves = a^height = a^log_bn
根据对数的性质：a^log_bn = n^log_ba，故leaves = n^log_ba
对于最后Θ(1)的叶节点，共n^log_ba片，时间复杂度为Θ(n^log_ba)

接下来比较递归树最底层的n^log_ba和最顶层的f(n)。
对于第三种情况，f(n)>n^log_ba，递归的代价a^kf(n/b^k) 逐渐降低，即成本呈几何级数降低，由最顶层的f(n)占主导，故Θ(f(n))。
对于第一种情况，f(n)log_ba，递归成本呈几何级数增长，时间复杂度由最底层的成本n^log_ba占主导，故Θ(n^log_ba)。
对于第二种情况，f(n)=n^log_ba，每一层的成本都渐近地相等，故时间复杂度为Θ(f(n)·h) = Θ(f(n)·log_bn) = Θ(f(n)·lgn)。

如何求得递归树的高度为 log_bn?
n
n/b
n/b²
n/b³
...
n/b^k ------- 1
递归树的高度为n --> 1的高度，即n --> n/b^k的高度。由上面的图可得高度为k，而n/b^k = 1，即n=b^k，即k=log_bn。