算法导论-3.递归部分习题选

这一部分主要算法导论中递归式、堆排序和快速排序章节里选择的对我而言较有价值的题目。

练习4.1-1 证明 $T(n)=T(\lceil n/2\rceil)+1$ 的解为 $O(\lg n)$ 。

解答:猜测 $T(n)\leq c\cdot \lg(n-b)$ ($-b$ 的原因见《算法导论》-4.1代换法-一些细微问题),则用数学归纳法,如果其满足 $n/2$ 则对 $n$ 有:

$$T(n)=T(\lceil n/2\rceil)+1\leq c\cdot \lg(\lceil n/2\rceil-b)+1\leq c\cdot \lg(n+1-2b)-c\cdot \lg2+1\leq c\cdot \lg n$$

最后一个不等号在 $c>1$ 而且 $b>1$ 的情况下成立。

练习4.1-6 求解递归式 $T(n)=2T(\sqrt{n})+1$ 的渐进紧确解。

思路:令 $m=\lg n$ 则原递归式 $T(n)$ 可以表示为 $S(m)=T(2^{m})=2T(2^{m/2})+1=2S(m/2)+1$ 。猜测 $S(m)\leq cm-b$ ,数学归纳法证明,如果其去满足 $m/2$ 则对 $m$ 有:

$$S(m)=2S(m/2)+1\leq2(cm/2-b)+1=cm-2b+1\leq cm$$

代入到 $T(n)$ 中则 $T(n)\leq c\cdot \lg n$,即 $T(n)=\mathrm{O}(\lg n)$ 。

练习4.2-2 利用递归树证明 $T(n)=T(n/3)+T(2n/3)+cn$ 的解是 $\Omega(n\lg n)$ 。

思路:该递归树不是完全二叉树,叶子节点有深有浅,最浅的叶子节点是从根节点沿着路径 $n\rightarrow (1/3)n\rightarrow (1/3)^{2}n\rightarrow ...\rightarrow (1/3)^{k}n=1$,的层数 $k=\log_{3}n$ 。在该最浅的层数向上,每一层的代价都是 $cn$ 。因此 $T(n)\geq k\cdot cn = cn\cdot \log_{3}n=\Omega(n\lg n)$ 。

练习4.2-4 利用递归树求递归式 $T(n)=T(n-a)+T(a)+cn$ 的渐进紧确界。

思路:画出递归树,该递归树极不平衡,所有是右孩子的节点全部是叶子节点,根节点的代价是 $cn$ ,第 $i$ 层的代价是 $c(n+(1-i)a)$ 。一共有 $n/a$ 层(包括根节点的第 $0$ 层)。总代价:

$$T(n)=cn+\sum_{i=1}^{n/a-1}c(n+(1-i)a)=\Theta(n^{2})$$

练习4.2-5 利用递归树求递归式 $T(n)=T((1-a)n)+T(an)+cn$ 的渐进紧确界。

思路:做算法导论的题目,关键还是要理解题目的意图。这道题和上一道是姊妹题,意在说明递归树划分时,如果用常数划分,不管划分得多么均衡,其代价都是 $\Theta(n^{2})$ ,如果用比例划分,不管划分得多么失衡,其代价都是 $\Theta(n\lg n)$ ,其原因就是 $n$ 可以足够大,以突出常数划分的失衡和比例划分的均衡。练习4.2-2已经证明了其特殊情况的下界(一般情况也没有什么区别,$1/3$系数的影响最终进入了常数项),即 $T(n)=\Omega(n\lg n)$ 。现在只要证明 $T(n)=O(n\lg n)$ :如果 $T(n)\leq dn\lg n$ ,用代换法:

$$T(n)\leq d(1-a)n\lg(1-a)n+dan\lg an+cn=dn\lg n +dn(a\lg a+(1-a)\lg(1-a))$$

因为 $a\in (0,1)$ ,所以 $\lg a<0,\lg(1-a)<0$,$d$ 有合适的取值能够使得 $T(n)\leq dn\lg n$ 。

