Design & Analysis of Algorithm

228 Transform-and-Conquer 10 the array representation 87 index 0 1 2 3 4 5 6 7 8 9 10 5 21 6 value 10 8 7 5 2 1 6 3 5 1 parents leaves 3 51 FIGURE 6.10 Heap and its array representation. relationship among key values for nodes either on the same level of the tree or, more generally, in the left and right subtrees of the same node. Here is a list of important properties of heaps, which are not difficult to prove (check these properties for the heap of Figure 6.10, as an example). 1. There exists exactly one essentially complete binary tree with n nodes. Its height is equal to log2 n . 2. The root of a heap always contains its largest element. 3. A node of a heap considered with all its descendants is also a heap. 4. A heap can be implemented as an array by recording its elements in the top- down, left-to-right fashion. It is convenient to store the heap’s elements in positions 1 through n of such an array, leaving H [0] either unused or putting there a sentinel whose value is greater than every element in the heap. In such a representation, a. the parental node keys will be in the first n/2 positions of the array, while the leaf keys will occupy the last n/2 positions; b. the children of a key in the array’s parental position i (1 ≤ i ≤ n/2 ) will be in positions 2i and 2i + 1, and, correspondingly, the parent of a key in position i (2 ≤ i ≤ n) will be in position i/2 . Thus, we could also define a heap as an array H [1..n] in which every element in position i in the first half of the array is greater than or equal to the elements in positions 2i and 2i + 1, i.e., H [i] ≥ max{H [2i], H [2i + 1]} for i = 1, . . . , n/2 . (Of course, if 2i + 1 > n, just H [i] ≥ H [2i] needs to be satisfied.) While the ideas behind the majority of algorithms dealing with heaps are easier to understand if we think of heaps as binary trees, their actual implementations are usually much simpler and more efficient with arrays. How can we construct a heap for a given list of keys? There are two principal alternatives for doing this. The first is the bottom-up heap construction algorithm illustrated in Figure 6.11. It initializes the essentially complete binary tree with n nodes by placing keys in the order given and then “heapifies” the tree as follows. Starting with the last parental node, the algorithm checks whether the parental

6.4 Heaps and Heapsort 229 2 2 2 97 98 98 6 58 6 57 6 57 2 9 9 98 28 68 6 57 6 57 2 57 FIGURE 6.11 Bottom-up construction of a heap for the list 2, 9, 7, 6, 5, 8. The double- headed arrows show key comparisons verifying the parental dominance. dominance holds for the key in this node. If it does not, the algorithm exchanges the node’s key K with the larger key of its children and checks whether the parental dominance holds for K in its new position. This process continues until the parental dominance for K is satisfied. (Eventually, it has to because it holds automatically for any key in a leaf.) After completing the “heapification” of the subtree rooted at the current parental node, the algorithm proceeds to do the same for the node’s immediate predecessor. The algorithm stops after this is done for the root of the tree. ALGORITHM HeapBottomUp(H [1..n]) //Constructs a heap from elements of a given array // by the bottom-up algorithm //Input: An array H [1..n] of orderable items //Output: A heap H [1..n] for i ← n/2 downto 1 do k ← i; v ← H [k] heap ← false while not heap and 2 ∗ k ≤ n do j ←2∗k if j < n //there are two children if H [j ] < H [j + 1] j ← j + 1 if v ≥ H [j ] heap ← true else H [k] ← H [j ]; k ← j H [k] ← v How efficient is this algorithm in the worst case? Assume, for simplicity, that n = 2k − 1 so that a heap’s tree is full, i.e., the largest possible number of

