1 / 118

4 Transform-and-Conquer

4 Transform-and-Conquer. Divide-and-conquer algorithms T(n) = aT (n/b) + f(n) Decrease-and-Conquer Exploiting and then establishing the relationship between a solution to a given instance of a problem and a solution to a smaller instance of the same problem.

rosariobell
Download Presentation

4 Transform-and-Conquer

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 4 Transform-and-Conquer

  2. Divide-and-conquer algorithms T(n) = aT(n/b) + f(n) • Decrease-and-Conquer • Exploiting and then establishing the relationship between • a solution to a given instance of a problem and • a solution to a smaller instance of the same problem. • Three major variations of decrease-and-conquer: • Decrease by a constant. Insertion sort, Topological sorting (DFS). T(n) = T(n - c) + f(n) • Decrease by a constant factor. Binary Search, Russian peasant multiplication, fake coin problem. T(n) = T(n/b) + f(n) • Variable size decrease. Euclid’s algorithm, the partition-based algorithm for interpolation search, and searching and insertion in a binary search tree.. review

  3. Transform-and-Conquer • Design methods based on the idea of transformation. • Two-stage procedures: • In the transformation stage, • the problem’s instance is modified to be, for one reason or another, more amenable to solution. • In the conquering stage, • it is solved.

  4. Transform-and-conquer strategy: • simpler instance • or • Problems’ another representation solution • instance or • another problem’s instance • transformation stage conquering stage

  5. Three major variations of this idea that differ by what we transform a given instance to: • instance simplification - transformation to a simpler or more convenient instance of the same problem. • representation change – transformation to a different representation of the same instance. • Problem reduction – transformation to an instance of a different problem for which an algorithm is already available.

  6. Instance Simplification: • Presorting is used to sort inputs for many algorithmic problems that become easier to solve. • Examples that illustrate instance simplification by using presorting • Checking element uniqueness in an array using Algorithm PresortElementUniqueness(A[0 .. n-1]). • T(n) = Θ(n2) goes down to T(n) = Θ(nlog n) + Θ(n). • Computing a mode using Algorithm PresortMode(A[0 .. n-1]). T(n) = Θ(n2 ) goes down to T(n) = Θ(nlog n) + Θ(n). • Searching problem for a given value v in a given array of n sortable items. • T(n) = Θ (n) goes up to T(n) = Θ(nlog n) + Θ(log n.)

  7. Representation Changes: • Gaussian elimination solves a system of linear equations by first transforming it to another system that makes finding a solution quite easy. • Balanced Search Trees, including AVL trees (transformation from an unbalanced binary tree to a binary search tree is considered to be instance simplification) is an example of the representation change technique. • Heaps and heapsort, Horner’s rule and Binary Exponentiation are considered examples of the representation change.

  8. Problem Reduction: • Examples are • Computing the Least Common Multiple, • Counting paths between two vertices in a graph, • Finding functions’ Maximization and Minimization problems, • Linear Programming (Investment and Knapsack problems). • Reduction to Graph Problems

  9. Instance Simplification: Techniques used for simplify instances • Presorting is used to sort inputs for many algorithmic problems that become easier to solve. • Some examples of sorting algorithms are as follows:

  10. Presorting • For the sake of simplicity, assume that lists are implemented as arrays. • Three elementary sorting algorithms: • Selection sort, (which is quadratic, Θ(n2), in the worst and average cases) • Bubble sort, (which is quadratic, Θ(n2), in the worst and average cases), and • Insertion sort (which is quadratic, Θ(n2), in the worst and average cases). • Mergesort (which is always in Θ(n log n)), and • Quicksort, (whose efficiency is also Θ(n log n) in the average case but is quadratic in the worst case).

  11. Are there faster sorting algorithms? • No general comparison-based sorting algorithm can have a better efficiency thannlog n in the worst case. • And the same result (nlog n) holds for average-case efficiency.

  12. Examples of Instance Simplification: Consider instance simplification - transformation to a simpler or more convenient instance of the same problem. Presorting is used to sort inputs for many algorithmic problems that become easier to solve.

  13. Example 1: Checking element uniqueness in an array • The brute-force algorithm compared pairs of the array’s elements until • either two equal elements were found • or no more pairs were left. • Its worst-case efficiency is in Θ(n2). • Alternatively, sort the array first and then check only its consecutive elements: if the array has equal elements, a pair of them just be next to each other and vice versa. Θ(n log n) + Θ(n)

  14. Algorithm PresortElementUniqueness(A[0 .. n-1]) • //Solves the element uniqueness problem by sorting the array first • //Input: An array A[0 .. n-1] of orderable elements • //Output: Returns “true” if A has no equal elements, • // “false” otherwise. • sort the array A; • i ← 0; • while i ≤ n – 2 do • { if A[ i ] = A[ i + 1] return false; //there are the same elements • i ← i +1; } • return true

  15. Analysis of efficiency of the algorithm: • The running time of this algorithm is the sum of • Time spent on sorting: • Use a good sorting algorithm, such as mergesort; sorting requires at least (nlog n) comparisons and, therefore, time efficiency for the worst-case is Θ(n log n). • Time spent on checking consecutive elements: • The later (checking consecutive elements) needs no more than (n – 1) comparisons. • …

  16. Analysis of efficiency of the algorithm: • The running time of this algorithm is the sum of • … • It is the sorting part that will determine the overall efficiency of the algorithm. • T(n) = Tsort (n) + Tscan (n) • ε Θ(nlog n) + Θ(n) • = Θ(nlog n).

  17. Example 2: Computing a mode • A mode is a value that occurs most often in a given list of numbers. • For example: • For 5, 1, 5, 7, 6, 5, 7, the mode is 5. • If several different values occur most often, any of them can be considered a mode.) • The brute-force approach to computing a mode would • scan the list and • compute the frequencies of all its distinct values, • then find the value with the largest frequency.

  18. To implement this idea, • Store the values already encountered, along with their frequencies, in a separate list. • On each iteration, • Compare the ith element of the original list with the values already encountered by traversing this auxiliary list. • If a matching value is found, increment its frequency; • else add the current element to the list of distinct values seen so far with a frequency of 1.

  19. Efficiency Analysis: • The worst-case input for this algorithm is a list with no equal elements. • For such a list, its ith element is compared with i – 1 elements of the auxiliary list of distinct values seen so far before being added to the list with a frequency of 1. • As a result, the worst-case number of comparisons made by the algorithm in creating the frequency list is • C(n) = • = 0 + 1 + 2 + 3 +… + (n – 1) • = (n – 1)n/2 ε Θ(n2 ) • …

  20. Efficiency Analysis: • The worst-case input for this algorithm is a list with no equal elements. • … • The additional n - 1 comparisons need to find the largest frequency in the auxiliary list do not change the quadratic worst-case efficiency class of the algorithm. That is, Tscan (n) = Θ(n). • Time efficiency for this brute force algorithm is: • T(n) = TC(n) (n) + Tscan (n) • = Θ(n2 ) + Θ(n) • = Θ(n2 ).

  21. As an alternative (Instance Simplification using Presorting), • First sort the input. • Then all equal values will be adjacent to each other. • To compute the mode, all we need to do is to find the longest run of adjacent equal values in the sorted array.

  22. Algorithm PresortMode(A[0 .. n-1]) //computes the mode of an array by sorting it first. //Input: An array A[0 .. n-1] of orderable elements //Output: The array’s mode sort the array A; i ← 0; //current run begins atposition I. modefrequency ← 0; //highest frequency seen so far. while i ≤ n-1 do { //go through A[0] through A[n-1] runlength ← 1; //reset identical contents# be 1 as itself runvalue ← A[i]; //set A[i] content as a new sequence //ask whether the next A[i+1], A[i+2], ... is identical to A[i]. If yes, ident.cont#++ while ( i + runlength ≤ n-1 & A[i+runlength] = = runvalue ) do runlength ← runlength + 1;//end inner while-do //if this identical contents# greater than existing modefreq, then set new modefreq. if runlength > modefrequency { modefrequency ← runlength; modevalue ← runvalue; } //end if //set the new content A[i+modefrequency] as next runvalue. Repeat the same process. i ← i + runlength; }//end outer while-do return modevalue;

  23. The algorithm analysis: • It is similar to the analysis of Example 1: • The running time of the algorithm will be dominated by the time spent on sorting since the remainder of the algorithm takes linear time (why?). • Given a list of n distinct elements in A[0..n-1], the inner while-loop will compare A[i] and A[i+1], 0 ≤i≤n-2 {using the basic operation of the algorithm, A[i+runlength] = = runvalue }. That is, the basic operation A[i+runlength] = runvalue will be execute n times only.

  24. Given a list of n mix-identical elements in A[0..n-1], say 3, 3, 4, 5, 5, 5, 6, 7, 7, 7. • That is, increase i by runlength (which is the number of identical contents. • C(n) = summation of runlength per each distinct element of a given list. For this example, 3, 3, 4, 5, 5, 5, 6, 7, 7, 7 C(n) = 23 + 14 + 35 + 16 + 37 = 10. That is C(n) = Θ(n). • Consequently, with an nlog n sort, this method’s worst-case will be in a better asymptotic class than the worst case efficiency of the brute-force algorithm, which is Θ(n2 ). • T(n) = TSort (n) + TC(n) (n) • = Θ(nlog n ) + Θ(n) • = Θ(nlog n )

  25. Example 3 : Searching problem • Consider the problem of searching for a given value v in a given array of n sortable items. • The brute-force solution is sequential search which needs n comparisons in the worst case. • If the array is sorted first, we can then apply binary search, which requires only └ log2 n ┘ + 1 comparisons in the worst case. • Assuming the most efficient n log n sort, the total running time of searching algorithm in the worst case will be • T(n) = Tsort(n) + Tsearch(n) • = Θ(nlog n) + Θ(log n) • = Θ(nlog n), • which is inferior to sequential search. The same will also be true for the average-case efficiency.

  26. Applications of presorting: • Geometric algorithms dealing with sets of points use presorting in one way or another. • Points can be sorted by one of their coordinates or by their distance from a particular line or by some angle, and so on. • For example, presorting was used in the divide-and-conquer algorithms for the closest-pair problem and for the convex-hull problem. For 2D, O(n log n), s = 2 • Some problems for directed acyclic graphs can be solved more easily after topologically sorting the diagraph in question. O(V+E) • The problem of finding the shortest and longest paths in such diagraphs illustrate this point.

  27. Gaussian Elimination-representation change • Consider a system of two linear equations in two unknown: • a11 x + a12 y = b1 • a21 x + a22 y = b2 • The standard method for finding the solution for the system is to • use either equation to express one of the variables as a function of the other and then x = (b1/ a11 ) - (a12 / a11 )y • substitute the result into the other equation, • yielding a linear equation whose solution is then used for finding the value of the second variable. a21 x + a22 y = b2 implies a21 ((b1/ a11 ) - (a12 / a11 ) y) + a22 y = b2 .

  28. In general, consider a system of n equations in a large number n unknowns: a11 x1 + a12 x2 + … + a1nxn = b1 a21 x1 + a22 x2 + … + a2nxn = b2 … an1 x1 + an2 x2 + … + annxn = bn An elegant algorithm for solving system of linear equations called Gaussian elimination.

  29. Gaussian elimination The idea of Gaussian elimination is to transform a system of n linear equations in n unknowns to an equivalent system (i.e., a system with the same solution as the original one) with an upper triangular coefficient matrix, a matrix with all zeros below its main diagonal:

  30. a11 x1 + a12 x2 + … + a1nxn = b1 a21 x1 + a22 x2 + … + a2nxn = b2 a31 x1 + a32 x2 + … + a3nxn = b3 … an1 x1 + an2 x2 + … +ann xn = bn a’11 x1 + a’12 x2 + … +a’1n xn = b’1 a’22 x2 + … + a’2n xn = b’2 where row 2 - (a21/ a11)* row 1; row 3 - (a31/ a11)* row 1; ... … a’nnxn = b’nrow n - (an1/ a11)* row 1; ...

  31. In matrix notations, we can write it as Ax = b A’x = b’, where a11 a12 … a1n b1 a21 a22 … a2n b2 A = … B = … an1 an2 … annbn a’11 a’12 … a’1n b’1 0 a’22 … a’2n b’2 A’ = … B’ = … 0 0 … a’nnb’n

  32. Example: Solve the system by Gaussian elimination 2x1 - x2 + x3 = 1 4x1 + x2 – x3 = 5 x1 + x2 + x3 = 0 2 -1 1 1 4 1 -1 5 row 2 – 4/2 row1 :row 2 - (a21/ a11)* row 1; 1 1 1 0 row 3 – 1/2 row1 :row 3 - (a31/ a11)* row 1; 2 -1 1 1 0 3 -3 3 0 3/2 1/2 -1/2 row 3 – 1/2 row2 {where ½ = (3/2)/3}

  33. 2 -1 1 1 0 3 -3 3 0 3/2 1/2 -1/2 row 3 – 1/2 row2 {where ½ = (3/2)/3} 2 -1 1 1 0 3 -3 3 0 0 2 -2 x3 = -2/2 = -1 x2 = (3 +3 (-1))/3 = 0 x1 = ( 1 – (-1)(0) – 1(-1))/2 = 1 Now we can obtain the solution by backward substitutions: 2x1 - x2 + x3 = 1 3x2 - 3x3 = 3 yields 2x3 = -2

  34. Algorithm GaussElimination(A[1 .. n, 1 .. n], b[1 .. n]) //Applies Gaussian elimination to matrix A of a system’s coefficients, //augmented with vector b of the system’s right-hand side values. //Input: Matrix A[1 .. n, 1 .. n], and column-vector b[1 .. n] //Output: An equivalent upper-triangular matrix in place of A with the // corresponding right-hand side values in the (n+1)st column. for i ← 1 to n do //set b’s be arguments as the values A[i, n+1] ← b[i]; //in the last column of the matrix //end for for i ← 1 to n-1 do for j ← i+1 to n do //rows after setting ith row for k ← i to n+1 do //column A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i]; ; ;

  35. A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] i A[2, 1] A[2, 2] A[2, 3] A[2,4] A[2, 5] j A[3, 1] A[3, 2] A[3, 3] A[3,4] A[3, 5] A[4, 1] A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 k for i ← 1 to n do A[i, n+1] ← b[i]; //augments the matrix as the last col. //end for for i ← 1 to n-1 do for j ← i+1 to n do //rows after setting ith row for k ← i to n+1 do //column A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i]; ; ;

  36. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1] A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1] A[3, 2] A[3, 3] A[3,4] A[3, 5] A[4, 1] A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 i = 1 ≤ 3; j = i+1 = 1+1=2 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i], where i≤ k ≤ 5 k = 1 ≤ 5 A[2,1] = A[2,1] – A[1,1] * A[2,1] / A[1,1]=0 k = 2 ≤ 5 A[2,2] = A[2,2] – A[1,2] * A[2,1] / A[1,1] k = 3 ≤ 5 A[2,3] = A[2,3] – A[1,3] * A[2,1] / A[1,1] k = 4 ≤ 5 A[2,4] = A[2,4] – A[1,4] * A[2,1] / A[1,1] k = 5 ≤ 5 A[2,5] = A[2,5] – A[1,5] * A[2,1] / A[1,1]

  37. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1] A[3, 2] A[3, 3] A[3,4] A[3, 5] A[4, 1] A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 j = 3 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i] k = 1 ≤ 5 A[3,1] = A[3,1] – A[1,1] * A[3,1] / A[1,1]=0 k = 2 ≤ 5 A[3,2] = A[3,2] – A[1,2] * A[3,1] / A[1,1] k = 3 ≤ 5 A[3,3] = A[3,3] – A[1,3] * A[3,1] / A[1,1] k = 4 ≤ 5 A[3,4] = A[3,4] – A[1,4] * A[3,1] / A[1,1] k = 5 ≤ 5 A[3,5] = A[3,5] – A[1,5] * A[3,1] / A[1,1]

  38. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1]=0 A[3, 2] A[3, 3] A[3,4] A[3, 5] A[4, 1] A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 j = 4 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i] k = 1 ≤ 5 A[4,1] = A[4,1] – A[1,1]*A[4,1]/A[1,1]=0 k = 2 ≤ 5 A[4,2] = A[4,2] – A[1,2]*A[4,1]/A[1,1] k = 3 ≤ 5 A[4,3] = A[4,3] – A[1,3]*A[4,1]/A[1,1] k = 4 ≤ 5 A[4,4] = A[4,4] – A[1,4]*A[4,1]/A[1,1] k = 5 ≤ 5 A[4,5] = A[4,5] – A[1,5]*A[4,1]/A[1,1]

  39. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1]=0 A[3, 2] A[3, 3] A[3,4] A[3, 5] A[4, 1]=0 A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 i = 2 ≤ 3; j = i+1 = 2+1=3 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i], where i≤ k ≤ 5 k = 2 ≤ 5 A[3,2] = A[3,2] – A[2,2]*A[3,2]/A[2,2]=0 k = 3 ≤ 5 A[3,3] = A[3,3] – A[2,3]*A[3,2]/A[2,2] k = 4 ≤ 5 A[3,4] = A[3,4] – A[2,4]*A[3,2]/A[2,2] k = 5 ≤ 5 A[3,5] = A[3,5] – A[2,5]*A[3,2]/A[2,2]

  40. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1]=0 A[3, 2]=0 A[3, 3] A[3,4] A[3, 5] A[4, 1]=0 A[4, 2] A[4, 3] A[4,4] A[4, 5] 4x5 i = 2 ≤ 3; j = i+1 = 2+1=4 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i], where i≤ k ≤ 5 k = 2 ≤ 5 A[4,2] = A[4,2] – A[2,2]*A[4,2]/A[2,2]=0 k = 3 ≤ 5 A[4,3] = A[4,3] – A[2,3]*A[4,2]/A[2,2] k = 4 ≤ 5 A[4,4] = A[4,4] – A[2,4]*A[4,2]/A[2,2] k = 5 ≤ 5 A[4,5] = A[4,5] – A[2,5]*A[4,2]/A[2,2]

  41. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1]=0 A[3, 2]=0 A[3, 3] A[3,4] A[3, 5] A[4, 1]=0 A[4, 2]=0 A[4, 3] A[4,4] A[4, 5] 4x5 i = 3 ≤ 3; j = i+1 = 3+1=4 ≤ 4 A[j, k] ← A[j, k] - A[i, k]* A[j, i] / A[i, i], where i≤ k ≤ 5 k = 3 ≤ 5 A[4,3] = A[4,3] – A[3,3]*A[4,3]/A[3,3]=0 k = 4 ≤ 5 A[4,4] = A[4,4] – A[3,4]*A[4,3]/A[3,3] k = 5 ≤ 5 A[4,5] = A[4,5] – A[3,5]*A[4,3]/A[3,3]

  42. Example: Consider 4 x 5 matrix A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] A[2, 1]=0 A[2, 2] A[2, 3] A[2,4] A[2, 5] A[3, 1]=0 A[3, 2]=0 A[3, 3] A[3,4] A[3, 5] A[4, 1]=0 A[4, 2]=0 A[4, 3]=0 A[4,4] A[4, 5] 4x5 That is, A[1, 1] A[1, 2] A[1, 3] A[1,4] A[1, 5] 0 A[2, 2] A[2, 3] A[2,4] A[2, 5] 0 0 A[3, 3] A[3,4] A[3, 5] 0 0 0 A[4,4] A[4, 5] 4x5

  43. There are two important observations to make about this pseudocode. • First, it is not always correct: • if A[i, i] = 0, we cannot divide by it and • the ith row cannot be used as a pivot for the ith iteration of the algorithm. • In such a case, by the first elementary operation, exchange the ith row with some row below it that has a nonzero coefficient in the ith column. • (If the system has a unique solution, which is the normal case for systems under consideration, such a row must exist).

  44. There are two important observations to make about this pseudocode. • First, it is not always correct: • … • To prepare for the possibility of row exchanges, we can take care of another potential difficulty: • the possibility that A[i, i] is so small and A[j, i] / A[i, i] so large that the new value of A[j, k] might become distorted by a round-off error caused by a subtraction of two numbers of greatly different magnitudes. • To avoid this problem, always look for a row with the largest absolute value of the coefficient in the ith column, exchange it with the ith row, and then use the new A[i, i] as the ith iteration’s pivot. • This modification called partial pivoting, guarantees that the magnitude of the scaling factor will never exceed 1.

  45. There are two important observations to make about this pseudocode. • First, it is not always correct: • if A[i, i] = 0, we cannot divide by it and • (If the system has a unique solution, which is the normal case for systems under consideration, such a row must exist). • The second observation is the fast that the innermost loop is written with a glaring inefficiency. • Can you find it before checking the following pseudocode, which both incorporates partial pivoting and eliminates this inefficiency?

  46. Algorithm BetterGaussElimination(A[1..n, 1..n], b[1..n]) //Implements Gaussian elimination with partial pivoting //Input: Matrix A[1..n, 1..n], and column-vector b[1..n] //Output: An equivalent upper-triangular matrix in place of a with the // corresponding right-hand side values in the (n+1)st column. for i ← 1 to n do A[i, n+1] ← b[i]; //appends b to A as the last col. //end for-do fori ← 1 to n-1 do pivotrow ← i; for j ← i+1 to n do if | A[j, i]| > |A[pivotrow, i]| pivotrow ← j; //end if; end for-do for k ← i to n+1 do swap(A[i, k], A[pivotrow, k]); //end for-do for j ← i+1 to n do temp ← A[j, i] / A[i, i]; for k ← i to n+1 do A[j, k] ← A[j, k] - A[i, k] * temp; //end for-do //end for-do //end for-do

  47. The time efficiency of this algorithm: • Its innermost loop consists of a single line • A[j, k] ← A[j, k] - A[i, k] * temp; • which contains one multiplication and one subtraction. • it is multiplication that is usually quoted as the algorithm’s basic operation. • C(n) = • ≈ ε Θ (n3 ) • Since the second (backward substitution) stage of the Gaussian elimination is in Θ( n2 ), as you will be asked to show in the exercise, the running time is dominated by the cubic elimination stage, making the entire algorithm cubic as well.

  48. C(n) = ∑n-1i=1 ∑nj=i+1 ∑n+1k=i1 = ∑n-1i=1 ∑nj=i+1 (n + 1 – i + 1) = ∑n-1i=1 ∑nj=i+1 (n + 2 – i) = ∑n-1i=1 (n + 2 – i) (n – (i + 1) + 1) = ∑n-1i=1 (n + 2 – i)(n - i) = (n + 1)(n - 1) + n(n - 2) + … + 3 * 1 = ∑n-1j=1 (j + 2) * j = ∑n-1j=1 j2 + ∑n-1j=1 2j = [(n - 1)n(2n - 1 ) / 6 ] + [ 2(n -1)n / 2 ] = n(n - 1)(2n + 5)/6 ≈ n3 / 3 ε Θ (n3 )

More Related