思考题4-2 某数组 $A[1...n]$ 含有从 $0$ 到 $n$ 的整数,但是缺了一个。另有一个数组 $B[0...n]$ 含有从 $0$ 到 $n$ 的所有整数。但是不能够单独访问数组中的某个整数,而只能访问某一位(整数是二进制的),就是说对数组 $A$ 的操作只能是“取 $A[i]$ 的第 $j$ 位”。给出一个代价为 $\Theta(n)$ 的算法,找出这个所缺的整数。

思路:二进制无符号整数一共 $\lceil \lg n\rceil$ 位。统计数组 $4$ 和 $B$ 中第 $1$ 位 为 $1$ 的整数个数(代价为 $\Theta(n)$),如果 $A$ 中第 $1$ 位为 $1$ 的整数个数小于 $B$ 中的,说明缺失的整数的第 $1$ 位是 $1$ ,否则缺失整数的第一位是 $0$ ;在数组 $A$ 和 $B$ 第 $1$ 位是 $1$ 或 $0$ 的整数里继续统计第二位为 $1$ 的整数个数(代价为 $\Theta(n/2)$)......直到确定缺失的整数的每一位。整个算法耗费的代价为:

$$\Theta(n)+\Theta(n/2)+...+\Theta(n/(2^{\lg n}))=\Theta(2n)=\Theta(n)$$

思考题4-5 斐波纳契数。定义生成函数(形式幂函数)为:

$$f(x)=\sum_{i=0}^{\infty}F_{i}z^{i}=0+z+z^{2}+2z^{3}+3z^{4}+5z^{5}+...$$

  1. 求证 $f(x)=z+z\cdot f(x)+z^{2}\cdot f(x)$ 。
    解答:将 $f(x)$ 代入
    $$f(x)=z+\sum_{i=0}^{\infty}F_{i}\cdot z^{i+1}+\sum_{i=0}^{\infty}F_{i}\cdot z^{i+2}=z+ z^{2}+\sum_{i=2}^{\infty}F_{i}\cdot z^{i+1}+\sum_{i=2}^{\infty}F_{i-1}\cdot z^{i+1}=z+z^{2}+\sum_{i=3}^{\infty}F_{i}\cdot z^{i}=\sum_{i=0}^{\infty}F_{i}\cdot z^{i}$$
  2. 证明:
    $$f(x)=\frac{z}{1-z-z^{2}}=\frac{z}{(1-\phi z)(1+\hat{\phi}z)}=\frac{1}{\sqrt{5}}\cdot(\frac{1}{1-\phi z}-\frac{1}{1+\hat{\phi} z})$$
    思路:将a中证明的式子变换就可以得到。

这一道题后面还有两道证明做不出来。

思考题4-6 VLSI(超大规模集成)芯片测试。有 $n$ 个设计完全相同的芯片,有一部分次品(坏的芯片)。这些芯片可以两两相互测试,报告另一个芯片是好的或是坏的。好的芯片总是如实报告另一个芯片的好坏,而坏的芯片的报告结果不可控制,即:

  • A报告:B是好的;B报告:A是好的。则都是好的或者都是坏的。
  • A报告:B是坏的;B报告:A是坏的。则至少有一个坏的。
  • A报告:B是好的;B报告:A是坏的。则至少有一个坏的。
  • A报告:B是坏的;B报告:A是好的。则至少有一个坏的。

已知好的芯片的数量大于 $n/2$ ,给出代价为 $\Theta(n)$ 的算法,找出所有好的芯片。

思路:只要找到一个好芯片,就可以用代价 $\Theta(n)$ 找出所有的好芯片。找一个好芯片的过程是这样:随机两两组合成 n/2 组互相测试,将互相报告是好芯片(上面的第一种)这种情况的组合挑出来,将每个组合拆下一个芯片,单独放在一起,构成原先 $n$ 芯片的一个子集(当子集的规模小于 $n/2$ 的时候,算法的代价才为 $\Theta(n)$)。对这个子集重复该方法,直到子集中只剩下一个芯片,该芯片就是好芯片。当然,这里忽略了 $n$ 为奇数的情况,那么就先假设 $n$ 是 $65536$ 之流吧。