230 Transform-and-Conquer nodes occurs on each level. Let h be the height of the tree. According to the first property of heaps in the list at the beginning of the section, h = log2 n or just log2 (n + 1) − 1 = k − 1 for the specific values of n we are considering. Each key on level i of the tree will travel to the leaf level h in the worst case of the heap construction algorithm. Since moving to the next level down requires two comparisons—one to find the larger child and the other to determine whether the exchange is required—the total number of key comparisons involving a key on level i will be 2(h − i). Therefore, the total number of key comparisons in the worst case will be h−1 h−1 Cworst (n) = 2(h − i) = 2(h − i)2i = 2(n − log2(n + 1)), i=0 level i keys i=0 where the validity of the last equality can be proved either by using the closed-form formula for the sum h i2i (see Appendix A) or by mathematical induction on i=1 h. Thus, with this bottom-up algorithm, a heap of size n can be constructed with fewer than 2n comparisons. The alternative (and less efficient) algorithm constructs a heap by successive insertions of a new key into a previously constructed heap; some people call it the top-down heap construction algorithm. So how can we insert a new key K into a heap? First, attach a new node with key K in it after the last leaf of the existing heap. Then sift K up to its appropriate place in the new heap as follows. Compare K with its parent’s key: if the latter is greater than or equal to K, stop (the structure is a heap); otherwise, swap these two keys and compare K with its new parent. This swapping continues until K is not greater than its last parent or it reaches the root (illustrated in Figure 6.12). Obviously, this insertion operation cannot require more key comparisons than the heap’s height. Since the height of a heap with n nodes is about log2 n, the time efficiency of insertion is in O(log n). How can we delete an item from a heap? We consider here only the most important case of deleting the root’s key, leaving the question about deleting an arbitrary key in a heap for the exercises. (Authors of textbooks like to do such things to their readers, do they not?) Deleting the root’s key from a heap can be done with the following algorithm, illustrated in Figure 6.13. 9 9 10 68 6 10 69 2 57 10 2 57 8 2 57 8 FIGURE 6.12 Inserting a key (10) into the heap constructed in Figure 6.11. The new key is sifted up via a swap with its parent until it is not larger than its parent (or is in the root).

6.4 Heaps and Heapsort 231 9 86 2 51 1 1 8 Step 3 56 Step 1 Step 2 86 86 2 59 25 21 FIGURE 6.13 Deleting the root’s key from a heap. The key to be deleted is swapped with the last key after which the smaller tree is “heapified” by exchanging the new key in its root with the larger key in its children until the parental dominance requirement is satisfied. Maximum Key Deletion from a heap Step 1 Exchange the root’s key with the last key K of the heap. Step 2 Decrease the heap’s size by 1. Step 3 “Heapify” the smaller tree by sifting K down the tree exactly in the same way we did it in the bottom-up heap construction algorithm. That is, verify the parental dominance for K: if it holds, we are done; if not, swap K with the larger of its children and repeat this operation until the parental dominance condition holds for K in its new position. The efficiency of deletion is determined by the number of key comparisons needed to “heapify” the tree after the swap has been made and the size of the tree is decreased by 1. Since this cannot require more key comparisons than twice the heap’s height, the time efficiency of deletion is in O(log n) as well. Heapsort Now we can describe heapsort—an interesting sorting algorithm discovered by J. W. J. Williams [Wil64]. This is a two-stage algorithm that works as follows. Stage 1 (heap construction): Construct a heap for a given array. Stage 2 (maximum deletions): Apply the root-deletion operation n − 1 times to the remaining heap. As a result, the array elements are eliminated in decreasing order. But since under the array implementation of heaps an element being deleted is placed last, the resulting array will be exactly the original array sorted in increasing order. Heapsort is traced on a specific input in Figure 6.14. (The same input as the one

232 Transform-and-Conquer Stage 1 (heap construction) Stage 2 (maximum deletions) 2 9 7 658 96 82 5 7 2 9 8 657 7 6 8 2 5|9 2 9 8 657 86 72 5 9 2 8 657 5 6 7 2 |8 9 6 8 257 76 52 2 6 5|7 62 5 5 2|6 52 2|5 2 FIGURE 6.14 Sorting the array 2, 9, 7, 6, 5, 8 by heapsort. in Figure 6.11 is intentionally used so that you can compare the tree and array implementations of the bottom-up heap construction algorithm.) Since we already know that the heap construction stage of the algorithm is in O(n), we have to investigate just the time efficiency of the second stage. For the number of key comparisons, C(n), needed for eliminating the root keys from the heaps of diminishing sizes from n to 2, we get the following inequality: n−1 C(n) ≤ 2 log2(n − 1) + 2 log2(n − 2) + . . . + 2 log2 1 ≤ 2 log2 i i=1 n−1 ≤ 2 log2(n − 1) = 2(n − 1) log2(n − 1) ≤ 2n log2 n. i=1 This means that C(n) ∈ O(n log n) for the second stage of heapsort. For both stages, we get O(n) + O(n log n) = O(n log n). A more detailed analysis shows that the time efficiency of heapsort is, in fact, in (n log n) in both the worst and average cases. Thus, heapsort’s time efficiency falls in the same class as that of mergesort. Unlike the latter, heapsort is in-place, i.e., it does not require any extra storage. Timing experiments on random files show that heapsort runs more slowly than quicksort but can be competitive with mergesort.

