obguy的博客

算法导论第三版 课后习题 4.2-7直接计算ac-bd和ad+bc需要计算乘法四次，故若想仅使用三次乘法就完成该计算，必须利用之前的计算结果： 1、S1S_1 = ac 2、S2S_2 = bd 3、S3S_3 = (a + b)(c + d) 则，可以计算得结果： 1、ac - bd = S1S_1 - S2S_2 2、ad + bc = S3S_3 - S1S_1 - S2S_2

5.3-1在进入循环前，先将在整个数组中随机选择一个数至于A[1]A[1]即可：PERMUTE-IN-PLACE(A)1 n=A.length2 swap A[1] with A[RANDOM(1,n)]3 for i=2 to n4 swap A[i] with A[RANDOM(i,n)]第二步其概率为1n\frac{1}{n}，后面一样5.3-2不能。虽然这个算法确实不会

DAG-SHORTEST-PATHS(G,w,s)1 topologically sort the verteces of G2 INITIALIZE-SINGLE-SOURCE(G,s)3 for each vertex u, taken in topologically sorted order4 for each vertex v belong to G.Adj[u]5

DIJKSTRA(G,w,s)1 INITIALIZE-SINGLE-SOURCE(G,s)2 S = emptyset3 Q = G.V4 while Q != emptyset5 u = EXTRACT-MIN(Q)6 S = S.add(u)7 for each vertex v belong to G.Adj[u]8 RELAX(u, v, w)java