需要证明的是这么几点:首先,需要证明该子集非空,即能选出这样的子集来:因为A中好芯片的数量大于 n/2 ,必定会出现好芯片和好芯片互相测试的组合,所以子集不可能为空;其次,需要证明子集的规模不大于 $n/2$ , 只有这样算法的代价才能够控制在 $\Theta(n)+\Theta(n/2)+...+\Theta(1)=\Theta(n)$ 以内:因为随机选取一对芯片中的一个加入子集,即使在最极端的情况下,好芯片仅仅和好芯片组合,坏芯片和坏芯片组合并共同“欺骗”测试者互相报告为好芯片,那么也仅仅有 $n/2$ 个芯片入选;最后,需要证明子集中好芯片的数量仍然大于子集元素个数的一半,使该条件传递下去直到子集中仅有一个元素:考虑没有被选入子集的芯片,要么是好芯片和坏芯片的组合,要么是坏芯片和坏芯片的组合,肯定没有好芯片和好芯片的组合,所以没有被选入子集的芯片中坏芯片的数量大于等于好芯片的数量,考虑到所有芯片中好芯片的数量大于坏芯片的数量,那么子集中好芯片的数量一定大于坏芯片的数量。

最后得到一个芯片,一定是好芯片,再用该芯片测试其他剩下的芯片,得到所有的好芯片。

思考题4-7 Monge矩阵。这道题比较长,难度不大,但结论却很有趣,因此把结论写下来,具体证明过程就略去。

一个 $m\times n$ 矩阵可以被称为Monge矩阵,当且仅当:对于所有 $i,j,k,l$ 有 $1\leq i<k\leq m$ 和 $1\leq j<l\leq m$,则:$A[i,j]+A[k,l]\leq A[i,l]+A[k,j]$ 。下面是一个Monge矩阵:

$$\begin{matrix}10 & 17 & 13\\ 17 & 22 & 16\\ 24 & 28 & 22\\11 & 13 & 6\end{matrix}$$

直观上,小的数分布在左上右下直线上,大的数分布在左下右上直线上。有这么几个有趣的结论:

  1. 一个矩阵为Monge矩阵的充要条件是:对所有的 $i=1,2,...,m-1$ 和 $j=1,2,...,n-1$ ,有:$A[i,j]+A[i+1,j+1]\leq A[i,j+1]+A[i+1,j]$ 。即当且仅当矩阵中的每一个 $2\times 2$的小矩阵都为Monge矩阵时,整个大矩阵才而且一定为Monge矩阵。
  2. 认为 $f(i)$ 表示第 $i$ 行中最小的数的列索引,如上面的矩阵,$f(1)=1,f(2)=f(3)=f(4)=3$ 。则有 $f(i)$ 是非严格递增函数,任意 $i<j$ 有 $f(i)<f(j)$ 。
  3. 从Monge矩阵中任意抽掉几行或几列,得到的新矩阵依然是Monger矩阵。这一个特性可以用来参加递归算法。

练习6.5-8 给出一个时间为 $O(n\lg k)$ 的算法,将 $k$ 个已排序的链表合并成一个排序链表的算法。$n$ 为输出链表中元素的个数。(最小堆做k路链接)。

思路:类似于最小堆排序,构建一个最小堆,每个节点表示一个已排序链表,节点值就是链表的第一个值,根节点就是第一个元素最小的链表。从根节点链表中取出第一个元素放入输出中,代价为 $O(1)$,这是最小的元素;然后根节点的值变大了,可能违反了最小堆性质,运行“保持最小堆性质”,代价为 $O(\lg k)$。每找出一个元素需要 $O(\lg k)+O(1)=O(\lg k)$ 代价,全部排序 $n$ 个元素需要的代价是 $O(n\lg k)$ 。