6.4 Heaps and Heapsort 233 Exercises 6.4 1. a. Construct a heap for the list 1, 8, 6, 5, 3, 7, 4 by the bottom-up algorithm. b. Construct a heap for the list 1, 8, 6, 5, 3, 7, 4 by successive key insertions (top-down algorithm). c. Is it always true that the bottom-up and top-down algorithms yield the same heap for the same input? 2. Outline an algorithm for checking whether an array H [1..n] is a heap and determine its time efficiency. 3. a. Find the smallest and the largest number of keys that a heap of height h can contain. b. Prove that the height of a heap with n nodes is equal to log2 n . 4. Prove the following equality used in Section 6.4: h−1 where n = 2h+1 − 1. 2(h − i)2i = 2(n − log2(n + 1)), i=0 5. a. Design an efficient algorithm for finding and deleting an element of the smallest value in a heap and determine its time efficiency. b. Design an efficient algorithm for finding and deleting an element of a given value v in a heap H and determine its time efficiency. 6. Indicate the time efficiency classes of the three main operations of the priority queue implemented as a. an unsorted array. b. a sorted array. c. a binary search tree. d. an AVL tree. e. a heap. 7. Sort the following lists by heapsort by using the array representation of heaps. a. 1, 2, 3, 4, 5 (in increasing order) b. 5, 4, 3, 2, 1 (in increasing order) c. S, O, R, T, I, N, G (in alphabetical order) 8. Is heapsort a stable sorting algorithm? 9. What variety of the transform-and-conquer technique does heapsort repre- sent? 10. Which sorting algorithm other than heapsort uses a priority queue? 11. Implement three advanced sorting algorithms—mergesort, quicksort, and heapsort—in the language of your choice and investigate their performance on arrays of sizes n = 103, 104, 105, and 106. For each of these sizes consider

234 Transform-and-Conquer a. randomly generated files of integers in the range [1..n]. b. increasing files of integers 1, 2, . . . , n. c. decreasing files of integers n, n − 1, . . . , 1. 12. Spaghetti sort Imagine a handful of uncooked spaghetti, individual rods whose lengths represent numbers that need to be sorted. a. Outline a “spaghetti sort”—a sorting algorithm that takes advantage of this unorthodox representation. b. What does this example of computer science folklore (see [Dew93]) have to do with the topic of this chapter in general and heapsort in particular? 6.5 Horner’s Rule and Binary Exponentiation In this section, we discuss the problem of computing the value of a polynomial p(x) = anxn + an−1xn−1 + . . . + a1x + a0 (6.1) at a given point x and its important special case of computing xn. Polynomials constitute the most important class of functions because they possess a wealth of good properties on the one hand and can be used for approximating other types of functions on the other. The problem of manipulating polynomials efficiently has been important for several centuries; new discoveries were still being made the last 50 years. By far the most important of them was the fast Fourier transform (FFT). The practical importance of this remarkable algorithm, which is based on representing a polynomial by its values at specially chosen points, was such that some people consider it one of the most important algorithmic discoveries of all time. Because of its relative complexity, we do not discuss the FFT algorithm in this book. An interested reader will find a wealth of literature on the subject, including reasonably accessible treatments in such textbooks as [Kle06] and [Cor09]. Horner’s Rule Horner’s rule is an old but very elegant and efficient algorithm for evaluating a polynomial. It is named after the British mathematician W. G. Horner, who pub- lished it in the early 19th century. But according to Knuth [KnuII, p. 486], the method was used by Isaac Newton 150 years before Horner. You will appreciate this method much more if you first design an algorithm for the polynomial evalu- ation problem by yourself and investigate its efficiency (see Problems 1 and 2 in this section’s exercises). Horner’s rule is a good example of the representation-change technique since it is based on representing p(x) by a formula different from (6.1). This new formula is obtained from (6.1) by successively taking x as a common factor in the remaining polynomials of diminishing degrees: p(x) = (. . . (anx + an−1)x + . . .)x + a0. (6.2)