5.4-1我的生日是一年中已经固定的一天，我们假设当有kk个人时，有人和我生日相同的概率为1/21/2，那么这kk个人中每一个人生日和我的不相同（即生日不在固定的某一天）的概率都为1−1/3651-1/365，而且每个人生日在哪一天相互独立，故没有人和我生日在同一天的概率为Pr=(1−1365)kPr=(1-\frac{1}{365})^k 那么能让某人生日和我相同的概率为P=1−Pr=1−(1−

5-1a.设AiA_i为第ii次计数时，计数器加一的事件，即 Ai={10第i次计数时，计数器加1第i次计数时计数器保持不变A_i=\begin{cases}{1}&\text{第$i$次计数时，计数器加1} \\{0}&\text{第$i$次计数时计数器保持不变}\end{cases} 显然P(Ai=1)=1(ni+1−ni)P(A_i=1)=\frac{1}{(n_{i+1}-n_i)}

6.1-1最多的情况是高度为hh的完全二叉树，元素一共有Nmax=∑i=0h2i=2h+1−1N_{max}=\sum_{i=0}^h2^i=2^{h+1}-1 最少的情况是高度为0的这一层的叶子只有一个，元素一共有Nmin=∑i=0h−12i+1=2hN_{min}=\sum_{i=0}^{h-1}2^i+1=2^h6.1-2由题6.1-1可知，高度为⌊lgn⌋\lfloor lgn\rfloo

6.2-1(a)初始状态，在结点i=3i=3处，A[3]A[3]违背了最大堆性质，因为它的值小于他的左孩子，所以将A[3]和A[6]A[3]和A[6]互换一下，得到新的序列为A′=<27,17,10,16,13,3,1,5,7,12,4,8,9,0>A^{'}=<27,17,10,16,13,3,1,5,7,12,4,8,9,0> (b)递归调用MAX-HEAPIFY(A,6)，此时i=6,A[6

6.3-1(a) A.length=9A.length=9，故从i=⌊A.length/2⌋=4i=\lfloor A.length/2\rfloor=4开始调用MAX-HEAPIFY(A,i)，A[4]<A[9]<A[8]A[4]\lt A[9]\lt A[8]，故交换A[4]和A[8]A[4]和A[8]得到新的序列A1={5,3,17,22,84,19,6,10,9}A_1=\{5,3,17,2

6.4-1(a) 首先调用BUILD-MAX-HEAP(A)得到最大堆A1={25,13,20,8,7,13,2,5,4}A_1=\{25,13,20,8,7,13,2,5,4\} (b) 然后将A[1]和A[9]A[1]和A[9]交换得到A2={4,13,20,8,7,17,2,5,25}A_2=\{4,13,20,8,7,17,2,5,25\}，然后调用MAX-HEAPIFY(A,1)，此时A

public class Priority_Queue { private static int heap_size = 0; public static int Parent(int i){ return (i-1)/2; } public static void Max_Heapify(double[] A, int i){ int l

6.5-1(a) 首先直接提取max=A[1]=15max = A[1] = 15； (b) 然后令A[1]=A[heap_size]=1A[1]=A[heap\_size]=1，让heap_size=heap_size−1heap\_size=heap\_size-1，此时堆A为A={1,13,9,5,12,8,7,4,0,6,2}A=\{1,13,9,5,12,8,7,4,0,6,2\}；

6-1a.不一样。例如习题6.3-1中的数组A，如果采用BUILD-MAX-HEAP算法得到的最大堆为A1={84,22,19,10,3,17,6,5,9}A_1=\{84,22,19,10,3,17,6,5,9\}；但如果采用插入方法建堆，得到的最大堆是A2={84,22,19,17,10,5,6,3,9}A_2=\{84,22,19,17,10,5,6,3,9\}b.在最坏的情况下，A应该是一个

7.1-1（a） 首先x=A[12]=11,i=0,j=1x=A[12]=11,i=0,j=1，此时我们比较A[1]和x可知A[1]>xA[1]和x可知A[1]\gt x，故令j=j+1=2j=j+1=2； （b） 然后比较A[2]和x可知A[2]>xA[2]和x可知A[2]\gt x，故继续令j=j+1=3j=j+1=3； （c） 比较A[3]和x可知A[3]<xA[3]和x可知A[3]\lt

7.2-1令Θ(n)=cn\Theta(n)=cn，带入递归式可得： T(n)=T(n−1)+Θ(n)=T(n−1)+cn=c∑i=1ni=c⋅n(n+1)2=Θ(n2)T(n)=T(n-1)+\Theta(n)=T(n-1)+cn=c\sum_{i=1}^ni=c\cdot \frac{n(n+1)}{2}=\Theta(n^2)7.2-2当数组A的所有元素都具有相同值时，此时出现最坏情况，每次

7.4-1我们可以猜测T(n)≥cn2T(n)\ge cn^2： T(n)≥max0≤q≤n−1[cq2+c(n−q−1)2]+Θ(n)=max0≤q≤n−1[cq2+c(n−q−1)2]+Θ(n)=cn2−2cn+c+Θ(n)≥cn2−2cn+Θ(n)≥cn2\begin{align}T(n)&\ge \max_{0\le q\le n-1}[cq^2+ c(n-q-1)^2]+\Theta(

5.1-1由于总能决定那个应聘者最佳，故两两之间都定义了关系，所以是一个全关系 其次由于1、每个应聘者都比自己好或者更好，所以满足自反性；2、如果应聘者A比B好或更好，B又比A好或更好，而且因为总能决定哪个应聘者最佳，故显然没有两个同样好的不同应聘者，那么显然A就是B，所以满足反对称性；3、如果应聘者A比B好，B又比C好，那么显然A就比C好，所以满足传递性。因此该关系就是一个偏序关系。 由于该关

BELLMAN-FORD最短路径算法：BELLMAN-FORD(G,w,s)1 INITIALIZE-SINGLE-SOURCE(G,s)2 for i = 1 to |G.V| - 13 for each edge(u,v) belong to G.E4 RELAX(u,v,w)5 for each edge(u,v) belong to G.E6 if v.d >

4.4-1画出递归树可知：递归树深度为log2nlog_2 n，第ii层共有3i3^i个节点，每个节点的代价为(12)in(\frac{1}{2})^i n，故第ii层总代价为(32)in(\frac{3}{2})^i n， 递归树叶子在第log2nlog_2 n层，则一共有3log2n3^{log_2 n}片叶子， 设叶子代价为Θ(1)\Theta(1),则叶子总代价为 Θ(3log2n)=

4.5-1af(n)=1,nlogba=nlog42=n12f(n)=1,n^{log_b a} = n^{log_4 2} = n^{\frac{1}{2}} 当0<ϵ≤12时，f(n)=O(nlogba−ϵ)0\lt \epsilon\le \frac{1}{2}时，f(n)=O(n^{log_b a - \epsilon}) 故T(n)=O(nlogba)=O(n−−√)T(n)=O(n^

4-1a.T(n)=Θ(n4)T(n)=\Theta(n^4) 先用代入法证明T(n)≤cn4T(n)\le cn^4: T(n)≤2⋅c(n2)4+n4=(c8+1)n4\begin{align}T(n)&\le 2\cdot c(\frac{n}{2})^4+n^4\\&=(\frac{c}{8}+1)n^4\end{align} 故T(n)=O(n4)T(n)=O(n^4) 再用

5.2-1正好雇佣一次说明第一次雇佣的就是所有应聘者中最好的，所以概率为1n\frac{1}{n} 正好雇佣nn次说明所有应聘者按优秀从低到高依次出现，第一位是最差的，概率为1n\frac{1}{n},第二位其次，概率为1n−1\frac{1}{n-1},所以整体概率为1n!\frac{1}{n!}5.2-2正好雇佣两次，说明第一个应聘者不是最好的，概率为n−1n\frac{n-1}{n}，第二个

4.3-1假设对∀m≤n0,∃c≥0,\forall m\le n_0,\exists c\ge0,使得： T(m)≤cm2\begin{align} T(m) \le cm^2 \end{align} 则有： T(n−1)≤c(n−1)2\begin{align} T(n-1) \le c(n-1)^2 \end{align} 带入迭代式可得： T(n)≤c(n−1)2+n=cn2−2c

7-1a.（1） 初始时，x=A[1]=13,i=0,j=13x=A[1]=13, i = 0, j = 13; （2） 令j=j−1=12，A[12]>xj=j-1=12，A[12]\gt x，故继续令j=j−1=11,A[11]<xj=j-1=11,A[11]\lt x；令i=i+1=1,A[1]≥xi=i+1=1,A[1]\ge x。交换A[1]和A[11]得到A1={6,19,9,5,12

8.1-1最小深度为n−1n-1，就像插入排序最好的情况一样，对已经排序好的序列排列的情况。8.1-2∑k=1nlgk≤∑k=1nlgn=nlgn\begin{align}\sum_{k=1}^nlgk\le \sum_{k=1}^nlgn=nlgn\end{align} 所以，lg(n!)=O(nlgn)lg(n!)=O(nlgn). ∑k=1nlgk=∑k=1n/2lgk+∑k=n/2+

8.2-1（a)首先通过第4到第5行，数组C={2,2,2,2,1,0,2}C=\{2,2,2,2,1,0,2\}，然后经过第7行到第8行，数组C={2,4,6,8,9,9,11}C=\{2,4,6,8,9,9,11\}。 （b) 然后根据第10行到第12行，我们有首先B[C[A[11]]]=B[6]=2B[C[A[11]]]=B[6]=2，此时C={2,2,2,2,8,9,9,10}C=\{2,

8.3-1(1) 首先按最低位字母进行排序得到SEA,TEA,MOB,TAB,DOG,RUG,DIG,BIG,BAR,EAR,COW,ROW,NOW,BOX,FOX； (2) 然后对次低位字母进行稳定排序得到TAG,BAR,EAR,SER,TEA,DIG,BIG,MOB,DOG,COW,ROW,NOW,BOX,FOX,RUG; (3) 最后对首位字母进行稳定排序得到BAR,BIG,BOX,COW

插入排序INSERTION-SORT(A)1 for j=2 to A.length2 key=A[j]3 // insert A[j] into the sorted sequence A[1...j-1].4 i=j-15 while i>0 and A[i]>key6 A[i+1]=A[i]7 i=i-18 A[i+1]=key最坏运行时间

8.4-1(1) 首先n=A.length=10n=A.length=10，然后让B[0...9]B[0...9]分别为一个空链表； (2) 遍历数组AA，将数组AA中每一个元素A[i]A[i]都加到链表B[⌊nA[i]⌋]B[\lfloor nA[i] \rfloor]中，得到B[0]=∅B[0]=\emptyset,B[1]={0.13,0.16}B[1]=\{0.13,0.16\},B[2]

8-1a.因为对于每一种输入，不可能能够到达同一片叶子，所以一共有n!n!片子是可以到达的。其次因为输入完全随机，每种输入概率相等且到叶子结点的路径是固定的，这n!n!个叶子结点的概率也是相等的，为1n!\frac{1}{n!}。b.一共有kk个叶子节点，那么一定会有kk条从叶子节点到根结点的路径，所有的路径要么会经过TT的左孩子节点，要么经过它的右孩子节点，即所有kk条路径都会从TT的左孩子节点或

下面算法中，假定输入图G=(V,E)是以邻接链表所标示的。该算法为途中每一个节点赋予了一些额外属性：我们将每个节点u的颜色存放在属性u.color里（白色表示没有发现过的节点，灰色表示已经发现但其邻接节点没有被全部发现，黑色表示已经被发现且邻接节点全部被发现），将u的前驱结点存放在属性u.pi里。如果u没有前驱节点（例如，如果u=s或者节点u尚未被发现），则u.pi = NIL。属性u.d记录的是广

DFS(G)1 for each vertex u belong to G.V2 u.color = WHITE3 u.pi = NIL4 time = 05 for each vertex u belong to G.V6 if u.color == WHITE7 DFS-VISIT(G,u)DFS-VISIT(G,u)1 time = time + 1

TOPOLOGICAL-SORT(G)1 call DFS(G) to compute finishing times v.f for each vertex v2 as each vertex is finished, insert it onto the front of a linked list3 return the linked list of vertecesjava代码如下：

7.3-1本来将快速排序随机化就是为了让其最坏情况的出现随机化，此时我们关心的就是该算法的期望运行时间。7.3-2在最坏的情况下，每次RANDOM取得的都是子数组中最大或最小的元素的下标，每次划分都会出现0和n−10和n-1的两个子数组，所以每层节点都只会调用一次RANDOM，一共会调用Θ(lgn)\Theta(lgn)次RANDOM； 在最好的情况下，每次RANDOM取得的都刚好是子数组中大小居