USC算法导论作业2
算法导论02
Algorithm : Design & Analysis [2]
In the last class…
Goal of the Course Algorithm: the Concept Algorithm Analysis: the Contents Average and Worst-Case Analysis Lower Bounds and the Complexity of Problems
Searching a Sequence
For a given K, there are two possibilities
K in E (say, with probability q), then K may be any one of E[i] (say, with equal probability, that is 1/n) K not in E (with probability 1-q), then K may be located in any one of gap(i) (say, with equal probability, that is 1/(n+1))
Input:
an array E containing n entries of numeric type sorted in non-decreasing order a value K
Output:
index for which K=E[index], if K is in E, or, -1, if K is not in E
Asymptotic Behavior
Asymptotic growth rate The Sets Ο, Ω and Θ Complexity Class An Example: Maximum Subsequence Sum
算法导论 答案 (2)
算法导论答案算法导论概述《算法导论》是一本经典的计算机科学教材，由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein合著。
这本书详细介绍了算法的设计、分析和实现，并涵盖了算法导论领域的许多重要概念和技术。
本文将为你提供一些关于《算法导论》中一些常见问题的答案。
1. 什么是算法？算法是一系列明确定义的步骤，用于解决特定问题或完成特定任务。
它可以是一个计算过程、一个程序或一个有限的操作序列。
算法通常用于计算和数据处理领域，是计算机科学的核心概念。
2. 为什么学习算法很重要？学习算法的重要性体现在以下几个方面：•提高问题解决能力：算法是解决问题的有效工具。
学习算法可以帮助我们思考和理解问题，并设计出相应的解决方案。
•优化计算性能：算法的设计和分析可以帮助我们提高计算的效率和性能。
合适的算法可以在短时间内处理大规模数据集和复杂计算任务。
•促进技术创新：算法是许多技术和应用的基石，包括人工智能、机器学习、数据挖掘等。
学习算法可以为我们打开更多的研究和创新机会。
3. 《算法导论》提供了哪些内容？《算法导论》这本书详细介绍了算法的基本概念和设计技巧，并提供了许多典型算法的实现和分析。
以下是该书的一些主要内容：•算法分析：对算法进行时间复杂度和空间复杂度的理论分析，帮助我们评估算法的效率和性能。
•排序和查找算法：介绍了各种排序算法（如插入排序、归并排序、快速排序）和查找算法（如二分查找、哈希表）。
•图算法：讨论了图的表示方法和图搜索算法（如深度优先搜索、广度优先搜索）以及最短路径算法（如Dijkstra算法）等。
•动态规划和贪心算法：介绍了动态规划和贪心算法的原理和应用，用于解决具有最优子结构性质的问题。
•分治算法和递归思想：讲解了分治算法的基本原理，并提供了许多使用递归思想解决问题的例子。
•NP完全问题：探讨了NP完全问题的性质和求解方法，引导了读者进入计算复杂性理论的领域。
USC算法导论作业2
Problem 1 (4.3-2): The recurrence T (n) = 7T (n/2) + n2 describes the running time of an algorithm A. A competing algorithm A has a running time of T (n) = aT (n/4) + n2 . What is the largest integer value for a such that A is asymptotically faster than A? Solution 1: By the master theorem, the worst-case asymptotic complexity of A is Θ(nlg 7 ) ≈ Θ(n2.80735 ), and the worst-case asymptotic complexity of A is Θ(nlog4 a ), if a > 16. For A to be asymptotically faster than A, log4 a < lg 7 = log4 49. Therefore, the largest integer value for a such that A is asymptotically faster than A is 48. Problem 2 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. a. T (n) = 2T (n/2) + n3 . b. T (n) = 16T (n/4) + n2 . c. T (n) = 7T (n/3) + n2 . d. T (n) = 7T (n/2) + n2 . √ e. T (n) = 2T (n/4) + n. f. T (n) = 3T (n/2) + n lg n. √ g. T (n) = 4T (n/2) + n2 n. h. T (n) = T (9n/10) + n. Solution 2: Use the master method to solve these recurrences. a. Case 3 of master theorem. T (n) = Θ(n3 ). b. Case 2 of master theorem. T (n) = Θ(n2 lg n). c. Case 3 of master theorem. T (n) = Θ(n2 ). d. Case 1 of master theorem. T (n) = Θ(nlg 7 ). √ e. Case 2 of master theorem. T (n) = Θ( n lg n). f. Case 1 of master theorem. T (n) = Θ(nlg 3 ). √ g. Case 3 of master theorem. T (n) = Θ(n2 n). h. Case 3 of master theorem. T (n) = Θ(n). Problem 3 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. You may assume that T (1) is a constant. a. T (n) = T (n − 1) + n.
《算法导论》习题答案
Chapter2 Getting Start2.1 Insertion sort2.1.2 将Insertion-Sort 重写为按非递减顺序排序2.1.3 计算两个n 位的二进制数组之和2.2 Analyzing algorithms2.2.1将函数32/10001001003n n n --+用符号Θ表示2.2.2写出选择排序算法selection-sort当前n-1个元素排好序后，第n 个元素已经是最大的元素了.最好时间和最坏时间均为2()n Θ2.3 Designing algorithms2.3.3 计算递归方程的解22()2(/2)2,1k if n T n T n n if n for k =⎧=⎨+ = >⎩ （1） 当1k =时，2n =，显然有()lg T n n n =（2） 假设当k i =时公式成立，即()lg 2lg22i i i T n n n i ===⋅，则当1k i =+，即12i n +=时，111111()(2)2(2)222(1)22lg(2)lg i i i i i i i i T n T T i i n n ++++++==+=⋅+=+== ()lg T n n n ∴ =2.3.4 给出insertion sort 的递归版本的递归式(1)1()(1)()1if n T n T n n if n Θ =⎧=⎨-+Θ >⎩2.3-6 使用二分查找来替代insertion-sort 中while 循环内的线性扫描，是否可以将算法的时间提高到(lg )n n Θ？虽然用二分查找法可以将查找正确位置的时间复杂度降下来，但是移位操作的复杂度并没有减少，所以最坏情况下该算法的时间复杂度依然是2()n Θ2.3-7 给出一个算法，使得其能在(lg )n n Θ的时间内找出在一个n 元素的整数数组内，是否存在两个元素之和为x首先利用快速排序将数组排序，时间(lg )n n Θ，然后再进行查找： Search(A,n,x)QuickSort(A,n);i←1; j←n;while A[i]+A[j]≠x and i<jif A[i]+A[j]<xi←i+1elsej←j -1if A[i]+A[j]=xreturn trueelsereturn false时间复杂度为)(n Θ。
《算法导论(第二版)》(中文版)课后答案
5
《算法导论（第二版） 》参考答案 do z←y 调用之前保存结果 y←INTERVAL-SEARCH-SUBTREE(y, i) 如果循环是由于y没有左子树，那我们返回y 否则我们返回z，这时意味着没有在z的左子树找到重叠区间 7 if y≠ nil[T] and i overlap int[y] 8 then return y 9 else return z 5 6 15.1-5 由 FASTEST-WAY 算法知：
15
lg n
2 lg n1 1 2cn 2 cn (n 2 ) 2 1
4.3-1 a) n2 b) n2lgn c) n3 4.3-4
2
《算法导论（第二版） 》参考答案 n2lg2n 7.1-2 (1)使用 P146 的 PARTION 函数可以得到 q=r 注意每循环一次 i 加 1，i 的初始值为 p 1 ，循环总共运行 (r 1) p 1次，最 终返回的 i 1 p 1 (r 1) p 1 1 r (2)由题目要求 q=(p+r)/2 可知，PARTITION 函数中的 i，j 变量应该在循环中同 时变化。 Partition(A, p, r) x = A[p]; i = p - 1; j = r + 1; while (TRUE) repeat j--; until A[j] <= x; repeat i++; until A[i] >= x; if (i < j) Swap(A, i, j); else return j; 7.3-2 （1）由 QuickSort 算法最坏情况分析得知：n 个元素每次都划 n-1 和 1 个，因 为是 p<r 的时候才调用，所以为Θ （n） （2）最好情况是每次都在最中间的位置分，所以递推式是： N(n)= 1+ 2*N(n/2) 不难得到：N(n) =Θ （n） 7.4-2 T(n)=2*T(n/2)+ Θ （n） 可以得到 T(n) =Θ （n lgn） 由 P46 Theorem3.1 可得：Ω (n lgn)
中科大算法导论第一,二次和第四次作业答案
2.2-3 再次考虑线性查找问题 （见练习2.1-3）。在平均情况 下，需要检查输入序列中的多 少个元素？假定待查找的元素 是数组中任何一个元素的可能 性是相等的。在最坏情况下有 怎样呢？用Θ形式表示的话，线 性查找的平均情况和最坏情况 运行时间怎样？对你的答案加 以说明。 • 线性查找问题 • 输入：一列数A=<a1,a2,…,an>和一 个值v。 • 输出：下标i，使得v=A[i]，或者当 v不在A中出现时为NIL。 • 平均情况下需要查找 (1+2+…+n)/n=(n+1)/2 • 最坏情况下即最后一个元素为待 查找元素，需要查找n个。 • 故平均情况和最坏情况的运行时 间都为Θ(n)。
• 2.3-2改写MERGE过程，使之不使 用哨兵元素，而是在一旦数组L或R 中的所有元素都被复制回数组A后， 就立即停止，再将另一个数组中 余下的元素复制回数组A中。 • MERGE(A,p,q,r) 1. n1←q-p+1 2. n2 ←r-q 3. create arrays L[1..n1] and R[1..n2] 4. for i ←1 to n1 5. do L*i+ ←A*p+i-1] 6. for j ←1 to n2 7. do R*j+ ←A*q+j+ 8. i ←1 9. j ←1
10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21.
k ←p while((i<=n1) and (j<=n2)) do if L[i]<=R[j] do A[k]=L[i] i++ else do A[k]=R[j] j++ k++ while(i<=n1) do A[k++]=L[i++] while(j<=n2) do A[k++]=R[j++]
USC算法导论作业3
CSCI303Homework3Problem1(9-1):Given a set A of n numbers,we wish tofind the k largest in sorted order using a comparison-based algorithm.Find the algorithm that implements each of the following methods with the best asymptotic worst-case running time,and analyze the running time of the algorithms in terms of n and k.a.Sort the numbers,and list the k largest.b.Build a max-priority queue from the numbers,and call Extract-Max k times.e an order-statistic algorithm tofind the i th largest number,partition around that num-ber,and sort the k largest numbers.Solution1:a.Merge-Sort(A,1,n)return A[n−k...k]This algorithm takes only as long as it takes to Merge-Sort a list of n numbers,so its running time isΘ(n lg n).b.Build-Max-Heap(A)for i←1to kB[i]←Heap-Extract-Max(A)return BThis algorithmfirst calls Build-Max-Heap on A,which has worst-case asymptotic com-plexity O(n).Then it calls Heap-Extract-Max k times,each of which has worst-case asymptotic complexity O(lg n).So the worst-case asymptotic complexity for this algorithm is O(n+k lg n).c.i←Select(A,k)A[n]↔A[i]Partition(A)Merge-Sort(A,n−k,n)return A[n−k...k]This algorithmfirst calls Select,which has worst-case asymptotic complexity O(n), then calls Partition,which also has worst-case asymptotic complexity O(n),then calls Merge-Sort to sort just the last k elements,which has worst-case asymptotic complexity O(k lg k).So the worst-case asymptotic complexity for this algorithm is O(n+k lg k).Problem2(9.3-5):Suppose that you have a“black-box”worst-case linear-time median subroutine.Give a simple, linear-time algorithm that solves the selection problem for an arbitrary order statistic.Solution2:Simple-Select(A,p,r,i)if p=rreturn A[p]A[r]↔A[Index-Of-Median(A,p,r)] Partition(A,p,r)k← r−p+12if i=kreturn A[k]else if i<kreturn Simple-Select(A,1,k−1,i)elsereturn Simple-Select(A,k+1,r,i−k)Problem3(9.3-8):Let X[1,...,n]and Y[1,...,n]be two arrays,each containing n numbers already in sorted order. Give an O(lg n)-time algorithm tofind the median of all2n elements in arrays X and Y. Solution3:Two-List-Median(X,p,q,Y,s,t)mx←Index-Of-Median(X,p,q)my←Index-Of-Median(Y,s,t)X[mx]↔X[q]Y[my]↔Y[t]Partition(X,p,q)Partition(Y,s,t)if X[mx]=Y[my]return X[mx]else if X[mx]>Y[my]return Two-List-Median(X,p,mx−1,Y,my+1,t)elsereturn Two-List-Median(X,mx+1,q,Y,s,my−1)Problem4(8.1-1):What is the smallest possible depth of a leaf in a decision tree for a comparison sort?Solution4:Given an array A that contains n elements,the smallest possible depth of a leaf in a decision tree to sort A using a comparison-type sort is n−1.To verify that A is in sorted order takes n−1 comparisons,and if fewer comparisons are used then at least one element was not compared to any of the others,so that element might not be in the correct position.Problem 5(Derived from 8.1-4):You are given a sequence of n elements to sort and a number k such that k divides n .The input sequence consists of n/k subsequences,each containing k elements.The elements in a given subsequence are all smaller than the elements in the succeeding subsequence and larger than the elements in the preceding subsequence.Thus,all that is needed to sort the whole sequence of length n is to sort the k elements in each of the n/k subsequences.Show an Ω(n lg k )lower bound on the number of comparisons needed to solve this varient of the sorting problem using a comparison-type sorting algorithm.(Hint:It is not rigorous to simply combine the lower bounds for the individual subsequences.)Solution 5:We will construct a decision tree for this varient of the sorting problem and show that it has height at least n lg k .Each leaf of the decision tree corresponds to a permutation of the original sequence.How many permutations are there?Each subsequence has k !permutations,and there are n/k subsequences,so there are (k !)n/k permutations of the whole sequence.Thus the decision tree has (k !)n/k leaves.A binary tree with (k !)n/k leaves has height at least lg (k !)n/k .lg (k !)n/k =n/k lg(k !)=Θ(n/k ·k lg k )=Θ(n lg k )Therefore the lower bound on the number of comparisons needed to solve this varient of the sorting problem using a comparison-type sorting algorithm is Ω(n lg k ).。
USC算法导论作业
CSCI 303Homework 1Problem 1(2.1-1):Using Figure 2.2as a model,illustrate the operation of Insertion-Sort on the array A = 31,41,59,26,41,58 .Solution 1:265841594131Problem 2(2.2-1):Express the function n 3/1000−100n 2−100n +3in terms of Θ-notation.Solution 2:n 3/1000−100n 2−100n +3=Θ(n 3)Problem 3(Derived from 2.2-2):Consider sorting n numbers stored in array A by first finding the smallest element of A and exchanging it with the element in A [1].Then find the second smallest element of A ,and exchange it with A [2].Continue in this manner for the first n −1elements of A .Write pseudocode for this algorithm,which is known as Selection-Sort .Give the worst-case running times of selection sort in Θ-notation.Solution 3:Selection-Sort (A )for i ←1to length [A ]do min-value ←A [i ]min-index =ifor j =i +1to length [A ]do if A [j ]≤min-valuemin-value =A [j ]min-index =jA [i ]↔A [min-index ]The worst-case running time of Selection-Sort is Θ(n 2).Using Figure2.4as a model,illustrate the operation of merge sort on the array A= 3,41,52,26,38,57,9,49 . Solution4:Sorted SequenceInitial SequenceProblem5(Derived from1.2-2):Suppose we are comparing two sorting algorithms.Suppose that for all inputs of size n,thefirst algorithm runs in8n2seconds,while the second algorithm runs in64n lg n seconds.For whichvalues of n does thefirst algorithm beat the second algorithm?Solution5:Thefirst algorithm beats the second algorithm if8n2<64n lg n.For this to happen,n<8lg n.This is true for2≤n≤43.Problem6(1.2-3):What is the smallest value of n such that an algorithm whose running time is100n2runs fasterthan an algorithm whose running time is2n?Solution6:n=15Assume that a new Intel processor can execute1015operations per second.You have two algorithms that test whether a number is prime or not.Thefirst algorithm uses100n2operations for a number with n decimal digits.The second uses2n operations for a number with n decimal ing thefirst algorithm,how many seconds would the Intel processor take to determine whether a1000 decimal digit number is prime?Using the second algorithm,how many seconds would the Intel processor take to determine whether a1000decimal digit number is prime?Solution7:Thefirst algorithm would take10−7seconds(100nanoseconds).The second algorithm would take 10286seconds.For comparison,the universe is about4.33×1017seconds old,so it would take approximately2.5×10268times the age of the universe to solve the problem using the second algorithm.Problem8(1-1Comparison of running times):For each function f(n)and time t in the following table,determine the largest size n of a prob-lem that can be solved in time t,assuming that the algorithm to solve the problem takes f(n) microseconds.1second1minute1hour1day1month1year1centurylg n√nnn lg nn2n32nn!Solution8:1second1minute1hour1day1month1year1centurylg n210626×10723.6×10928.64×101022.63×101223.16×101323.16×1015√n10123.6×10151.3×10197.46×10216.92×10249.96×10249.96×1030 n1066×1073.6×1098.64×10102.63×10123.16×10133.16×1015 n lg n6274628014171.33×1082.76×1097.29×10107.98×10116.87×1013 n210007745600002939381621643561753856175382 n3100391153244201380231600146677 2n19253136414451n!9111213151617Problem9(Derived from3.1-2):Show that for all numbers a and b,(n+a)b=Θ(n b). Solution9:(n+a)b=bk=0bkn b−k a k(The binomial formula)=n b+bn b−1k+···+bnk b−1+k b=Θ(n b)Problem10(3.1-4):Is2n+1=O(2n)?Is22n=O(2n)?Solution10:2n+1=2×2n so2n+1=O(2n)22n=2n×2n so22n=O(2n)Problem11(Not in book):In the table below,write O if f(n)=O(g(n)),Ωif f(n)=Ω(g(n)),andΘif f(n)=Θ(g(n)).g(n)↓f(n)→5n+33.14×1088n2lg4n+n32n5n3+4n2lg n+3n12n+lg8n 5n+33.14×1088n2lg4n+n32n5n3+4n2lg n+3n12n+lg8nSolution11:g(n)↓f(n)→5n+33.14×1088n2lg4n+n32n5n3+4n2lg n+3n12n+lg8n 5n+3ΘOΩΩΩΘ3.14×108ΩΘΩΩΩΩ8n2lg4n+n3O OΘΩΩO 2n O O OΘO O5n3+4n2lg n+3n O O OΩΘO 12n+lg8nΘOΩΩΩΘ。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
b. T (n) = T (n − 1) + 1/n. c. T (n) = T (n − 1) + lg n. d. T (n) = 2T (n/2) + n lg n. e. T (n) = 5T (n/5) + n/ lg n. Solution 3: For these recurrences, the master theorem does not apply. a. Assume T (1) = 1, then unroll the recurrence: T (n) = T (n − 1) + n = n + (n − 1) + (n − 2) + · · · + 2 + T (1)
n
T (n) = ≥
1
k=1 n+1
1 k
n
T (n) =
k=1
1 k
n
1 dx x
=1+
k=2 n
1 k 1 dx x
= ln(n + 1) ≥ ln n = Ω(ln n)
≤1+
1
= 1 + ln n = O(ln n)
T (n) = Θ(ln n) = Θ(lg n)
2
c. Assume T (1) = 1, then unroll the recurrence: T (n) = T (n − 1) + lg n = lg n + lg(n − 1) + lg(n − 2) + · · · + lg 2 + lg 1
n 5
+ n/ lg n
n 25 n +n 5 / lg 5 + n/ lg n n n 25 / lg 25 n +n 5 / lg 5 + n/ lg n
= 5 5T
= 5 5 · · · 5 (5 (5T (1) + 5/ lg 5) + 25/ lg 25) + · · · +
n n = n(c + 1/ lg 5 + 1/ lg 52 + · · · + 1/ lg 5 2 + 1/ lg 5 + 1/ lg n log5 n 1 = n c + lg 5k k=1
CSCI 303 Homework 2
Problem 1 (4.3-2): The recurrence T (n) = 7T (n/2) + n2 describes the running time of an algorithm A. A competing algorithm A has a running time of T (n) = aT (n/4) + n2 . What is the largest integer value for a such that A is asymptotically faster than A? Solution 1: By the master theorem, the worst-case asymptotic complexity of A is Θ(nlg 7 ) ≈ Θ(n2.80735 ), and the worst-case asymptotic complexity of A is Θ(nlog4 a ), if a > 16. For A to be asymptotically faster than A, log4 a < lg 7 = log4 49. Therefore, the largest integer value for a such that A is asymptotically faster than A is 48. Problem 2 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. a. T (n) = 2T (n/2) + n3 . b. T (n) = 16T (n/4) + n2 . c. T (n) = 7T (n/3) + n2 . d. T (n) = 7T (n/2) + n2 . √ e. T (n) = 2T (n/4) + n. f. T (n) = 3T (n/2) + n lg n. √ g. T (n) = 4T (n/2) + n2 n. h. T (n) = T (9n/10) + n. Solution 2: Use the master method to solve these recurrences. a. Case 3 of master theorem. T (n) = Θ(n3 ). b. Case 2 of master theorem. T (n) = Θ(n2 lg n). c. Case 3 of master theorem. T (n) = Θ(n2 ). d. Case 1 of master theorem. T (n) = Θ(nlg 7 ). √ e. Case 2 of master theorem. T (n) = Θ( n lg n). f. Case 1 of master theorem. T (n) = Θ(nlg 3 ). √ g. Case 3 of master theorem. T (n) = Θ(n2 n). h. Case 3 of master theorem. T (n) = Θ(n). Problem 3 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. You may assume that T (1) is a constant. a. T (n) = T (n − 1) + n.
n
=
k=1
lg k
n
= lg
k=1
k
= lg(n!) = Θ(n lg n) By Stirling’s approximation (see section 3.2 in the book, equation 3.18). d. Assume n = 2m for some m and T (1) = c, then unroll the recurrence: T (n) = 2T
3
Given a list of numbers A and a target number t, the algorithm returns 1 if t it is in the list, and 0 otherwise. Unsorted-Search(A, t, p, q ) if q − p < 1 if A[p] = t return 1 else return 0 q if Unsorted-Search(A, t, p, p+ 2 ) = 1 return 1 p+q if Unsorted-Search(A, t, 2 + 1, q ) = 1 return 1 return 0 Analyze this algorithm with respect to worst-case asymptotic complexity, and give the worst-case running time in terms of Θ notation. How does this algorithm compare to the naive algorithm that simply iterates through the list to look for the target? Solution 4: The algorithm is given an array of n numbers and a target number. The first two lines take constant time, call it c. The next two lines recursively call Unsorted-Search on inputs of size n/2. Therefore, the worst-case asymptotic complexity is T (n) = 2T (n/2) + c Using case 1 of the master theorem, we see that T (n) = Θ(n). This is the same worst-case asymptotic complexity as the naive algorithm, although in practice the naive algorithm would probably run more quickly. Problem 5 (28.2-4): V. Pan has discovered a way of multiplying 68 × 68 matrices using 132,464 multiplications, a way of multiplying 70 × 70 matrices using 143,640 multiplications, and a way of multiplying 72 × 72 matrices using 155,424 multiplications. Which method yields the best asymptotic running time when used in a divide-and-conquer matrix-multiplication algorithm? How does it compare to Strassen’s algorithm? Solution 5: For each case, we write the recurrence and solve it using the master theorem: (1) (2) (3) T (n) = 132464T (n/68) + n2 T (n) = 143640T (n/70) + n2 T (n) = 155424T (n/72) + n2 ⇒ ⇒ ⇒ T (n) = Θ(nlog68 132464 ) ≈ Θ(n2.795128 ) T (n) = Θ(nlog70 143640 ) ≈ Θ(n2.795123 ) T (n) = Θ(nlog72 155424 ) ≈ Θ(n2.795147 )