6.5 Horner’s Rule and Binary Exponentiation 235 For example, for the polynomial p(x) = 2x4 − x3 + 3x2 + x − 5, we get p(x) = 2x4 − x3 + 3x2 + x − 5 (6.3) = x(2x3 − x2 + 3x + 1) − 5 = x(x(2x2 − x + 3) + 1) − 5 = x(x(x(2x − 1) + 3) + 1) − 5. It is in formula (6.2) that we will substitute a value of x at which the polyno- mial needs to be evaluated. It is hard to believe that this is a way to an efficient algorithm, but the unpleasant appearance of formula (6.2) is just that, an appear- ance. As we shall see, there is no need to go explicitly through the transformation leading to it: all we need is an original list of the polynomial’s coefficients. The pen-and-pencil calculation can be conveniently organized with a two- row table. The first row contains the polynomial’s coefficients (including all the coefficients equal to zero, if any) listed from the highest an to the lowest a0. Except for its first entry, which is an, the second row is filled left to right as follows: the next entry is computed as the x’s value times the last entry in the second row plus the next coefficient from the first row. The final entry computed in this fashion is the value being sought. EXAMPLE 1 Evaluate p(x) = 2x4 − x3 + 3x2 + x − 5 at x = 3. coefficients 2 −1 3 1 −5 x = 3 2 3 . 2 + (−1) = 5 3 . 5 + 3 = 18 3 . 18 + 1 = 55 3 . 55 + (−5) = 160 Thus, p(3) = 160. (On comparing the table’s entries with formula (6.3), you will see that 3 . 2 + (−1) = 5 is the value of 2x − 1 at x = 3, 3 . 5 + 3 = 18 is the value of x(2x − 1) + 3 at x = 3, 3 . 18 + 1 = 55 is the value of x(x(2x − 1) + 3) + 1 at x = 3, and, finally, 3 . 55 + (−5) = 160 is the value of x(x(x(2x − 1) + 3) + 1) − 5 = p(x) at x = 3.) Pseudocode of this algorithm is the shortest one imaginable for a nontrivial algorithm: ALGORITHM Horner(P [0..n], x) //Evaluates a polynomial at a given point by Horner’s rule //Input: An array P [0..n] of coefficients of a polynomial of degree n, // stored from the lowest to the highest and a number x //Output: The value of the polynomial at x p ← P [n] for i ← n − 1 downto 0 do p ← x ∗ p + P [i] return p