思考题6-2 对 $d$ 叉堆的分析。$d$ 叉堆和二叉堆类似,唯一的例外是每个非叶子节点有 $d$ 个子女而不是 $2$ 个。

  1. 如何在数组中表示 $d$ 叉堆(类似二叉堆)。我在草稿上找了半天规律,还是被卡住了……答案是:索引为 $i$ 的节点的第 $j$ 个孩子节点的索引为 $d\cdot (i-1)+j+1$,父节点的索引为 $(i-2)/d+1$ 。关键的思想就是:索引值为 $i$ 的节点的第 $j$ 个孩子节点,其前面的所有节点是:索引值为 $i$ 的节点的前面的所有节点($i-1$ 个)的子节点,加上自己的前 $j-1$ 个孩子节点,加上根节点。
  2. $d$ 叉堆的高度是?答案 $\lceil \log_{d}n\rceil$ 。
  3. 给出 $d$ 叉堆的Extract-Max,Insert,Increase-Key几个实现。都很简单,模仿二叉堆即可,只不过比较兄弟节点的时候要比较 $d$ 个节点。

思考题6-3 Young矩阵,也是一个难度不大但是有趣的问题。一个 $m\times n$ 的Young矩阵,每一行数据都是从左到右排序,每一列数据都是从上到下排序。矩阵中可以包含 $\infty$ 项。比如这样一个矩阵:

$$\begin{matrix}0 & 0 & 1 & 5\\ 2 & 5 & 5 & \infty\\ 3 & \infty & \infty & \infty\end{matrix}$$

  1. 如果该矩阵 $A$ 中, $A[1,1]=\infty$ ,则矩阵的所有元素都是$\infty$ ,$A[m,n]\neq \infty$ ,则矩阵的所有元素都不是$\infty$。这几乎是显然的。
  2. Young矩阵和二叉堆很类似,可以实现Extract-Min算法和Insert算法。
    Extract-Min算法:取出一个元素 $A[i,j]$ ,然后比较 $A[i+1,j]$ 和 $A[i,j+1]$ ,选取小的一个填充到 $A[i,j]$ 中,比如 $A[i+1,j]$ 。由于 $A[i+1,j]\geq A[i,j]$,$A[i,j]\geq A[i-1,j]$,$A[i,j]\geq A[i,j-1]$ ,所以新填入的元素满足 $A_{new}[i,j]\geq A[i-1,j],A_{new}[i,j]\geq A[i,j-1]$ 。又因为 $A[i+1,j]\leq A[i,j+1]$ (之前比较过), $A[i+1,j]\leq A[i+2,j]$,后者即将成为 $A[i+1,j]$ ,所以满足 $A_{new}[i,j]\leq A[i,j+1],A_{new}[i,j]\leq A_{new}[i+1,j]$ ,四个方向都满足了循环不变式,再去对 $A[i+1,j]$ 执行这一套直到执行到遇到 $\infty$ 为止。从 $A[1,1]$ 开始执行就提取出了最小的元素。
    Insert算法类似,只不过从 $A[m,n]$ 插入,遇到依次比较左边和上方的数,将较大的一个“挤”下来,同样可以证明循环不变式,跟Extract-Min基本一样。
  3. 利用 $n\times n$ 的Young矩阵进行排序的代价为 $O(n^{3})$ 。获取堆顶元素的代价为 $O(2n)$ ,共有 $n^{2}$ 个元素,代价为 $O(n^{3})$ 。注意这里实际上排了 $n^{2}$ 个元素,实际上排 $n$ 个元素的代价是 $O(n\sqrt{n})$ 。
  4. 在运行时间 $O(m+n)$ 内确定一个给定的数是否存在于矩阵中。从矩阵左下角开始,如果给定的数大就向右,否则向上。
posted @ 2012-12-31 08:55 一叶斋主人 阅读(...) 评论(...) 编辑 收藏