236 Transform-and-Conquer The number of multiplications and the number of additions are given by the same sum: n−1 M(n) = A(n) = 1 = n. i=0 To appreciate how efficient Horner’s rule is, consider only the first term of a polynomial of degree n: anxn. Just computing this single term by the brute- force algorithm would require n multiplications, whereas Horner’s rule computes, in addition to this term, n − 1 other terms, and it still uses the same number of multiplications! It is not surprising that Horner’s rule is an optimal algorithm for polynomial evaluation without preprocessing the polynomial’s coefficients. But it took scientists 150 years after Horner’s publication to come to the realization that such a question was worth investigating. Horner’s rule also has some useful byproducts. The intermediate numbers generated by the algorithm in the process of evaluating p(x) at some point x0 turn out to be the coefficients of the quotient of the division of p(x) by x − x0, and the final result, in addition to being p(x0), is equal to the remainder of this division. Thus, according to Example 1, the quotient and the remainder of the division of 2x4 − x3 + 3x2 + x − 5 by x − 3 are 2x3 + 5x2 + 18x + 55 and 160, respectively. This division algorithm, known as synthetic division, is more convenient than so- called long division. Binary Exponentiation The amazing efficiency of Horner’s rule fades if the method is applied to comput- ing an, which is the value of xn at x = a. In fact, it degenerates to the brute-force multiplication of a by itself, with wasteful additions of zeros in between. Since computing an (actually, an mod m) is an essential operation in several important primality-testing and encryption methods, we consider now two algorithms for computing an that are based on the representation-change idea. They both exploit the binary representation of exponent n, but one of them processes this binary string left to right, whereas the second does it right to left. Let n = bI . . . bi . . . b0 be the bit string representing a positive integer n in the binary number system. This means that the value of n can be computed as the value of the polynomial p(x) = bI xI + . . . + bixi + . . . + b0 (6.4) at x = 2. For example, if n = 13, its binary representation is 1101 and 13 = 1 . 23 + 1 . 22 + 0 . 21 + 1 . 20. Let us now compute the value of this polynomial by applying Horner’s rule and see what the method’s operations imply for computing the power an = ap(2) = abI 2I +...+bi2i+...+b0.

6.5 Horner’s Rule and Binary Exponentiation 237 Horner’s rule for the binary polynomial p(2) Implications for an = ap(2) p ← 1 //the leading digit is always 1 for n ≥ 1 ap ← a1 for i ← I − 1 downto 0 do for i ← I − 1 downto 0 do p ← 2p + bi ap ← a2p+bi But a2p+bi = a2p . abi = (ap)2 . abi = (ap)2 if bi = 0, (ap)2 . a if bi = 1. Thus, after initializing the accumulator’s value to a, we can scan the bit string representing the exponent n to always square the last value of the accumulator and, if the current binary digit is 1, also to multiply it by a. These observations lead to the following left-to-right binary exponentiation method of computing an. ALGORITHM LeftRightBinaryExponentiation(a, b(n)) //Computes an by the left-to-right binary exponentiation algorithm //Input: A number a and a list b(n) of binary digits bI , . . . , b0 // in the binary expansion of a positive integer n //Output: The value of an product ← a for i ← I − 1 downto 0 do product ← product ∗ product if bi = 1 product ← product ∗ a return product EXAMPLE 2 Compute a13 by the left-to-right binary exponentiation algorithm. Here, n = 13 = 11012. So we have binary digits of n 1 1 0 1 (a6)2 . a = a13 product accumulator a a2 . a = a3 (a3)2 = a6 Since the algorithm makes one or two multiplications on each repetition of its only loop, the total number of multiplications M(n) made by it in computing an is (b − 1) ≤ M(n) ≤ 2(b − 1), where b is the length of the bit string representing the exponent n. Taking into account that b − 1 = log2 n , we can conclude that the efficiency of the left- to-right binary exponentiation is logarithmic. Thus, this algorithm is in a better efficiency class than the brute-force exponentiation, which always requires n − 1 multiplications.

238 Transform-and-Conquer The right-to-left binary exponentiation uses the same binary polynomial p(2) (see (6.4)) yielding the value of n. But rather than applying Horner’s rule to it as the previous method did, this one exploits it differently: an = abI 2I +...+bi2i+...+b0 = abI 2I . . . . . abi2i . . . . . ab0. Thus, an can be computed as the product of the terms abi2i = a2i if bi = 1, 1 if bi = 0, i.e., the product of consecutive terms a2i, skipping those for which the binary digit bi is zero. In addition, we can compute a2i by simply squaring the same term we computed for the previous value of i since a2i = (a2i−1)2. So we compute all such powers of a from the smallest to the largest (from right to left), but we include in the product accumulator only those whose corresponding binary digit is 1. Here is pseudocode of this algorithm. ALGORITHM RightLeftBinaryExponentiation(a, b(n)) //Computes an by the right-to-left binary exponentiation algorithm //Input: A number a and a list b(n) of binary digits bI , . . . , b0 // in the binary expansion of a nonnegative integer n //Output: The value of an term ← a //initializes a2i if b0 = 1 product ← a else product ← 1 for i ← 1 to I do term ← term ∗ term if bi = 1 product ← product ∗ term return product EXAMPLE 3 Compute a13 by the right-to-left binary exponentiation method. Here, n = 13 = 11012. So we have the following table filled in from right to left: 1 1 0 1 binary digits of n a8 a4 a2 a terms a2i a5 . a8 = a13 a . a4 = a5 a product accumulator Obviously, the algorithm’s efficiency is also logarithmic for the same reason the left-to-right binary multiplication is. The usefulness of both binary exponentia- tion algorithms is reduced somewhat by their reliance on availability of the explicit

6.5 Horner’s Rule and Binary Exponentiation 239 binary expansion of exponent n. Problem 9 in this section’s exercises asks you to design an algorithm that does not have this shortcoming. Exercises 6.5 1. Consider the following brute-force algorithm for evaluating a polynomial. ALGORITHM BruteForcePolynomialEvaluation(P [0..n], x) //Computes the value of polynomial P at a given point x //by the “highest to lowest term” brute-force algorithm //Input: An array P [0..n] of the coefficients of a polynomial of degree n, // stored from the lowest to the highest and a number x //Output: The value of the polynomial at the point x p ← 0.0 for i ← n downto 0 do power ← 1 for j ← 1 to i do power ← power ∗ x p ← p + P [i] ∗ power return p Find the total number of multiplications and the total number of additions made by this algorithm. 2. Write pseudocode for the brute-force polynomial evaluation that stems from substituting a given value of the variable into the polynomial’s formula and evaluating it from the lowest term to the highest one. Determine the number of multiplications and the number of additions made by this algorithm. 3. a. Estimate how much faster Horner’s rule is compared to the “lowest-to- highest term” brute-force algorithm of Problem 2 if (i) the time of one multiplication is significantly larger than the time of one addition; (ii) the time of one multiplication is about the same as the time of one addition. b. Is Horner’s rule more time efficient at the expense of being less space efficient than the brute-force algorithm? 4. a. Apply Horner’s rule to evaluate the polynomial p(x) = 3x4 − x3 + 2x + 5 at x = −2. b. Use the results of the above application of Horner’s rule to find the quo- tient and remainder of the division of p(x) by x + 2. 5. Apply Horner’s rule to convert 110100101 from binary to decimal. 6. Compare the number of multiplications and additions/subtractions needed by the “long division” of a polynomial p(x) = anxn + an−1xn−1 + . . . + a0 by

240 Transform-and-Conquer x − c, where c is some constant, with the number of these operations in the “synthetic division.” 7. a. Apply the left-to-right binary exponentiation algorithm to compute a17. b. Is it possible to extend the left-to-right binary exponentiation algorithm to work for every nonnegative integer exponent? 8. Apply the right-to-left binary exponentiation algorithm to compute a17. 9. Design a nonrecursive algorithm for computing an that mimics the right-to-left binary exponentiation but does not explicitly use the binary representation of n. 10. Is it a good idea to use a general-purpose polynomial-evaluation algorithm such as Horner’s rule to evaluate the polynomial p(x) = xn + xn−1 + . . . + x + 1? 11. According to the corollary of the Fundamental Theorem of Algebra, every polynomial p(x) = anxn + an−1xn−1 + . . . + a0 can be represented in the form p(x) = an(x − x1)(x − x2) . . . (x − xn) where x1, x2, . . . , xn are the roots of the polynomial (generally, complex and not necessarily distinct). Discuss which of the two representations is more convenient for each of the following operations: a. polynomial evaluation at a given point b. addition of two polynomials c. multiplication of two polynomials 12. Polynomial interpolation Given a set of n data points (xi, yi) where no two xi are the same, find a polynomial p(x) of degree at most n − 1 such that p(xi) = yi for every i = 1, 2, . . . , n. 6.6 Problem Reduction Here is my version of a well-known joke about mathematicians. Professor X, a noted mathematician, noticed that when his wife wanted to boil water for their tea, she took their kettle from their cupboard, filled it with water, and put it on the stove. Once, when his wife was away (if you have to know, she was signing her best-seller in a local bookstore), the professor had to boil water by himself. He saw that the kettle was sitting on the kitchen counter. What did Professor X do? He put the kettle in the cupboard first and then proceeded to follow his wife’s routine.

6.6 Problem Reduction 241 reduction alg. A Problem 1 Problem 2 solution to Problem 2 (to be solved) (solvable by alg. A) FIGURE 6.15 Problem reduction strategy. The way Professor X approached his task is an example of an important problem-solving strategy called problem reduction. If you need to solve a problem, reduce it to another problem that you know how to solve (Figure 6.15). The joke about the professor notwithstanding, the idea of problem reduction plays a central role in theoretical computer science, where it is used to classify problems according to their complexity. We will touch on this classification in Chapter 11. But the strategy can be used for actual problem solving, too. The practical difficulty in applying it lies, of course, in finding a problem to which the problem at hand should be reduced. Moreover, if we want our efforts to be of practical value, we need our reduction-based algorithm to be more efficient than solving the original problem directly. Note that we have already encountered this technique earlier in the book. In Section 6.5, for example, we mentioned the so-called synthetic division done by applying Horner’s rule for polynomial evaluation. In Section 5.5, we used the following fact from analytical geometry: if p1(x1, y1), p2(x2, y2), and p3(x3, y3) are three arbitrary points in the plane, then the determinant x1 y1 1 x2 y2 1 = x1y2 + x3y1 + x2y3 − x3y2 − x1y3 − x2y1 x3 y3 1 is positive if and only if the point p3 is to the left of the directed line p−−−p−→ through 12 points p1 and p2. In other words, we reduced a geometric question about the relative locations of three points to a question about the sign of a determinant. In fact, the entire idea of analytical geometry is based on reducing geometric problems to algebraic ones. And the vast majority of geometric algorithms take advantage of this historic insight by Rene´ Descartes (1596–1650). In this section, we give a few more examples of algorithms based on the strategy of problem reduction. Computing the Least Common Multiple Recall that the least common multiple of two positive integers m and n, denoted lcm(m, n), is defined as the smallest integer that is divisible by both m and n. For example, lcm(24, 60) = 120, and lcm(11, 5) = 55. The least common multiple is one of the most important notions in elementary arithmetic and algebra. Perhaps you remember the following middle-school method for computing it: Given the prime factorizations of m and n, compute the product of all the common prime

242 Transform-and-Conquer factors of m and n, all the prime factors of m that are not in n, and all the prime factors of n that are not in m. For example, 24 = 2 . 2 . 2 . 3, 60 = 2 . 2 . 3 . 5, lcm(24, 60) = (2 . 2 . 3) . 2 . 5 = 120. As a computational procedure, this algorithm has the same drawbacks as the middle-school algorithm for computing the greatest common divisor discussed in Section 1.1: it is inefficient and requires a list of consecutive primes. A much more efficient algorithm for computing the least common multiple can be devised by using problem reduction. After all, there is a very efficient algorithm (Euclid’s algorithm) for finding the greatest common divisor, which is a product of all the common prime factors of m and n. Can we find a formula relating lcm(m, n) and gcd(m, n)? It is not difficult to see that the product of lcm(m, n) and gcd(m, n) includes every factor of m and n exactly once and hence is simply equal to the product of m and n. This observation leads to the formula lcm(m, n) = m . n , gcd(m, n) where gcd(m, n) can be computed very efficiently by Euclid’s algorithm. Counting Paths in a Graph As our next example, we consider the problem of counting paths between two vertices in a graph. It is not difficult to prove by mathematical induction that the number of different paths of length k > 0 from the ith vertex to the j th vertex of a graph (undirected or directed) equals the (i, j )th element of Ak where A is the adjacency matrix of the graph. Therefore, the problem of counting a graph’s paths can be solved with an algorithm for computing an appropriate power of its adjacency matrix. Note that the exponentiation algorithms we discussed before for computing powers of numbers are applicable to matrices as well. As a specific example, consider the graph of Figure 6.16. Its adjacency matrix A and its square A2 indicate the numbers of paths of length 1 and 2, respectively, between the corresponding vertices of the graph. In particular, there are three ab abcd abcd a 0111 a 3011 b 1000 A2 = b 0 1 1 1 A= c 1 0 0 1 c 1121 cd d 1010 d 1112 FIGURE 6.16 A graph, its adjacency matrix A, and its square A2. The elements of A and A2 indicate the numbers of paths of lengths 1 and 2, respectively.

6.6 Problem Reduction 243 paths of length 2 that start and end at vertex a (a − b − a, a − c − a, and a − d − a); but there is only one path of length 2 from a to c (a − d − c). Reduction of Optimization Problems Our next example deals with solving optimization problems. If a problem asks to find a maximum of some function, it is said to be a maximization problem; if it asks to find a function’s minimum, it is called a minimization problem. Suppose now that you need to find a minimum of some function f (x) and you have an algorithm for function maximization. How can you take advantage of the latter? The answer lies in the simple formula min f (x) = − max[−f (x)]. In other words, to minimize a function, we can maximize its negative instead and, to get a correct minimal value of the function itself, change the sign of the answer. This property is illustrated for a function of one real variable in Figure 6.17. Of course, the formula max f (x) = − min[−f (x)] is valid as well; it shows how a maximization problem can be reduced to an equivalent minimization problem. This relationship between minimization and maximization problems is very general: it holds for functions defined on any domain D. In particular, we can y f (x ) f (x*) x* x –f (x*) –f (x ) FIGURE 6.17 Relationship between minimization and maximization problems: min f (x) = − max[−f (x)].

244 Transform-and-Conquer apply it to functions of several variables subject to additional constraints. A very important class of such problems is introduced below in this section. Now that we are on the topic of function optimization, it is worth pointing out that the standard calculus procedure for finding extremum points of a function is, in fact, also based on problem reduction. Indeed, it suggests finding the function’s derivative f (x) and then solving the equation f (x) = 0 to find the function’s critical points. In other words, the optimization problem is reduced to the problem of solving an equation as the principal part of finding extremum points. Note that we are not calling the calculus procedure an algorithm, since it is not clearly defined. In fact, there is no general method for solving equations. A little secret of calculus textbooks is that problems are carefully selected so that critical points can always be found without difficulty. This makes the lives of both students and instructors easier but, in the process, may unintentionally create a wrong impression in students’ minds. Linear Programming Many problems of optimal decision making can be reduced to an instance of the linear programming problem—a problem of optimizing a linear function of several variables subject to constraints in the form of linear equations and linear inequalities. EXAMPLE 1 Consider a university endowment that needs to invest $100 million. This sum has to be split between three types of investments: stocks, bonds, and cash. The endowment managers expect an annual return of 10%, 7%, and 3% for their stock, bond, and cash investments, respectively. Since stocks are more risky than bonds, the endowment rules require the amount invested in stocks to be no more than one-third of the moneys invested in bonds. In addition, at least 25% of the total amount invested in stocks and bonds must be invested in cash. How should the managers invest the money to maximize the return? Let us create a mathematical model of this problem. Let x, y, and z be the amounts (in millions of dollars) invested in stocks, bonds, and cash, respectively. By using these variables, we can pose the following optimization problem: maximize 0.10x + 0.07y + 0.03z subject to x + y + z = 100 x ≤ 1 y 3 z ≥ 0.25(x + y) x ≥ 0, y ≥ 0, z ≥ 0. Although this example is both small and simple, it does show how a problem of optimal decision making can be reduced to an instance of the general linear programming problem