程序代写代做代考 B tree gui cache go Excel chain computational biology kernel DNA ada algorithm computer architecture information theory C js arm graph Hive database concurrency assembly html data structure decision tree game Java AVL ER clock assembler discrete mathematics interpreter flex compiler AI c++ INTRODUCTION TO

72 Chapter 4 Divide-and-Conquer
This procedure works as follows. Lines 1–7 find a maximum subarray of the left half, AŒlow : : mid􏳩. Since this subarray must contain AŒmid􏳩, the for loop of lines 3–7 starts the index i at mid and works down to low, so that every subarray it considers is of the form AŒi : : mid􏳩. Lines 1–2 initialize the variables left-sum, which holds the greatest sum found so far, and sum, holding the sum of the entries in AŒi : : mid􏳩. Whenever we find, in line 5, a subarray AŒi : : mid􏳩 with a sum of values greater than left-sum, we update left-sum to this subarray’s sum in line 6, and in line 7 we update the variable max-left to record this index i. Lines 8–14 work analogously for the right half, AŒmid C 1 : : high􏳩. Here, the for loop of lines 10–14 starts the index j at midC1 and works up to high, so that every subarray it considers is of the form AŒmid C 1 : : j 􏳩. Finally, line 15 returns the indices max-left and max-right that demarcate a maximum subarray crossing the midpoint, along with the sum left-sum C right-sum of the values in the subarray AŒmax-left : : max-right􏳩.
If the subarray AŒlow : : high􏳩 contains n entries (so that n D high 􏳣 low C 1), we claim that the call FIND-MAX-CROSSING-SUBARRAY .A; low; mid; high/ takes ‚.n/ time. Since each iteration of each of the two for loops takes ‚.1/ time, we just need to count up how many iterations there are altogether. The for loop of lines 3–7 makes mid 􏳣 low C 1 iterations, and the for loop of lines 10–14 makes high 􏳣 mid iterations, and so the total number of iterations is
.mid􏳣lowC1/C.high􏳣mid/ D high􏳣lowC1 Dn:
With a linear-time FIND-MAX-CROSSING-SUBARRAY procedure in hand, we can write pseudocode for a divide-and-conquer algorithm to solve the maximum- subarray problem:
FIND-MAXIMUM-SUBARRAY.A; low; high/
1 2 3 4
5 6
7 8 9
10 11
if high == low
return .low; high; AŒlow􏳩/
else mid D b.low C high/=2c .left-low; left-high; left-sum/ D
// base case: only one element
FIND-MAXIMUM-SUBARRAY.A; low; mid/ .right-low; right-high; right-sum/ D
FIND-MAXIMUM-SUBARRAY.A; mid C 1; high/ .cross-low; cross-high; cross-sum/ D
FIND-MAX-CROSSING-SUBARRAY .A; low; mid; high/ if left-sum 􏳦 right-sum and left-sum 􏳦 cross-sum
return .left-low; left-high; left-sum/
elseif right-sum 􏳦 left-sum and right-sum 􏳦 cross-sum
return .right-low; right-high; right-sum/ else return .cross-low; cross-high; cross-sum/

4.1 The maximum-subarray problem 73
The initial call FIND-MAXIMUM-SUBARRAY.A; 1; A:length/ will find a maxi- mum subarray of AŒ1 : : n􏳩.
Similar to FIND-MAX-CROSSING-SUBARRAY, the recursive procedure FIND- MAXIMUM-SUBARRAY returns a tuple containing the indices that demarcate a maximum subarray, along with the sum of the values in a maximum subarray. Line 1 tests for the base case, where the subarray has just one element. A subar- ray with just one element has only one subarray—itself—and so line 2 returns a tuple with the starting and ending indices of just the one element, along with its value. Lines 3–11 handle the recursive case. Line 3 does the divide part, comput- ing the index mid of the midpoint. Let’s refer to the subarray AŒlow : : mid􏳩 as the left subarray and to AŒmid C 1 : : high􏳩 as the right subarray. Because we know that the subarray AŒlow : : high􏳩 contains at least two elements, each of the left and right subarrays must have at least one element. Lines 4 and 5 conquer by recur- sively finding maximum subarrays within the left and right subarrays, respectively. Lines 6–11 form the combine part. Line 6 finds a maximum subarray that crosses the midpoint. (Recall that because line 6 solves a subproblem that is not a smaller instance of the original problem, we consider it to be in the combine part.) Line 7 tests whether the left subarray contains a subarray with the maximum sum, and line 8 returns that maximum subarray. Otherwise, line 9 tests whether the right subarray contains a subarray with the maximum sum, and line 10 returns that max- imum subarray. If neither the left nor right subarrays contain a subarray achieving the maximum sum, then a maximum subarray must cross the midpoint, and line 11 returns it.
Analyzing the divide-and-conquer algorithm
Next we set up a recurrence that describes the running time of the recursive FIND- MAXIMUM-SUBARRAY procedure. As we did when we analyzed merge sort in Section 2.3.2, we make the simplifying assumption that the original problem size is a power of 2, so that all subproblem sizes are integers. We denote by T .n/ the running time of FIND-MAXIMUM-SUBARRAY on a subarray of n elements. For starters, line 1 takes constant time. The base case, when n D 1, is easy: line 2 takes constant time, and so
T .1/ D ‚.1/ : (4.5)
The recursive case occurs when n > 1. Lines 1 and 3 take constant time. Each of the subproblems solved in lines 4 and 5 is on a subarray of n=2 elements (our assumption that the original problem size is a power of 2 ensures that n=2 is an integer), and so we spend T.n=2/ time solving each of them. Because we have to solve two subproblems—for the left subarray and for the right subarray—the contribution to the running time from lines 4 and 5 comes to 2T .n=2/. As we have

74 Chapter 4 Divide-and-Conquer
already seen, the call to FIND-MAX-CROSSING-SUBARRAY in line 6 takes ‚.n/ time. Lines 7–11 take only ‚.1/ time. For the recursive case, therefore, we have
T.n/ D ‚.1/ C 2T.n=2/ C ‚.n/ C ‚.1/
D 2T .n=2/ C ‚.n/ : (4.6)
Combining equations (4.5) and (4.6) gives us a recurrence for the running time T .n/ of FIND-MAXIMUM-SUBARRAY:
(
T.n/D ‚.1/ ifnD1; (4.7) 2T.n=2/C‚.n/ ifn>1:
This recurrence is the same as recurrence (4.1) for merge sort. As we shall see from the master method in Section 4.5, this recurrence has the solution T .n/ D ‚.n lg n/. You might also revisit the recursion tree in Figure 2.5 to un- derstand why the solution should be T .n/ D ‚.n lg n/.
Thus, we see that the divide-and-conquer method yields an algorithm that is asymptotically faster than the brute-force method. With merge sort and now the maximum-subarray problem, we begin to get an idea of how powerful the divide- and-conquer method can be. Sometimes it will yield the asymptotically fastest algorithm for a problem, and other times we can do even better. As Exercise 4.1-5 shows, there is in fact a linear-time algorithm for the maximum-subarray problem, and it does not use divide-and-conquer.
Exercises
4.1-1
What does FIND-MAXIMUM-SUBARRAY return when all elements of A are nega- tive?
4.1-2
Write pseudocode for the brute-force method of solving the maximum-subarray problem. Your procedure should run in ‚.n2/ time.
4.1-3
Implement both the brute-force and recursive algorithms for the maximum- subarray problem on your own computer. What problem size n0 gives the crossover point at which the recursive algorithm beats the brute-force algorithm? Then, change the base case of the recursive algorithm to use the brute-force algorithm whenever the problem size is less than n0. Does that change the crossover point?
4.1-4
Suppose we change the definition of the maximum-subarray problem to allow the result to be an empty subarray, where the sum of the values of an empty subar-

4.2 Strassen’s algorithm for matrix multiplication 75
ray is 0. How would you change any of the algorithms that do not allow empty subarrays to permit an empty subarray to be the result?
4.1-5
Use the following ideas to develop a nonrecursive, linear-time algorithm for the maximum-subarray problem. Start at the left end of the array, and progress toward the right, keeping track of the maximum subarray seen so far. Knowing a maximum subarray of AŒ1 : : j 􏳩, extend the answer to find a maximum subarray ending at in- dex j C1 by using the following observation: a maximum subarray of AŒ1 : : j C 1􏳩 is either a maximum subarray of AŒ1::j􏳩 or a subarray AŒi ::j C 1􏳩, for some 1 􏳥 i 􏳥 j C1. Determine a maximum subarray of the form AŒi::j C1􏳩 in constant time based on knowing a maximum subarray ending at index j .
4.2 Strassen’s algorithm for matrix multiplication
If you have seen matrices before, then you probably know how to multiply them. (Otherwise, you should read Section D.1 in Appendix D.) If A D .aij/ and BD.bij/aresquaren􏳨nmatrices,thenintheproductC DA􏳵B,wedefinethe entrycij,fori;j D1;2;:::;n,by
Xn kD1
We must compute n2 matrix entries, and each is the sum of n values. The following procedure takes n 􏳨 n matrices A and B and multiplies them, returning their n 􏳨 n product C . We assume that each matrix has an attribute rows, giving the number of rows in the matrix.
SQUARE-MATRIX-MULTIPLY.A;B/
cij D
aik 􏳵bkj : (4.8)
1 2 3 4 5 6 7 8
n D A:rows
letC beanewn􏳨nmatrix foriD1ton
for j D 1 to n cij D0
for k D 1 to n
cij DcijCaik􏳵bkj
return C
The SQUARE-MATRIX-MULTIPLY procedure works as follows. The for loop of lines 3–7 computes the entries of each row i, and within a given row i, the

76 Chapter 4 Divide-and-Conquer
for loop of lines 4–7 computes each of the entries cij , for each column j . Line 5 initializescij to0aswestartcomputingthesumgiveninequation(4.8),andeach iteration of the for loop of lines 6–7 adds in one more term of equation (4.8).
Because each of the triply-nested for loops runs exactly n iterations, and each execution of line 7 takes constant time, the SQUARE-MATRIX-MULTIPLY proce- dure takes ‚.n3/ time.
You might at first think that any matrix multiplication algorithm must take 􏳫.n3/ time, since the natural definition of matrix multiplication requires that many mul- tiplications. You would be incorrect, however: we have a way to multiply matrices in o.n3/ time. In this section, we shall see Strassen’s remarkable recursive algo- rithm for multiplying n 􏳨 n matrices. It runs in ‚.nlg 7/ time, which we shall show in Section 4.5. Since lg 7 lies between 2:80 and 2:81, Strassen’s algorithm runs in O.n2:81/ time, which is asymptotically better than the simple SQUARE-MATRIX- MULTIPLY procedure.
A simple divide-and-conquer algorithm
To keep things simple, when we use a divide-and-conquer algorithm to compute thematrixproductC DA􏳵B,weassumethatnisanexactpowerof2ineachof the n 􏳨 n matrices. We make this assumption because in each divide step, we will divide n 􏳨 n matrices into four n=2 􏳨 n=2 matrices, and by assuming that n is an exact power of 2, we are guaranteed that as long as n 􏳦 2, the dimension n=2 is an integer.
Suppose that we partition each of A, B, and C into four n=2 􏳨 n=2 matrices 􏳧􏳹􏳧􏳹􏳧􏳹
AD A11 A12 ; BD B11 B12 ; CD C11
C12 ; C22
(4.9)
(4.10)
(4.11) (4.12) (4.13) (4.14)
A21 A22 B21 B22
so that we rewrite the equation C D A 􏳵 B as 􏳧􏳹􏳧􏳹􏳧􏳹
C11 C12 D A11 A12 􏳵 B11 B12 : C21 C22 A21 A22 B21 B22
Equation (4.10) corresponds to the four equations
C11 D A11 􏳵B11 CA12 􏳵B21 ;
C12 D A11 􏳵B12 CA12 􏳵B22 ;
C21 D A21 􏳵B11 CA22 􏳵B21 ;
C22 D A21 􏳵B12 CA22 􏳵B22 :
C21
Each of these four equations specifies two multiplications of n=2 􏳨 n=2 matrices and the addition of their n=2 􏳨 n=2 products. We can use these equations to create a straightforward, recursive, divide-and-conquer algorithm:

4.2 Strassen’s algorithm for matrix multiplication 77
SQUARE-MATRIX-MULTIPLY-RECURSIVE.A;B/
1 2 3 4 5 6
7 8 9
10
n D A:rows
letC beanewn􏳨nmatrix ifn==1
c11 Da11􏳵b11
else partition A, B, and C as in equations (4.9)
C11 D SQUARE-MATRIX-MULTIPLY-RECURSIVE.A11;B11/ C SQUARE-MATRIX-MULTIPLY-RECURSIVE.A12; B21/ C12 D SQUARE-MATRIX-MULTIPLY-RECURSIVE.A11;B12/ C SQUARE-MATRIX-MULTIPLY-RECURSIVE.A12; B22/ C21 D SQUARE-MATRIX-MULTIPLY-RECURSIVE.A21;B11/ C SQUARE-MATRIX-MULTIPLY-RECURSIVE.A22; B21/ C22 D SQUARE-MATRIX-MULTIPLY-RECURSIVE.A21;B12/ C SQUARE-MATRIX-MULTIPLY-RECURSIVE.A22; B22/
return C
This pseudocode glosses over one subtle but important implementation detail. How do we partition the matrices in line 5? If we were to create 12 new n=2 􏳨 n=2 matrices, we would spend ‚.n2/ time copying entries. In fact, we can partition the matrices without copying entries. The trick is to use index calculations. We identify a submatrix by a range of row indices and a range of column indices of the original matrix. We end up representing a submatrix a little differently from how we represent the original matrix, which is the subtlety we are glossing over. The advantage is that, since we can specify submatrices by index calculations, executing line 5 takes only ‚.1/ time (although we shall see that it makes no difference asymptotically to the overall running time whether we copy or partition in place).
Now, we derive a recurrence to characterize the running time of SQUARE- MATRIX-MULTIPLY-RECURSIVE. Let T .n/ be the time to multiply two n 􏳨 n matrices using this procedure. In the base case, when n D 1, we perform just the one scalar multiplication in line 4, and so
T .1/ D ‚.1/ : (4.15)
The recursive case occurs when n > 1. As discussed, partitioning the matrices in line 5 takes ‚.1/ time, using index calculations. In lines 6–9, we recursively call SQUARE-MATRIX-MULTIPLY-RECURSIVE a total of eight times. Because each recursive call multiplies two n=2 􏳨 n=2 matrices, thereby contributing T .n=2/ to the overall running time, the time taken by all eight recursive calls is 8T .n=2/. We also must account for the four matrix additions in lines 6–9. Each of these matrices contains n2=4 entries, and so each of the four matrix additions takes ‚.n2/ time. Since the number of matrix additions is a constant, the total time spent adding ma-

78 Chapter 4 Divide-and-Conquer
trices in lines 6–9 is ‚.n2/. (Again, we use index calculations to place the results of the matrix additions into the correct positions of matrix C, with an overhead of ‚.1/ time per entry.) The total time for the recursive case, therefore, is the sum of the partitioning time, the time for all the recursive calls, and the time to add the matrices resulting from the recursive calls:
T.n/ D ‚.1/ C 8T.n=2/ C ‚.n2/
D 8T .n=2/ C ‚.n2/ : (4.16)
Notice that if we implemented partitioning by copying matrices, which would cost ‚.n2/ time, the recurrence would not change, and hence the overall running time would increase by only a constant factor.
Combining equations (4.15) and (4.16) gives us the recurrence for the running time of SQUARE-MATRIX-MULTIPLY-RECURSIVE:
(
T.n/D ‚.1/ ifnD1; (4.17) 8T.n=2/C‚.n2/ ifn>1:
As we shall see from the master method in Section 4.5, recurrence (4.17) has the solution T .n/ D ‚.n3 /. Thus, this simple divide-and-conquer approach is no faster than the straightforward SQUARE-MATRIX-MULTIPLY procedure.
Before we continue on to examining Strassen’s algorithm, let us review where the components of equation (4.16) came from. Partitioning each n 􏳨 n matrix by index calculation takes ‚.1/ time, but we have two matrices to partition. Although you could say that partitioning the two matrices takes ‚.2/ time, the constant of 2 is subsumed by the ‚-notation. Adding two matrices, each with, say, k entries, takes ‚.k/ time. Since the matrices we add each have n2=4 entries, you could say that adding each pair takes ‚.n2=4/ time. Again, however, the ‚-notation subsumes the constant factor of 1=4, and we say that adding two n2=4 􏳨 n2=4 matrices takes ‚.n2/ time. We have four such matrix additions, and once again, instead of saying that they take ‚.4n2/ time, we say that they take ‚.n2/ time. (Of course, you might observe that we could say that the four matrix additions take ‚.4n2=4/ time, and that 4n2=4 D n2, but the point here is that ‚-notation subsumes constant factors, whatever they are.) Thus, we end up with two terms of ‚.n2/, which we can combine into one.
When we account for the eight recursive calls, however, we cannot just sub- sume the constant factor of 8. In other words, we must say that together they take 8T .n=2/ time, rather than just T .n=2/ time. You can get a feel for why by looking back at the recursion tree in Figure 2.5, for recurrence (2.1) (which is identical to recurrence (4.7)), with the recursive case T .n/ D 2T .n=2/ C ‚.n/. The factor of 2 determined how many children each tree node had, which in turn determined how many terms contributed to the sum at each level of the tree. If we were to ignore

4.2 Strassen’s algorithm for matrix multiplication 79
the factor of 8 in equation (4.16) or the factor of 2 in recurrence (4.1), the recursion tree would just be linear, rather than “bushy,” and each level would contribute only one term to the sum.
Bear in mind, therefore, that although asymptotic notation subsumes constant multiplicative factors, recursive notation such as T .n=2/ does not.
Strassen’s method
The key to Strassen’s method is to make the recursion tree slightly less bushy. That is, instead of performing eight recursive multiplications of n=2 􏳨 n=2 matrices, it performs only seven. The cost of eliminating one matrix multiplication will be several new additions of n=2 􏳨 n=2 matrices, but still only a constant number of additions. As before, the constant number of matrix additions will be subsumed by ‚-notation when we set up the recurrence equation to characterize the running time.
Strassen’s method is not at all obvious. (This might be the biggest understate- ment in this book.) It has four steps:
1. DividetheinputmatricesAandBandoutputmatrixCinton=2􏳨n=2subma- trices, as in equation (4.9). This step takes ‚.1/ time by index calculation, just as in SQUARE-MATRIX-MULTIPLY-RECURSIVE.
2. Create10matricesS1;S2;:::;S10,eachofwhichisn=2􏳨n=2andisthesum or difference of two matrices created in step 1. We can create all 10 matrices in ‚.n2/ time.
3. Using the submatrices created in step 1 and the 10 matrices created in step 2, recursively compute seven matrix products P1;P2;:::;P7. Each matrix Pi is n=2 􏳨 n=2.
4. Compute the desired submatrices C11;C12;C21;C22 of the result matrix C by adding and subtracting various combinations of the Pi matrices. We can com- pute all four submatrices in ‚.n2/ time.
We shall see the details of steps 2–4 in a moment, but we already have enough
information to set up a recurrence for the running time of Strassen’s method. Let us assume that once the matrix size n gets down to 1, we perform a simple scalar mul- tiplication, just as in line 4 of SQUARE-MATRIX-MULTIPLY-RECURSIVE. When n > 1, steps 1, 2, and 4 take a total of ‚.n2/ time, and step 3 requires us to per- form seven multiplications of n=2 􏳨 n=2 matrices. Hence, we obtain the following recurrence for the running time T .n/ of Strassen’s algorithm:
(
T.n/D ‚.1/ ifnD1; (4.18) 7T.n=2/C‚.n2/ ifn>1:

80 Chapter 4 Divide-and-Conquer
We have traded off one matrix multiplication for a constant number of matrix ad- ditions. Once we understand recurrences and their solutions, we shall see that this tradeoff actually leads to a lower asymptotic running time. By the master method in Section 4.5, recurrence (4.18) has the solution T .n/ D ‚.nlg 7 /.
We now proceed to describe the details. In step 2, we create the following 10 matrices:
S1 DB12􏳣B22;
S2 DA11CA12;
S3 DA21CA22;
S4 DB21􏳣B11;
S5 DA11CA22;
S6 DB11CB22;
S7 DA12􏳣A22;
S8 DB21CB22;
S9 DA11􏳣A21;
S10 DB11CB12:
Since we must add or subtract n=2 􏳨 n=2 matrices 10 times, this step does indeed take ‚.n2/ time.
In step 3, we recursively multiply n=2􏳨n=2 matrices seven times to compute the following n=2 􏳨 n=2 matrices, each of which is the sum or difference of products of A and B submatrices:
P1 D A11􏳵S1
P2 D S2􏳵B22
P3 D S3􏳵B11
P4 D A22􏳵S4
P5 DS5􏳵S6
P6 DS7􏳵S8
P7 DS9􏳵S10
D A11􏳵B12􏳣A11􏳵B22;
D A11􏳵B22CA12􏳵B22;
D A21􏳵B11CA22􏳵B11;
D A22􏳵B21􏳣A22􏳵B11;
D A11 􏳵B11 CA11 􏳵B22 CA22 􏳵B11 CA22 􏳵B22 ; D A12 􏳵B21 CA12 􏳵B22 􏳣A22 􏳵B21 􏳣A22 􏳵B22 ; D A11 􏳵B11 CA11 􏳵B12 􏳣A21 􏳵B11 􏳣A21 􏳵B12 :
Note that the only multiplications we need to perform are those in the middle col- umn of the above equations. The right-hand column just shows what these products equal in terms of the original submatrices created in step 1.
Step 4 adds and subtracts the Pi matrices created in step 3 to construct the four n=2 􏳨 n=2 submatrices of the product C . We start with
C11 DP5 CP4 􏳣P2 CP6 :

4.2 Strassen’s algorithm for matrix multiplication 81
Expanding out the right-hand side, with the expansion of each Pi on its own line and vertically aligning terms that cancel out, we see that C11 equals
A11 􏳵B11 CA11 􏳵B22 CA22 􏳵B11 CA22 􏳵B22 􏳣 A22 􏳵B11
􏳣 A11 􏳵B22
A11 􏳵B11
which corresponds to equation (4.11). Similarly, we set
C12 D P1 C P2 ;
and so C12 equals
A11 􏳵B12 􏳣 A11 􏳵B22
C A11 􏳵B22 C A12 􏳵B22
A11􏳵B12 CA12􏳵B22 ;
corresponding to equation (4.12). Setting
C21 D P3 C P4
makes C21 equal
A21 􏳵 B11 C A22 􏳵 B11
􏳣 A22 􏳵B11 C A22 􏳵B21
A21􏳵B11 CA22􏳵B21 ;
corresponding to equation (4.13). Finally, we set
C22 DP5 CP1 􏳣P3 􏳣P7 ;
so that C22 equals
A11 􏳵B11 CA11 􏳵B22 CA22 􏳵B11 CA22 􏳵B22 􏳣 A11 􏳵B22
CA22 􏳵B21
􏳣 A22 􏳵B22 􏳣 A22 􏳵B21 CA12 􏳵B22 CA12 􏳵B21
􏳣 A12 􏳵B22
CA12 􏳵B21 ;
􏳣A11 􏳵B11
􏳣 A22 􏳵B11
A22 􏳵B22
CA11 􏳵B12
􏳣 A21 􏳵B11
􏳣 A11 􏳵B12 CA21 􏳵B11 CA21 􏳵B12 CA21 􏳵B12 ;

82 Chapter 4 Divide-and-Conquer
which corresponds to equation (4.14). Altogether, we add or subtract n=2 􏳨 n=2 matrices eight times in step 4, and so this step indeed takes ‚.n2/ time.
Thus, we see that Strassen’s algorithm, comprising steps 1–4, produces the cor- rect matrix product and that recurrence (4.18) characterizes its running time. Since we shall see in Section 4.5 that this recurrence has the solution T.n/ D ‚.nlg7/, Strassen’s method is asymptotically faster than the straightforward SQUARE- MATRIX-MULTIPLY procedure. The notes at the end of this chapter discuss some of the practical aspects of Strassen’s algorithm.
Exercises
Note: Although Exercises 4.2-3, 4.2-4, and 4.2-5 are about variants on Strassen’s algorithm, you should read Section 4.5 before trying to solve them.
4.2-1
Use Strassen’s algorithm to compute the matrix product
􏳧 􏳹􏳧 􏳹
13 68 75 42
Show your work.
4.2-2
Write pseudocode for Strassen’s algorithm.
4.2-3
How would you modify Strassen’s algorithm to multiply n 􏳨 n matrices in which n is not an exact power of 2? Show that the resulting algorithm runs in time ‚.nlg 7/.
4.2-4
What is the largest k such that if you can multiply 3 􏳨 3 matrices using k multi- plications (not assuming commutativity of multiplication), then you can multiply n 􏳨 n matrices in time o.nlg 7/? What would the running time of this algorithm be?
4.2-5
V. Pan has discovered a way of multiplying 68 􏳨 68 matrices using 132,464 mul- tiplications, 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?
:

4.3 The substitution method for solving recurrences 83
4.2-6
How quickly can you multiply a kn􏳨n matrix by an n􏳨kn matrix, using Strassen’s algorithm as a subroutine? Answer the same question with the order of the input matrices reversed.
4.2-7
Show how to multiply the complex numbers a C bi and c C di using only three multiplications of real numbers. The algorithm should take a, b, c, and d as input and produce the real component ac 􏳣 bd and the imaginary component ad C bc separately.
4.3 The substitution method for solving recurrences
Now that we have seen how recurrences characterize the running times of divide- and-conquer algorithms, we will learn how to solve recurrences. We start in this section with the “substitution” method.
The substitution method for solving recurrences comprises two steps:
1. Guesstheformofthesolution.
2. Use mathematical induction to find the constants and show that the solution works.
We substitute the guessed solution for the function when applying the inductive hypothesis to smaller values; hence the name “substitution method.” This method is powerful, but we must be able to guess the form of the answer in order to apply it.
We can use the substitution method to establish either upper or lower bounds on a recurrence. As an example, let us determine an upper bound on the recurrence
T.n/ D 2T.bn=2c/ C n ; (4.19)
which is similar to recurrences (4.3) and (4.4). We guess that the solution is T .n/ D O.n lg n/. The substitution method requires us to prove that T .n/ 􏳥 c n lg n for an appropriate choice of the constant c > 0. We start by assuming that this bound holds for all positive m < n, in particular for m D bn=2c, yielding T .bn=2c/ 􏳥 c bn=2c lg.bn=2c/. Substituting into the recurrence yields T .n/ 􏳥 2.c bn=2c lg.bn=2c// C n 􏳥 cnlg.n=2/Cn D cnlgn􏳣cnlg2Cn D cnlgn􏳣cnCn 􏳥 cnlgn; 84 Chapter 4 Divide-and-Conquer where the last step holds as long as c 􏳦 1. Mathematical induction now requires us to show that our solution holds for the boundary conditions. Typically, we do so by showing that the boundary condi- tions are suitable as base cases for the inductive proof. For the recurrence (4.19), we must show that we can choose the constant c large enough so that the bound T .n/ 􏳥 cn lg n works for the boundary conditions as well. This requirement can sometimes lead to problems. Let us assume, for the sake of argument, that T .1/ D 1 is the sole boundary condition of the recurrence. Then for n D 1, the bound T.n/ 􏳥 cnlgn yields T.1/ 􏳥 c1lg1 D 0, which is at odds with T.1/ D 1. Consequently, the base case of our inductive proof fails to hold. We can overcome this obstacle in proving an inductive hypothesis for a spe- cific boundary condition with only a little more effort. In the recurrence (4.19), for example, we take advantage of asymptotic notation requiring us only to prove T.n/ 􏳥 cnlgn for n 􏳦 n0, where n0 is a constant that we get to choose. We keep the troublesome boundary condition T .1/ D 1, but remove it from consid- eration in the inductive proof. We do so by first observing that for n > 3, the recurrence does not depend directly on T .1/. Thus, we can replace T .1/ by T .2/ and T .3/ as the base cases in the inductive proof, letting n0 D 2. Note that we make a distinction between the base case of the recurrence (n D 1) and the base cases of the inductive proof (n D 2 and n D 3). With T .1/ D 1, we derive from the recurrence that T .2/ D 4 and T .3/ D 5. Now we can complete the inductive proof that T .n/ 􏳥 cn lg n for some constant c 􏳦 1 by choosing c large enough so that T.2/ 􏳥 c2lg2 and T.3/ 􏳥 c3lg3. As it turns out, any choice of c 􏳦 2 suffices for the base cases of n D 2 and n D 3 to hold. For most of the recurrences we shall examine, it is straightforward to extend boundary conditions to make the inductive assumption work for small n, and we shall not always explicitly work out the details.
Making a good guess
Unfortunately, there is no general way to guess the correct solutions to recurrences. Guessing a solution takes experience and, occasionally, creativity. Fortunately, though, you can use some heuristics to help you become a good guesser. You can also use recursion trees, which we shall see in Section 4.4, to generate good guesses.
If a recurrence is similar to one you have seen before, then guessing a similar solution is reasonable. As an example, consider the recurrence
T .n/ D 2T .bn=2c C 17/ C n ;
which looks difficult because of the added “17” in the argument to T on the right- hand side. Intuitively, however, this additional term cannot substantially affect the

4.3 The substitution method for solving recurrences 85
solution to the recurrence. When n is large, the difference between bn=2c and bn=2c C 17 is not that large: both cut n nearly evenly in half. Consequently, we make the guess that T .n/ D O.n lg n/, which you can verify as correct by using the substitution method (see Exercise 4.3-6).
Another way to make a good guess is to prove loose upper and lower bounds on the recurrence and then reduce the range of uncertainty. For example, we might start with a lower bound of T.n/ D 􏳫.n/ for the recurrence (4.19), since we have the term n in the recurrence, and we can prove an initial upper bound of T.n/ D O.n2/. Then, we can gradually lower the upper bound and raise the lower bound until we converge on the correct, asymptotically tight solution of T.n/ D ‚.nlgn/.
Subtleties
Sometimes you might correctly guess an asymptotic bound on the solution of a recurrence, but somehow the math fails to work out in the induction. The problem frequently turns out to be that the inductive assumption is not strong enough to prove the detailed bound. If you revise the guess by subtracting a lower-order term when you hit such a snag, the math often goes through.
Consider the recurrence
T.n/ D T.bn=2c/ C T.dn=2e/ C 1 :
We guess that the solution is T .n/ D O.n/, and we try to show that T .n/ 􏳥 cn for an appropriate choice of the constant c. Substituting our guess in the recurrence, we obtain
T.n/ 􏳥 cbn=2cCcdn=2eC1 D cnC1;
which does not imply T .n/ 􏳥 cn for any choice of c. We might be tempted to try a larger guess, say T.n/ D O.n2/. Although we can make this larger guess work, our original guess of T.n/ D O.n/ is correct. In order to show that it is correct, however, we must make a stronger inductive hypothesis.
Intuitively, our guess is nearly right: we are off only by the constant 1, a lower-order term. Nevertheless, mathematical induction does not work unless we prove the exact form of the inductive hypothesis. We overcome our difficulty by subtracting a lower-order term from our previous guess. Our new guess is T.n/􏳥cn􏳣d,whered 􏳦0isaconstant. Wenowhave
T.n/ 􏳥 .cbn=2c􏳣d/C.cdn=2e􏳣d/C1 D cn􏳣2dC1
􏳥 cn􏳣d;

86 Chapter 4 Divide-and-Conquer
as long as d 􏳦 1. As before, we must choose the constant c large enough to handle the boundary conditions.
You might find the idea of subtracting a lower-order term counterintuitive. Af- ter all, if the math does not work out, we should increase our guess, right? Not necessarily! When proving an upper bound by induction, it may actually be more difficult to prove that a weaker upper bound holds, because in order to prove the weaker bound, we must use the same weaker bound inductively in the proof. In our current example, when the recurrence has more than one recursive term, we get to subtract out the lower-order term of the proposed bound once per recursive term. In the above example, we subtracted out the constant d twice, once for the T .bn=2c/ term and once for the T .dn=2e/ term. We ended up with the inequality T .n/ 􏳥 cn 􏳣 2d C 1, and it was easy to find values of d to make cn 􏳣 2d C 1 be less than or equal to cn 􏳣 d.
Avoiding pitfalls
It is easy to err in the use of asymptotic notation. For example, in the recur- rence (4.19) we can falsely “prove” T.n/ D O.n/ by guessing T.n/ 􏳥 cn and then arguing
T.n/ 􏳥 2.c bn=2c/ C n 􏳥 cnCn
D O.n/ ; 􏳶 wrong!!
since c is a constant. The error is that we have not proved the exact form of the inductive hypothesis, that is, that T.n/ 􏳥 cn. We therefore will explicitly prove that T.n/ 􏳥 cn when we want to show that T.n/ D O.n/.
Changing variables
Sometimes, a little algebraic manipulation can make an unknown recurrence simi- lar to one you have seen before. As an example, consider the recurrence
􏳣􏳼p ̆􏳵
T .n/ D 2T n C lg n ;
which looks difficult. We can simplify this recurrence, though, with a change of variables. For convenience, we shall not worry about rounding off values, such as pn, to be integers. Renaming m D lg n yields
T.2m/ D 2T.2m=2/ C m :
We can now rename S.m/ D T.2m/ to produce the new recurrence S.m/ D 2S.m=2/ C m ;

4.3 The substitution method for solving recurrences 87
which is very much like recurrence (4.19). Indeed, this new recurrence has the same solution: S.m/ D O.m lg m/. Changing back from S.m/ to T .n/, we obtain
T .n/ D T .2m/ D S.m/ D O.m lg m/ D O.lg n lg lg n/ : Exercises
4.3-1
Show that the solution of T.n/ D T.n 􏳣 1/ C n is O.n2/. 4.3-2
Show that the solution of T .n/ D T .dn=2e/ C 1 is O.lg n/.
4.3-3
We saw that the solution of T .n/ D 2T .bn=2c/ C n is O.n lg n/. Show that the so- lution of this recurrence is also 􏳫.n lg n/. Conclude that the solution is ‚.n lg n/.
4.3-4
Show that by making a different inductive hypothesis, we can overcome the diffi- culty with the boundary condition T .1/ D 1 for recurrence (4.19) without adjusting the boundary conditions for the inductive proof.
4.3-5
Show that ‚.n lg n/ is the solution to the “exact” recurrence (4.3) for merge sort. 4.3-6
Show that the solution to T .n/ D 2T .bn=2c C 17/ C n is O.n lg n/.
4.3-7
Using the master method in Section 4.5, you can show that the solution to the recurrence T .n/ D 4T .n=3/ C n is T .n/ D ‚.nlog3 4 /. Show that a substitution proof with the assumption T.n/ 􏳥 cnlog3 4 fails. Then show how to subtract off a lower-order term to make a substitution proof work.
4.3-8
Using the master method in Section 4.5, you can show that the solution to the recurrence T .n/ D 4T .n=2/ C n2 is T .n/ D ‚.n2/. Show that a substitution proof with the assumption T.n/ 􏳥 cn2 fails. Then show how to subtract off a lower-order term to make a substitution proof work.

88 Chapter 4 Divide-and-Conquer
4.3-9
p
n/ C log n by making a change of variables.
Solve the recurrence T .n/ D 3T .
Your solution should be asymptotically tight. Do not worry about whether values are integral.
4.4 The recursion-tree method for solving recurrences
Although you can use the substitution method to provide a succinct proof that a solution to a recurrence is correct, you might have trouble coming up with a good guess. Drawing out a recursion tree, as we did in our analysis of the merge sort recurrence in Section 2.3.2, serves as a straightforward way to devise a good guess. In a recursion tree, each node represents the cost of a single subproblem somewhere in the set of recursive function invocations. We sum the costs within each level of the tree to obtain a set of per-level costs, and then we sum all the per-level costs to determine the total cost of all levels of the recursion.
A recursion tree is best used to generate a good guess, which you can then verify by the substitution method. When using a recursion tree to generate a good guess, you can often tolerate a small amount of “sloppiness,” since you will be verifying your guess later on. If you are very careful when drawing out a recursion tree and summing the costs, however, you can use a recursion tree as a direct proof of a solution to a recurrence. In this section, we will use recursion trees to generate good guesses, and in Section 4.6, we will use recursion trees directly to prove the theorem that forms the basis of the master method.
For example, let us see how a recursion tree would provide a good guess for the recurrence T .n/ D 3T .bn=4c/ C ‚.n2 /. We start by focusing on finding an upper bound for the solution. Because we know that floors and ceilings usually do not matter when solving recurrences (here’s an example of sloppiness that we can tolerate), we create a recursion tree for the recurrence T .n/ D 3T .n=4/ C cn2, having written out the implied constant coefficient c > 0.
Figure 4.5 shows how we derive the recursion tree for T .n/ D 3T .n=4/ C cn2. For convenience, we assume that n is an exact power of 4 (another example of tolerable sloppiness) so that all subproblem sizes are integers. Part (a) of the figure shows T .n/, which we expand in part (b) into an equivalent tree representing the recurrence. The cn2 term at the root represents the cost at the top level of recursion, and the three subtrees of the root represent the costs incurred by the subproblems of size n=4. Part (c) shows this process carried one step further by expanding each node with cost T .n=4/ from part (b). The cost for each of the three children of the root is c.n=4/2. We continue expanding each node in the tree by breaking it into its constituent parts as determined by the recurrence.

T.n/ cn2
cn2
4.4 The recursion-tree method for solving recurrences
89
T 􏳣n􏳵 T 􏳣n􏳵 T 􏳣n􏳵 c􏳣n􏳵2 444444
c􏳣n􏳵2 c􏳣n􏳵2
T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵 T􏳣n􏳵
(a)
(b)
(c)
16 16 16 16 16 16 16 16 16
cn2
cn2
c􏳣n􏳵2 c􏳣n􏳵2
4 4 4 16
c􏳣n􏳵2 3 cn2
log4 n
􏳣 n 􏳵2 c 16
􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 􏳣 n 􏳵2 c 16 c 16 c 16 c 16 c 16 c 16 c 16 c 16
􏳣 3 􏳵2 2 16 cn
‚.nlog43/
Total: O.n2/
T.1/ T.1/ T.1/ T.1/ T.1/ T.1/ T.1/ T.1/ T.1/ T.1/ … T.1/ T.1/ T.1/ nlog4 3
(d)
Figure 4.5 Constructing a recursion tree for the recurrence T .n/ D 3T .n=4/ C cn2. Part (a) shows T .n/, which progressively expands in (b)–(d) to form the recursion tree. The fully expanded tree in part (d) has height log4 n (it has log4 n C 1 levels).
…

90 Chapter 4 Divide-and-Conquer
Because subproblem sizes decrease by a factor of 4 each time we go down one level, we eventually must reach a boundary condition. How far from the root do we reach one? The subproblem size for a node at depth i is n=4i . Thus, the subproblem size hits n D 1 when n=4i D 1 or, equivalently, when i D log4 n. Thus, the tree has log4 n C 1 levels (at depths 0; 1; 2; : : : ; log4 n).
Next we determine the cost at each level of the tree. Each level has three times more nodes than the level above, and so the number of nodes at depth i is 3i . Because subproblem sizes reduce by a factor of 4 for each level we go down from the root, each node at depth i, for i D 0;1;2;:::;log4 n 􏳣 1, has a cost of c.n=4i/2. Multiplying, we see that the total cost over all nodes at depth i, for i D 0;1;2;:::;log4 n 􏳣 1, is 3ic.n=4i/2 D .3=16/icn2. The bottom level, at depth log4 n, has 3log4 n D nlog4 3 nodes, each contributing cost T .1/, for a total cost of nlog4 3 T .1/, which is ‚.nlog4 3 /, since we assume that T .1/ is a constant.
Now we add up the costs over all levels to determine the cost for the entire tree:
T.n/ D
D
D
cn2 C‚.nlog4 3/
(by equation (A.5)) :
3 􏳧 3 􏳹2 􏳧 3 􏳹log4 n􏳣1 cn2 C cn2 C cn2 C􏳵􏳵􏳵C
log n􏳣1􏳧 􏳹 43i
X
16 16 16
cn2 C ‚.nlog4 3/ .3=16/log4 n 􏳣 1 cn2 C ‚.nlog4 3/
16 .3=16/ 􏳣 1
iD0
This last formula looks somewhat messy until we realize that we can again take advantage of small amounts of sloppiness and use an infinite decreasing geometric series as an upper bound. Backing up one step and applying equation (A.6), we have
T.n/ D < D D D X log n􏳣1􏳧 􏳹 43i cn2 C ‚.nlog4 3/ cn2 C ‚.nlog4 3/ 16 X1 􏳧 3 􏳹 i 16 1 iD0 iD0 cn2 C ‚.nlog4 3/ 16cn2C‚.nlog43/ 1 􏳣 .3=16/ 13 O.n2/: Thus, we have derived a guess of T.n/ D O.n2/ for our original recurrence T .n/ D 3T .bn=4c/ C ‚.n2/. In this example, the coefficients of cn2 form a decreasing geometric series and, by equation (A.6), the sum of these coefficients 4.4 The recursion-tree method for solving recurrences 91 log3=2 n cn cn c􏳣n􏳵 c􏳣2n􏳵 cn 33 c􏳣n􏳵 c􏳣2n􏳵 c􏳣2n􏳵 c􏳣4n􏳵 cn 9999 Total: O.n lg n/ A recursion tree for the recurrence T .n/ D T .n=3/ C T .2n=3/ C cn. Figure 4.6 is bounded from above by the constant 16=13. Since the root’s contribution to the total cost is cn2, the root contributes a constant fraction of the total cost. In other words, the cost of the root dominates the total cost of the tree. In fact, if O.n2/ is indeed an upper bound for the recurrence (as we shall verify in a moment), then it must be a tight bound. Why? The first recursive call contributes a cost of ‚.n2/, and so 􏳫.n2/ must be a lower bound for the recurrence. Now we can use the substitution method to verify that our guess was cor- rect, that is, T.n/ D O.n2/ is an upper bound for the recurrence T.n/ D 3T.bn=4c/C‚.n2/. We want to show that T.n/ 􏳥 dn2 for some constant d > 0. Using the same constant c > 0 as before, we have
3T .bn=4c/ C cn2 3d bn=4c2 C cn2 3d.n=4/2 C cn2
3dn2Ccn2 16
In another, more intricate, example, Figure 4.6 shows the recursion tree for
T.n/ D T.n=3/ C T.2n=3/ C O.n/ :
(Again, we omit floor and ceiling functions for simplicity.) As before, we let c represent the constant factor in the O.n/ term. When we add the values across the levels of the recursion tree shown in the figure, we get a value of cn for every level.
T.n/ 􏳥 􏳥 􏳥
D
dn2;
􏳥
where the last step holds as long as d 􏳦 .16=13/c.
…
…

92 Chapter 4 Divide-and-Conquer
The longest simple path from the root to a leaf is n ! .2=3/n ! .2=3/2n ! 􏳵􏳵􏳵 ! 1. Since .2=3/kn D 1 when k D log3=2 n, the height of the tree is log3=2 n.
Intuitively, we expect the solution to the recurrence to be at most the number of levels times the cost of each level, or O.cn log3=2 n/ D O.n lg n/. Figure 4.6 shows only the top levels of the recursion tree, however, and not every level in the tree contributes a cost of cn. Consider the cost of the leaves. If this recursion tree were a complete binary tree of height log3=2 n, there would be 2log3=2 n D nlog3=2 2 leaves. Since the cost of each leaf is a constant, the total cost of all leaves would then be ‚.nlog3=2 2/ which, since log3=2 2 is a constant strictly greater than 1, is !.nlgn/. This recursion tree is not a complete binary tree, however, and so it has fewer than nlog3=2 2 leaves. Moreover, as we go down from the root, more and more internal nodes are absent. Consequently, levels toward the bottom of the recursion tree contribute less than cn to the total cost. We could work out an accu- rate accounting of all costs, but remember that we are just trying to come up with a guess to use in the substitution method. Let us tolerate the sloppiness and attempt to show that a guess of O.n lg n/ for the upper bound is correct.
Indeed, we can use the substitution method to verify that O.n lg n/ is an upper bound for the solution to the recurrence. We show that T .n/ 􏳥 d n lg n, where d is a suitable positive constant. We have
T.n/ 􏳥 􏳥 D
D D D 􏳥
accounting of costs in the recursion tree.
Exercises
4.4-1
Use a recursion tree to determine a good asymptotic upper bound on the recurrence T .n/ D 3T .bn=2c/ C n. Use the substitution method to verify your answer.
4.4-2
Use a recursion tree to determine a good asymptotic upper bound on the recurrence T .n/ D T .n=2/ C n2. Use the substitution method to verify your answer.
T.n=3/CT.2n=3/Ccn
d.n=3/ lg.n=3/ C d.2n=3/ lg.2n=3/ C cn .d.n=3/ lg n 􏳣 d.n=3/ lg 3/
C .d.2n=3/ lg n 􏳣 d.2n=3/ lg.3=2// C cn dnlgn􏳣d..n=3/lg3C.2n=3/lg.3=2//Ccn dnlgn􏳣d..n=3/lg3C.2n=3/lg3􏳣.2n=3/lg2/Ccn dnlgn􏳣dn.lg3􏳣2=3/Ccn
dnlgn;
as long as d 􏳦 c=.lg 3 􏳣 .2=3//. Thus, we did not need to perform a more accurate

4.5 The master method for solving recurrences 93
4.4-3
Use a recursion tree to determine a good asymptotic upper bound on the recurrence T .n/ D 4T .n=2 C 2/ C n. Use the substitution method to verify your answer.
4.4-4
Use a recursion tree to determine a good asymptotic upper bound on the recurrence T .n/ D 2T .n 􏳣 1/ C 1. Use the substitution method to verify your answer.
4.4-5
Use a recursion tree to determine a good asymptotic upper bound on the recurrence T.n/ D T.n􏳣1/CT.n=2/Cn. Use the substitution method to verify your answer.
4.4-6
Argue that the solution to the recurrence T .n/ D T .n=3/CT .2n=3/Ccn, where c is a constant, is 􏳫.n lg n/ by appealing to a recursion tree.
4.4-7
Draw the recursion tree for T .n/ D 4T .bn=2c/ C cn, where c is a constant, and provide a tight asymptotic bound on its solution. Verify your bound by the substi- tution method.
4.4-8
Use a recursion tree to give an asymptotically tight solution to the recurrence T .n/ D T .n 􏳣 a/ C T .a/ C cn, where a 􏳦 1 and c > 0 are constants.
4.4-9
Use a recursion tree to give an asymptotically tight solution to the recurrence T.n/ D T. ̨n/CT..1􏳣 ̨/n/Ccn, where ̨ is a constant in the range 0 < ̨ < 1 and c > 0 is also a constant.
4.5 The master method for solving recurrences
The master method provides a “cookbook” method for solving recurrences of the form
T .n/ D aT .n=b/ C f .n/ ; (4.20)
where a 􏳦 1 and b > 1 are constants and f .n/ is an asymptotically positive function. To use the master method, you will need to memorize three cases, but then you will be able to solve many recurrences quite easily, often without pencil and paper.

94 Chapter 4 Divide-and-Conquer
The recurrence (4.20) describes the running time of an algorithm that divides a problem of size n into a subproblems, each of size n=b, where a and b are positive constants. The a subproblems are solved recursively, each in time T.n=b/. The function f .n/ encompasses the cost of dividing the problem and combining the results of the subproblems. For example, the recurrence arising from Strassen’s algorithm has a D 7, b D 2, and f.n/ D ‚.n2/.
As a matter of technical correctness, the recurrence is not actually well defined, because n=b might not be an integer. Replacing each of the a terms T .n=b/ with either T .bn=bc/ or T .dn=be/ will not affect the asymptotic behavior of the recur- rence, however. (We will prove this assertion in the next section.) We normally find it convenient, therefore, to omit the floor and ceiling functions when writing divide-and-conquer recurrences of this form.
The master theorem
The master method depends on the following theorem.
Theorem 4.1 (Master theorem)
Let a 􏳦 1 and b > 1 be constants, let f.n/ be a function, and let T.n/ be defined on the nonnegative integers by the recurrence
T .n/ D aT .n=b/ C f .n/ ;
where we interpret n=b to mean either bn=bc or dn=be. Then T .n/ has the follow-
ing asymptotic bounds:
1. If f.n/ D O.nlogb a􏳣􏳮/ for some constant 􏳮 > 0, then T.n/ D ‚.nlogb a/.
2. If f.n/ D ‚.nlogb a/, then T.n/ D ‚.nlogb a lgn/.
3. If f.n/ D 􏳫.nlogb aC􏳮/ for some constant 􏳮 > 0, and if af.n=b/ 􏳥 cf.n/ for some constant c < 1 and all sufficiently large n, then T .n/ D ‚.f .n//. Before applying the master theorem to some examples, let’s spend a moment trying to understand what it says. In each of the three cases, we compare the function f .n/ with the function nlogb a . Intuitively, the larger of the two functions determines the solution to the recurrence. If, as in case 1, the function nlogb a is the larger, then the solution is T.n/ D ‚.nlogb a/. If, as in case 3, the function f.n/ is the larger, then the solution is T .n/ D ‚.f .n//. If, as in case 2, the two func- tions are the same size, we multiply by a logarithmic factor, and the solution is T.n/ D ‚.nlogb a lgn/ D ‚.f.n/lgn/. Beyond this intuition, you need to be aware of some technicalities. In the first case, not only must f.n/ be smaller than nlogb a, it must be polynomially smaller. 4.5 The master method for solving recurrences 95 That is, f .n/ must be asymptotically smaller than nlogb a by a factor of n􏳮 for some constant 􏳮 > 0. In the third case, not only must f .n/ be larger than nlogb a , it also must be polynomially larger and in addition satisfy the “regularity” condition that af .n=b/ 􏳥 cf .n/. This condition is satisfied by most of the polynomially bounded functions that we shall encounter.
Note that the three cases do not cover all the possibilities for f .n/. There is a gap between cases 1 and 2 when f .n/ is smaller than nlogb a but not polynomi- ally smaller. Similarly, there is a gap between cases 2 and 3 when f .n/ is larger than nlogb a but not polynomially larger. If the function f .n/ falls into one of these gaps, or if the regularity condition in case 3 fails to hold, you cannot use the master method to solve the recurrence.
Using the master method
To use the master method, we simply determine which case (if any) of the master theorem applies and write down the answer.
As a first example, consider
T .n/ D 9T .n=3/ C n :
For this recurrence, we have a D 9, b D 3, f.n/ D n, and thus we have that nlogb a D nlog3 9 D ‚.n2). Since f.n/ D O.nlog3 9􏳣􏳮/, where 􏳮 D 1, we can apply case 1 of the master theorem and conclude that the solution is T .n/ D ‚.n2/.
Now consider
T .n/ D T .2n=3/ C 1;
inwhichaD1,bD3=2,f.n/D1,andnlogba Dnlog3=21 Dn0 D1. Case2 applies, since f.n/ D ‚.nlogb a/ D ‚.1/, and thus the solution to the recurrence is T .n/ D ‚.lg n/.
For the recurrence
T .n/ D 3T .n=4/ C n lg n ;
we have a D 3, b D 4, f.n/ D nlgn, and nlogba D nlog43 D O.n0:793/. Since f .n/ D 􏳫.nlog4 3C􏳮 /, where 􏳮 􏳬 0:2, case 3 applies if we can show that the regularity condition holds for f.n/. For sufficiently large n, we have that af .n=b/ D 3.n=4/ lg.n=4/ 􏳥 .3=4/n lg n D cf .n/ for c D 3=4. Consequently, by case 3, the solution to the recurrence is T .n/ D ‚.n lg n/.
The master method does not apply to the recurrence
T .n/ D 2T .n=2/ C n lg n ;
even though it appears to have the proper form: a D 2, b D 2, f.n/ D nlgn, and nlogb a D n. You might mistakenly think that case 3 should apply, since

96 Chapter 4 Divide-and-Conquer
f .n/ D n lg n is asymptotically larger than nlogb a D n. The problem is that it is not polynomially larger. The ratio f .n/=nlogb a D .n lg n/=n D lg n is asymp- totically less than n􏳮 for any positive constant 􏳮. Consequently, the recurrence falls into the gap between case 2 and case 3. (See Exercise 4.6-2 for a solution.)
Let’s use the master method to solve the recurrences we saw in Sections 4.1 and 4.2. Recurrence (4.7),
T.n/ D 2T.n=2/ C ‚.n/ ;
characterizes the running times of the divide-and-conquer algorithm for both the maximum-subarray problem and merge sort. (As is our practice, we omit stating the base case in the recurrence.) Here, we have a D 2, b D 2, f .n/ D ‚.n/, and thus we have that nlogb a D nlog2 2 D n. Case 2 applies, since f .n/ D ‚.n/, and so we have the solution T .n/ D ‚.n lg n/.
Recurrence (4.17),
T.n/ D 8T.n=2/ C ‚.n2/ ;
describes the running time of the first divide-and-conquer algorithm that we saw for matrix multiplication. Now we have a D 8, b D 2, and f.n/ D ‚.n2/, and so nlogb a D nlog2 8 D n3. Since n3 is polynomially larger than f.n/ (that is, f.n/ D O.n3􏳣􏳮/ for 􏳮 D 1), case 1 applies, and T.n/ D ‚.n3/.
Finally, consider recurrence (4.18),
T.n/ D 7T.n=2/ C ‚.n2/ ;
which describes the running time of Strassen’s algorithm. Here, we have a D 7, b D 2, f.n/ D ‚.n2/, and thus nlogb a D nlog2 7. Rewriting log2 7 as lg7 and recalling that 2:80 < lg7 < 2:81, we see that f.n/ D O.nlg7􏳣􏳮/ for 􏳮 D 0:8. Again, case 1 applies, and we have the solution T .n/ D ‚.nlg 7 /. Exercises 4.5-1 Use the master method to give tight asymptotic bounds for the following recur- rences. a. T.n/ D 2T.n=4/ C 1. b. T.n/ D 2T.n=4/ C pn. c. T.n/ D 2T.n=4/ C n. d. T.n/ D 2T.n=4/ C n2. ? 4.6 4.5-2 Professor Caesar wishes to develop a matrix-multiplication algorithm that is asymptotically faster than Strassen’s algorithm. His algorithm will use the divide- and-conquer method, dividing each matrix into pieces of size n=4 􏳨 n=4, and the divide and combine steps together will take ‚.n2/ time. He needs to determine how many subproblems his algorithm has to create in order to beat Strassen’s algo- rithm. If his algorithm creates a subproblems, then the recurrence for the running time T .n/ becomes T .n/ D aT .n=4/ C ‚.n2/. What is the largest integer value of a for which Professor Caesar’s algorithm would be asymptotically faster than Strassen’s algorithm? 4.5-3 Use the master method to show that the solution to the binary-search recurrence T .n/ D T .n=2/ C ‚.1/ is T .n/ D ‚.lg n/. (See Exercise 2.3-5 for a description of binary search.) 4.5-4 Can the master method be applied to the recurrence T .n/ D 4T .n=2/ C n2 lg n? Why or why not? Give an asymptotic upper bound for this recurrence. 4.5-5 ? Consider the regularity condition af .n=b/ 􏳥 cf .n/ for some constant c < 1, which is part of case 3 of the master theorem. Give an example of constants a 􏳦 1 and b > 1 and a function f .n/ that satisfies all the conditions in case 3 of the master theorem except the regularity condition.
Proof of the master theorem
This section contains a proof of the master theorem (Theorem 4.1). You do not need to understand the proof in order to apply the master theorem.
The proof appears in two parts. The first part analyzes the master recur- rence (4.20), under the simplifying assumption that T.n/ is defined only on ex- act powers of b > 1, that is, for n D 1;b;b2;:::. This part gives all the intuition needed to understand why the master theorem is true. The second part shows how to extend the analysis to all positive integers n; it applies mathematical technique to the problem of handling floors and ceilings.
In this section, we shall sometimes abuse our asymptotic notation slightly by using it to describe the behavior of functions that are defined only over exact powers of b. Recall that the definitions of asymptotic notations require that
4.6 Proof of the master theorem 97

98 Chapter 4 Divide-and-Conquer
bounds be proved for all sufficiently large numbers, not just those that are pow- ers of b. Since we could make new asymptotic notations that apply only to the set fbi WiD0;1;2;:::g,insteadoftothenonnegativenumbers,thisabuseisminor.
Nevertheless, we must always be on guard when we use asymptotic notation over a limited domain lest we draw improper conclusions. For example, proving that T .n/ D O.n/ when n is an exact power of 2 does not guarantee that T .n/ D O.n/.
The function T .n/ could be defined as (
n if n D 1;2;4;8;::: ; n2 otherwise ;
in which case the best upper bound that applies to all values of n is T .n/ D O.n2/. Because of this sort of drastic consequence, we shall never use asymptotic notation over a limited domain without making it absolutely clear from the context that we are doing so.
4.6.1 The proof for exact powers
The first part of the proof of the master theorem analyzes the recurrence (4.20)
T .n/ D aT .n=b/ C f .n/ ;
for the master method, under the assumption that n is an exact power of b > 1, where b need not be an integer. We break the analysis into three lemmas. The first reduces the problem of solving the master recurrence to the problem of evaluating an expression that contains a summation. The second determines bounds on this summation. The third lemma puts the first two together to prove a version of the master theorem for the case in which n is an exact power of b.
Lemma 4.2
Let a 􏳦 1 and b > 1 be constants, and let f .n/ be a nonnegative function defined
T .n/ D
on exact powers of b. Define T .n/ on exact powers of b by the recurrence (
‚.1/ if n D 1 ; aT.n=b/Cf.n/ ifnDbi ;
T .n/ D
where i is a positive integer. Then
T .n/ D ‚.nlogb a/ C
X
aj f .n=bj / :
log n􏳣1 b
jD0
Proof We use the recursion tree in Figure 4.7. The root of the tree has cost f .n/, and it has a children, each with cost f .n=b/. (It is convenient to think of a as being
(4.21)

4.6 Proof of the master theorem
99
f .n=b/ f .n=b/ aaa
f .n/
f .n/
af .n=b/
a
…
f .n=b/
logb n
22…222…222…222
f.n=b /f.n=b / f.n=b / f.n=b /f.n=b / f.n=b / f.n=b /f.n=b / f.n=b /
aaaaaaaaa
………………………
a f.n=b /
‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ nlogb a
… ‚.1/ ‚.1/ ‚.1/
Total: ‚.nlogb a/C
‚.nlogb a/
ajf.n=bj/
The recursion tree generated by T .n/ D aT .n=b/ C f .n/. The tree is a complete a-ary tree with nlogb a leaves and height logb n. The cost of the nodes at each depth is shown at the right, and their sum is given in equation (4.21).
an integer, especially when visualizing the recursion tree, but the mathematics does not require it.) Each of these children has a children, making a2 nodes at depth 2, and each of the a children has cost f.n=b2/. In general, there are aj nodes at depth j, and each has cost f.n=bj/. The cost of each leaf is T.1/ D ‚.1/, and each leaf is at depth logb n, since n=blogb n D 1. There are alogb n D nlogb a leaves in the tree.
We can obtain equation (4.21) by summing the costs of the nodes at each depth in the tree, as shown in the figure. The cost for all internal nodes at depth j is aj f .n=bj /, and so the total cost of all internal nodes is
Figure 4.7
log n􏳣1 b
X
aj f .n=bj / : jD0
In the underlying divide-and-conquer algorithm, this sum represents the costs of dividing problems into subproblems and then recombining the subproblems. The
log n􏳣1 b
X
jD0
…

100 Chapter 4 Divide-and-Conquer
cost of all the leaves, which is the cost of doing all nlogb a subproblems of size 1, is ‚.nlogb a/.
In terms of the recursion tree, the three cases of the master theorem correspond to cases in which the total cost of the tree is (1) dominated by the costs in the leaves, (2) evenly distributed among the levels of the tree, or (3) dominated by the cost of the root.
The summation in equation (4.21) describes the cost of the dividing and com- bining steps in the underlying divide-and-conquer algorithm. The next lemma pro- vides asymptotic bounds on the summation’s growth.
Lemma 4.3
Let a 􏳦 1 and b > 1 be constants, and let f .n/ be a nonnegative function defined on exact powers of b. A function g.n/ defined over exact powers of b by
(4.22)
g.n/ D
log n􏳣1 b
X
aj f .n=bj /
has the following asymptotic bounds for exact powers of b:
1. If f.n/ D O.nlogb a􏳣􏳮/ for some constant 􏳮 > 0, then g.n/ D O.nlogb a/.
2. If f .n/ D ‚.nlogb a/, then g.n/ D ‚.nlogb a lg n/.
jD0
3. If af .n=b/ 􏳥 cf .n/ for some constant c < 1 and for all sufficiently large n, then g.n/ D ‚.f .n//. Proof For case 1, we have f .n/ D O.nlogb a􏳣􏳮 /, which implies that f .n=bj / D O..n=bj /logb a􏳣􏳮 /. Substituting into equation (4.22) yields ! g.n/DO We bound the summation within the O-notation by factoring out terms and simpli- fying, which leaves an increasing geometric series: logb n􏳣1 􏳰 􏳳 X j n logba􏳣􏳮 a bj : (4.23) jD0 logb n􏳣1 􏳰 􏳳 X j n logba􏳣􏳮 log a􏳣􏳮 X a Dnb bj jD0 jD0 jD0 􏳧b􏳮logb n 􏳣1􏳹 b􏳮 􏳣1 logb n􏳣1 􏳧 􏳮 􏳹j ab D nlogb a􏳣􏳮 D nlogb a􏳣􏳮 X log n􏳣1 b blogb a .b􏳮/j 4.6 Proof of the master theorem 101 logb n􏳣1 􏳰 􏳳 X j n logba a bj : (4.24) jD0 a Dnb bj jD0 jD0 􏳧n􏳮 􏳣1􏳹 b􏳮 􏳣1 D nlogba􏳣􏳮 Since b and 􏳮 are constants, we can rewrite the last expression as nlogb a􏳣􏳮O.n􏳮/ D O.nlogb a/. Substituting this expression for the summation in equation (4.23) yields g.n/ D O.nlogb a/ ; thereby proving case 1. Because case 2 assumes that f .n/ D ‚.nlogb a/, we have that f .n=bj / D ‚..n=bj /logb a/. Substituting into equation (4.22) yields ! g.n/D‚ We bound the summation within the ‚-notation as in case 1, but this time we do not obtain a geometric series. Instead, we discover that every term of the summation is the same: logb n􏳣1 􏳰 􏳳 logb n􏳣1 􏳰 􏳳 X j n logba log a X a j : blogb a Substituting this expression for the summation in equation (4.24) yields g.n/ D ‚.nlogb a logb n/ D ‚.nlogb a lg n/ ; proving case 2. We prove case 3 similarly. Since f .n/ appears in the definition (4.22) of g.n/ and all terms of g.n/ are nonnegative, we can conclude that g.n/ D 􏳫.f .n// for exact powers of b. We assume in the statement of the lemma that af .n=b/ 􏳥 cf .n/ for some constant c < 1 and all sufficiently large n. We rewrite this assumption as f .n=b/ 􏳥 .c=a/f .n/ and iterate j times, yielding f .n=bj / 􏳥 .c=a/j f .n/ or, equivalently, aj f .n=bj / 􏳥 cj f .n/, where we assume that the values we iterate on are sufficiently large. Since the last, and smallest, such value is n=bj􏳣1, it is enough to assume that n=bj 􏳣1 is sufficiently large. Substituting into equation (4.22) and simplifying yields a geometric series, but unlike the series in case 1, this one has decreasing terms. We use an O.1/ term to D nlogba X 1 jD0 D nlogb a logb n: log n􏳣1 b 102 Chapter 4 Divide-and-Conquer capture the terms that are not covered by our assumption that n is sufficiently large: g.n/ D 􏳥 ajf.n=bj/ cjf.n/CO.1/ jD0 X1 log n􏳣1 b 􏳥 f.n/ D cj CO.1/ 􏳧1􏳹 X jD0 log n􏳣1 b X jD0 f.n/ 1􏳣c CO.1/ O.f.n//; D since c is a constant. Thus, we can conclude that g.n/ D ‚.f .n// for exact powers of b. With case 3 proved, the proof of the lemma is complete. We can now prove a version of the master theorem for the case in which n is an exact power of b. Lemma 4.4 Let a 􏳦 1 and b > 1 be constants, and let f .n/ be a nonnegative function defined on exact powers of b. Define T .n/ on exact powers of b by the recurrence
(
‚.1/ if n D 1 ; aT.n=b/Cf.n/ ifnDbi ;
T .n/ D
where i is a positive integer. Then T .n/ has the following asymptotic bounds for
exact powers of b:
1. If f.n/ D O.nlogb a􏳣􏳮/ for some constant 􏳮 > 0, then T.n/ D ‚.nlogb a/.
2. If f.n/ D ‚.nlogb a/, then T.n/ D ‚.nlogb a lgn/.
3. If f.n/ D 􏳫.nlogb aC􏳮/ for some constant 􏳮 > 0, and if af.n=b/ 􏳥 cf.n/ for some constant c < 1 and all sufficiently large n, then T .n/ D ‚.f .n//. Proof We use the bounds in Lemma 4.3 to evaluate the summation (4.21) from Lemma 4.2. For case 1, we have T.n/ D ‚.nlogb a/ C O.nlogb a/ D ‚.nlogba/; 4.6 Proof of the master theorem 103 and for case 2, T .n/ D For case 3, ‚.nlogb a/ C ‚.nlogb a lg n/ D ‚.nlogb a lg n/ : ‚.nlogb a/ C ‚.f .n// D ‚.f .n// ; T .n/ D because f .n/ D 􏳫.nlogb aC􏳮 /. 4.6.2 Floors and ceilings To complete the proof of the master theorem, we must now extend our analysis to the situation in which floors and ceilings appear in the master recurrence, so that the recurrence is defined for all integers, not for just exact powers of b. Obtaining a lower bound on T .n/ D aT .dn=be/ C f .n/ (4.25) and an upper bound on T .n/ D aT .bn=bc/ C f .n/ (4.26) is routine, since we can push through the bound dn=be 􏳦 n=b in the first case to yield the desired result, and we can push through the bound bn=bc 􏳥 n=b in the second case. We use much the same technique to lower-bound the recurrence (4.26) as to upper-bound the recurrence (4.25), and so we shall present only this latter bound. We modify the recursion tree of Figure 4.7 to produce the recursion tree in Fig- ure 4.8. As we go down in the recursion tree, we obtain a sequence of recursive invocations on the arguments n; dn=be ; ddn=be=be ; dddn=be=be=be ; : Let us denote the j th element in the sequence by nj , where ( njD n ifjD0; dnj􏳣1=be ifj>0:
(4.27)

104
Chapter 4 Divide-and-Conquer
f .n/
f.n1/ f.n1/ … f.n1/ aaa
f.n2/ … f.n2/ f.n2/ f.n2/ … f.n2/ f.n2/ f.n2/ … f.n2/
f .n/
af.n1/
a2f.n2/
‚.nlogb a/
a
blogb nc
f.n2/
aaaaaaaaa
………………………
‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.1/ ‚.nlogb a/
… ‚.1/ ‚.1/ ‚.1/ Total: ‚.nlogb a/C
The recursion tree generated by T .n/ D aT .dn=be/Cf .n/. The recursive argument nj is given by equation (4.27).
Our first goal is to determine the depth k such that nk is a constant. Using the inequality dxe 􏳥 x C 1, we obtain
Figure 4.8
n0 􏳥 n;
n1 􏳥 nC1;
blog nc􏳣1 b
X
ajf.nj/
jD0
b
n2 􏳥 nC1C1;
b2 b
n3 􏳥 nC1C1C1;
b3 b2 b :
In general, we have
…

4.6 Proof of the master theorem 105
j􏳣1
nj 􏳥 nCX1
bj
n X1 1
bi bCb=.b􏳣1/, where c < 1 is a constant, then it follows that aj f .nj / 􏳥 cj f .n/. Therefore, we can evaluate the sum in equation (4.29) just as in Lemma 4.3. For case 2, we have f .n/ D ‚.nlogb a /. If we can show that f .nj / D O.nlogb a=aj / D O..n=bj /logb a/, then the proof for case 2 of Lemma 4.3 will go through. Observe that j 􏳥 blogb nc implies bj =n 􏳥 1. The bound f .n/ D O.nlogb a/ implies that there exists a constant c > 0 such that for all sufficiently large nj ,
(4.28)

106 Chapter 4
Divide-and-Conquer
f.nj/
􏳧n b 􏳹logba 􏳥 c bj Cb􏳣1
􏳧n􏳧 bj b 􏳹􏳹logba
Dcbj 1Cn􏳵b􏳣1 􏳧nlogb a 􏳹􏳧 􏳧bj b
Dc aj 1Cn􏳵b􏳣1 􏳧nlogba􏳹􏳧 b 􏳹logba
􏳥caj 1Cb􏳣1 􏳧nlogb a 􏳹
DOaj ;
􏳹􏳹logb a
since c.1 C b=.b 􏳣 1//logb a is a constant. Thus, we have proved case 2. The proof of case 1 is almost identical. The key is to prove the bound f .nj / D O.nlogb a􏳣􏳮 /, which is similar to the corresponding proof of case 2, though the algebra is more intricate.
We have now proved the upper bounds in the master theorem for all integers n. The proof of the lower bounds is similar.
Exercises
4.6-1 ?
Giveasimpleandexactexpressionfornj inequation(4.27)forthecaseinwhichb is a positive integer instead of an arbitrary real number.
4.6-2 ?
Show that if f .n/ D ‚.nlogb a lgk n/, where k 􏳦 0, then the master recurrence has solution T.n/ D ‚.nlogb a lgkC1 n/. For simplicity, confine your analysis to exact powers of b.
4.6-3 ?
Show that case 3 of the master theorem is overstated, in the sense that the regularity condition af .n=b/ 􏳥 cf .n/ for some constant c < 1 implies that there exists a constant 􏳮 > 0 such that f .n/ D 􏳫.nlogb aC􏳮 /.

Problems
Problems for Chapter 4 107
4-1 Recurrence examples
Give asymptotic upper and lower bounds for T .n/ in each of the following recur- rences. Assume that T.n/ is constant for n 􏳥 2. Make your bounds as tight as possible, and justify your answers.
a. T.n/D2T.n=2/Cn4.
b. T.n/DT.7n=10/Cn.
c. T.n/D16T.n=4/Cn2.
d. T.n/ D 7T.n=3/ C n2.
e. T.n/D7T.n=2/Cn2.
f. T.n/ D 2T.n=4/ C pn.
g. T.n/DT.n􏳣2/Cn2.
4-2 Parameter-passing costs
Throughout this book, we assume that parameter passing during procedure calls takes constant time, even if an N -element array is being passed. This assumption is valid in most systems because a pointer to the array is passed, not the array itself. This problem examines the implications of three parameter-passing strategies:
1. An array is passed by pointer. Time D ‚.1/.
2. An array is passed by copying. Time D ‚.N /, where N is the size of the array.
3. An array is passed by copying only the subrange that might be accessed by the called procedure. Time D ‚.q 􏳣 p C 1/ if the subarray AŒp : : q􏳩 is passed.
a. Considertherecursivebinarysearchalgorithmforfindinganumberinasorted array (see Exercise 2.3-5). Give recurrences for the worst-case running times of binary search when arrays are passed using each of the three methods above, and give good upper bounds on the solutions of the recurrences. Let N be the size of the original problem and n be the size of a subproblem.
b. Redo part (a) for the MERGE-SORT algorithm from Section 2.3.1.

108 Chapter 4 Divide-and-Conquer
4-3 More recurrence examples
Give asymptotic upper and lower bounds for T .n/ in each of the following recur- rences. Assume that T .n/ is constant for sufficiently small n. Make your bounds as tight as possible, and justify your answers.
a. T.n/D4T.n=3/Cnlgn.
b. T.n/D3T.n=3/Cn=lgn.
c. T.n/D4T.n=2/Cn2pn.
d. T.n/ D 3T.n=3 􏳣 2/ C n=2.
e. T.n/D2T.n=2/Cn=lgn.
f. T.n/ D T.n=2/ C T.n=4/ C T.n=8/ C n.
g. T.n/DT.n􏳣1/C1=n.
h. T.n/DT.n􏳣1/Clgn.
i. T.n/DT.n􏳣2/C1=lgn.
j. T.n/ D pnT.pn/ C n.
4-4 Fibonacci numbers
This problem develops properties of the Fibonacci numbers, which are defined by recurrence (3.22). We shall use the technique of generating functions to solve the Fibonacci recurrence. Define the generating function (or formal power se- ries) F as
where Fi is the ith Fibonacci number.
a. ShowthatF. ́/D ́C ́F. ́/C ́2F. ́/.
F. ́/ D
X1 iD0
Fi ́i
D 0C ́C ́2 C2 ́3 C3 ́4 C5 ́5 C8 ́6 C13 ́7 C21 ́8 C􏳵􏳵􏳵 ;

Problems for Chapter 4
109
b. Show that F. ́/ D
́
1􏳣 ́􏳣 ́2 ́
D
D p5 1􏳣􏳭 ́􏳣1􏳣􏳭y ́ ;
.1 􏳣 􏳭 ́/.1 􏳣 􏳭y ́/ 1􏳧1 1􏳹
p
􏳭D1C 5D1:61803:::
2
p
􏳭yD1􏳣 5D􏳣0:61803::::
2
c. Show that
where
and
X1 1 i yi i p .􏳭 􏳣 􏳭 / ́ :
F . ́/ D
d. Usepart(c)toprovethatF D􏳭i=p5fori>0,roundedtothenearestinteger.
5
(Hint: Observe that 􏳭 < 1.) 4-5 Chip testing Professor Diogenes has n supposedly identical integrated-circuit chips that in prin- ciple are capable of testing each other. The professor’s test jig accommodates two chips at a time. When the jig is loaded, each chip tests the other and reports whether it is good or bad. A good chip always reports accurately whether the other chip is good or bad, but the professor cannot trust the answer of a bad chip. Thus, the four possible outcomes of a test are as follows: Chip A says B is good B is good B is bad B is bad Chip B says A is good Aisbad A is good Aisbad Conclusion both are good, or both are bad at least one is bad at least one is bad at least one is bad iD0 ˇyˇ i a. Showthatifmorethann=2chipsarebad,theprofessorcannotnecessarilyde- termine which chips are good using any strategy based on this kind of pairwise test. Assume that the bad chips can conspire to fool the professor. 110 Chapter 4 Divide-and-Conquer b. c. Consider the problem of finding a single good chip from among n chips, as- suming that more than n=2 of the chips are good. Show that bn=2c pairwise tests are sufficient to reduce the problem to one of nearly half the size. Show that the good chips can be identified with ‚.n/ pairwise tests, assuming that more than n=2 of the chips are good. Give and solve the recurrence that describes the number of tests. 4-6 An m 􏳨 n array A of real numbers is a Monge array if for all i, j, k, and l such that 1 􏳥 i < k 􏳥 m and 1 􏳥 j < l 􏳥 n, we have AŒi;j􏳩 C AŒk;l􏳩 􏳥 AŒi;l􏳩 C AŒk;j􏳩 : In other words, whenever we pick two rows and two columns of a Monge array and consider the four elements at the intersections of the rows and the columns, the sum of the upper-left and lower-right elements is less than or equal to the sum of the lower-left and upper-right elements. For example, the following array is Monge: 10 17 13 28 23 17 22 16 29 23 24 28 22 34 24 11 13 6 17 7 45 44 32 37 23 36331921 6 75 a. b. 66 51 53 34 Prove that an array is Monge if and only if for all i D 1;2;:::;m 􏳣 1 and j D1;2;:::;n􏳣1,wehave AŒi;j􏳩CAŒiC1;j C1􏳩􏳥AŒi;j C1􏳩CAŒiC1;j􏳩: (Hint: For the “if” part, use induction separately on rows and columns.) The following array is not Monge. Change one element in order to make it Monge. (Hint: Use part (a).) 37 23 22 32 21 6 7 10 53 34 30 31 32 13 9 6 432115 8 Monge arrays Notes for Chapter 4 111 c. Let f .i / be the index of the column containing the leftmost minimum element of row i . Prove that f .1/ 􏳥 f .2/ 􏳥 􏳵 􏳵 􏳵 􏳥 f .m/ for any m 􏳨 n Monge array. d. Hereisadescriptionofadivide-and-conqueralgorithmthatcomputestheleft- most minimum element in each row of an m 􏳨 n Monge array A: Construct a submatrix A0 of A consisting of the even-numbered rows of A. Recursively determine the leftmost minimum for each row of A0. Then compute the leftmost minimum in the odd-numbered rows of A. Explain how to compute the leftmost minimum in the odd-numbered rows of A (given that the leftmost minimum of the even-numbered rows is known) in O.m C n/ time. e. Write the recurrence describing the running time of the algorithm described in part (d). Show that its solution is O.m C n log m/. Chapter notes Divide-and-conquer as a technique for designing algorithms dates back to at least 1962 in an article by Karatsuba and Ofman [194]. It might have been used well be- fore then, however; according to Heideman, Johnson, and Burrus [163], C. F. Gauss devised the first fast Fourier transform algorithm in 1805, and Gauss’s formulation breaks the problem into smaller subproblems whose solutions are combined. The maximum-subarray problem in Section 4.1 is a minor variation on a problem studied by Bentley [43, Chapter 7]. Strassen’s algorithm [325] caused much excitement when it was published in 1969. Before then, few imagined the possibility of an algorithm asymptotically faster than the basic SQUARE-MATRIX-MULTIPLY procedure. The asymptotic upper bound for matrix multiplication has been improved since then. The most asymptotically efficient algorithm for multiplying n 􏳨 n matrices to date, due to Coppersmith and Winograd [78], has a running time of O.n2:376/. The best lower bound known is just the obvious 􏳫.n2/ bound (obvious because we must fill in n2 elements of the product matrix). From a practical point of view, Strassen’s algorithm is often not the method of choice for matrix multiplication, for four reasons: 1. The constant factor hidden in the ‚.nlg7/ running time of Strassen’s algo- rithm is larger than the constant factor in the ‚.n3/-time SQUARE-MATRIX- MULTIPLY procedure. 2. When the matrices are sparse, methods tailored for sparse matrices are faster. 112 Chapter 4 Divide-and-Conquer 3. Strassen’s algorithm is not quite as numerically stable as SQUARE-MATRIX- MULTIPLY. In other words, because of the limited precision of computer arith- metic on noninteger values, larger errors accumulate in Strassen’s algorithm than in SQUARE-MATRIX-MULTIPLY. 4. The submatrices formed at the levels of recursion consume space. The latter two reasons were mitigated around 1990. Higham [167] demonstrated that the difference in numerical stability had been overemphasized; although Strassen’s algorithm is too numerically unstable for some applications, it is within acceptable limits for others. Bailey, Lee, and Simon [32] discuss techniques for reducing the memory requirements for Strassen’s algorithm. In practice, fast matrix-multiplication implementations for dense matrices use Strassen’s algorithm for matrix sizes above a “crossover point,” and they switch to a simpler method once the subproblem size reduces to below the crossover point. The exact value of the crossover point is highly system dependent. Analyses that count operations but ignore effects from caches and pipelining have produced crossover points as low as n D 8 (by Higham [167]) or n D 12 (by Huss-Lederman et al. [186]). D’Alberto and Nicolau [81] developed an adaptive scheme, which determines the crossover point by benchmarking when their software package is installed. They found crossover points on various systems ranging from n D 400 to n D 2150, and they could not find a crossover point on a couple of systems. Recurrences were studied as early as 1202 by L. Fibonacci, for whom the Fi- bonacci numbers are named. A. De Moivre introduced the method of generating functions (see Problem 4-4) for solving recurrences. The master method is adapted from Bentley, Haken, and Saxe [44], which provides the extended method justified by Exercise 4.6-2. Knuth [209] and Liu [237] show how to solve linear recurrences using the method of generating functions. Purdom and Brown [287] and Graham, Knuth, and Patashnik [152] contain extended discussions of recurrence solving. Several researchers, including Akra and Bazzi [13], Roura [299], Verma [346], and Yap [360], have given methods for solving more general divide-and-conquer recurrences than are solved by the master method. We describe the result of Akra and Bazzi here, as modified by Leighton [228]. The Akra-Bazzi method works for (4.30) recurrences of the form ( T.x/D PkiD1aiT.bix/Cf.x/ ifx>x0 ;
where
􏳮 􏳮 􏳮
x 􏳦 1 is a real number,
x0 isaconstantsuchthatx0 􏳦1=bi andx0 􏳦1=.1􏳣bi/foriD1;2;:::;k, ai is a positive constant for i D 1;2;:::;k,
‚.1/ if1􏳥x􏳥x0 ;

Notes for Chapter 4 113
bi isaconstantintherange0 AŒj􏳩, then the pair .i;j/ is called an inversion of A. (See Problem 2-4 for more on inver- sions.) Suppose that the elements of A form a uniform random permutation of h1; 2; : : : ; ni. Use indicator random variables to compute the expected number of inversions.
5.3 Randomized algorithms
In the previous section, we showed how knowing a distribution on the inputs can help us to analyze the average-case behavior of an algorithm. Many times, we do not have such knowledge, thus precluding an average-case analysis. As mentioned in Section 5.1, we may be able to use a randomized algorithm.
For a problem such as the hiring problem, in which it is helpful to assume that all permutations of the input are equally likely, a probabilistic analysis can guide the development of a randomized algorithm. Instead of assuming a distribution of inputs, we impose a distribution. In particular, before running the algorithm, we randomly permute the candidates in order to enforce the property that every permutation is equally likely. Although we have modified the algorithm, we still expect to hire a new office assistant approximately ln n times. But now we expect

5.3 Randomized algorithms 123
this to be the case for any input, rather than for inputs drawn from a particular distribution.
Let us further explore the distinction between probabilistic analysis and random- ized algorithms. In Section 5.2, we claimed that, assuming that the candidates ar- rive in a random order, the expected number of times we hire a new office assistant is about ln n. Note that the algorithm here is deterministic; for any particular input, the number of times a new office assistant is hired is always the same. Furthermore, the number of times we hire a new office assistant differs for different inputs, and it depends on the ranks of the various candidates. Since this number depends only on the ranks of the candidates, we can represent a particular input by listing, in order, the ranks of the candidates, i.e., hrank.1/; rank.2/; : : : ; rank.n/i. Given the rank listA1 Dh1;2;3;4;5;6;7;8;9;10i,anewofficeassistantisalwayshired10times, since each successive candidate is better than the previous one, and lines 5–6 are executed in each iteration. Given the list of ranks A2 D h10; 9; 8; 7; 6; 5; 4; 3; 2; 1i, a new office assistant is hired only once, in the first iteration. Given a list of ranks A3 D h5; 2; 1; 8; 4; 7; 10; 9; 3; 6i, a new office assistant is hired three times, upon interviewing the candidates with ranks 5, 8, and 10. Recalling that the cost of our algorithm depends on how many times we hire a new office assistant, we see that there are expensive inputs such as A1, inexpensive inputs such as A2, and moderately expensive inputs such as A3.
Consider, on the other hand, the randomized algorithm that first permutes the candidates and then determines the best candidate. In this case, we randomize in the algorithm, not in the input distribution. Given a particular input, say A3 above, we cannot say how many times the maximum is updated, because this quantity differs with each run of the algorithm. The first time we run the algorithm on A3, it may produce the permutation A1 and perform 10 updates; but the second time we run the algorithm, we may produce the permutation A2 and perform only one update. The third time we run it, we may perform some other number of updates. Each time we run the algorithm, the execution depends on the random choices made and is likely to differ from the previous execution of the algorithm. For this algorithm and many other randomized algorithms, no particular input elicits its worst-case behavior. Even your worst enemy cannot produce a bad input array, since the random permutation makes the input order irrelevant. The randomized algorithm performs badly only if the random-number generator produces an “un- lucky” permutation.
For the hiring problem, the only change needed in the code is to randomly per- mute the array.

124 Chapter 5 Probabilistic Analysis and Randomized Algorithms
RANDOMIZED-HIRE-ASSISTANT.n/
1 2 3 4 5 6 7
randomly permute the list of candidates
best D 0 // candidate 0 is a least-qualified dummy candidate foriD1ton
interview candidate i
if candidate i is better than candidate best
best D i
hire candidate i
With this simple change, we have created a randomized algorithm whose perfor- mance matches that obtained by assuming that the candidates were presented in a random order.
Lemma 5.3
The expected hiring cost of the procedure RANDOMIZED-HIRE-ASSISTANT is O.ch ln n/.
Proof After permuting the input array, we have achieved a situation identical to that of the probabilistic analysis of HIRE-ASSISTANT.
Comparing Lemmas 5.2 and 5.3 highlights the difference between probabilistic analysis and randomized algorithms. In Lemma 5.2, we make an assumption about the input. In Lemma 5.3, we make no such assumption, although randomizing the input takes some additional time. To remain consistent with our terminology, we couched Lemma 5.2 in terms of the average-case hiring cost and Lemma 5.3 in terms of the expected hiring cost. In the remainder of this section, we discuss some issues involved in randomly permuting inputs.
Randomly permuting arrays
Many randomized algorithms randomize the input by permuting the given input array. (There are other ways to use randomization.) Here, we shall discuss two methods for doing so. We assume that we are given an array A which, without loss of generality, contains the elements 1 through n. Our goal is to produce a random permutation of the array.
One common method is to assign each element AŒi􏳩 of the array a random pri- ority PŒi􏳩, and then sort the elements of A according to these priorities. For ex- ample, if our initial array is A D h1; 2; 3; 4i and we choose random priorities P D h36; 3; 62; 19i, we would produce an array B D h2; 4; 1; 3i, since the second priority is the smallest, followed by the fourth, then the first, and finally the third. We call this procedure PERMUTE-BY-SORTING:

5.3 Randomized algorithms 125
PERMUTE-BY-SORTING.A/
1 n D A: length
2 let PŒ1::n􏳩 be a new array
3 foriD1ton
4 PŒi􏳩 D RANDOM.1;n3/
5 sort A, using P as sort keys
Line 4 chooses a random number between 1 and n3. We use a range of 1 to n3 to make it likely that all the priorities in P are unique. (Exercise 5.3-5 asks you to prove that the probability that all entries are unique is at least 1 􏳣 1=n, and Exercise 5.3-6 asks how to implement the algorithm even if two or more priorities are identical.) Let us assume that all the priorities are unique.
The time-consuming step in this procedure is the sorting in line 5. As we shall see in Chapter 8, if we use a comparison sort, sorting takes 􏳫.n lg n/ time. We can achieve this lower bound, since we have seen that merge sort takes ‚.n lg n/ time. (We shall see other comparison sorts that take ‚.n lg n/ time in Part II. Exercise 8.3-4 asks you to solve the very similar problem of sorting numbers in the range 0 to n3 􏳣 1 in O.n/ time.) After sorting, if P Œi 􏳩 is the j th smallest priority, then AŒi 􏳩 lies in position j of the output. In this manner we obtain a permutation. It remains to prove that the procedure produces a uniform random permutation, that is, that the procedure is equally likely to produce every permutation of the numbers 1 through n.
Lemma 5.4
Procedure PERMUTE-BY-SORTING produces a uniform random permutation of the input, assuming that all priorities are distinct.
Proof We start by considering the particular permutation in which each ele- ment AŒi􏳩 receives the ith smallest priority. We shall show that this permutation occurs with probability exactly 1=nŠ. For i D 1; 2; : : : ; n, let Ei be the event that element AŒi􏳩 receives the ith smallest priority. Then we wish to compute the probability that for all i, event Ei occurs, which is
PrfE1 \E2 \E3 \􏳵􏳵􏳵\En􏳣1 \Eng :
Using Exercise C.2-5, this probability is equal to
PrfE1g􏳵PrfE2 jE1g􏳵PrfE3 jE2 \E1g􏳵PrfE4 jE3 \E2 \E1g 􏳵􏳵􏳵PrfEi jEi􏳣1 \Ei􏳣2 \􏳵􏳵􏳵\E1g􏳵􏳵􏳵PrfEn jEn􏳣1 \􏳵􏳵􏳵\E1g :
We have that PrfE1g D 1=n because it is the probability that one priority chosen randomly out of a set of n is the smallest priority. Next, we observe

126 Chapter 5 Probabilistic Analysis and Randomized Algorithms
that Pr fE2 j E1g D 1=.n 􏳣 1/ because given that element AŒ1􏳩 has the small- est priority, each of the remaining n 􏳣 1 elements has an equal chance of hav- ing the second smallest priority. In general, for i D 2; 3; : : : ; n, we have that PrfEi j Ei􏳣1 \ Ei􏳣2 \ 􏳵􏳵􏳵 \ E1g D 1=.n􏳣i C1/, since, given that elements AŒ1􏳩 through AŒi 􏳣 1􏳩 have the i 􏳣 1 smallest priorities (in order), each of the remaining n 􏳣 .i 􏳣 1/ elements has an equal chance of having the i th smallest priority. Thus, we have
􏳧1􏳹􏳧 1 􏳹 􏳧1􏳹􏳧1􏳹 PrfE1 \E2 \E3 \􏳵􏳵􏳵\En􏳣1 \Eng D n n􏳣1 􏳵􏳵􏳵 2 1
D1; nŠ
and we have shown that the probability of obtaining the identity permutation is 1=nŠ.
We can extend this proof to work for any permutation of priorities. Consider any fixed permutation 􏳯 D h􏳯.1/;􏳯.2/;:::;􏳯.n/i of the set f1;2;:::;ng. Let us denote by ri the rank of the priority assigned to element AŒi􏳩, where the element with the j th smallest priority has rank j . If we define Ei as the event in which element AŒi􏳩 receives the 􏳯.i/th smallest priority, or ri D 􏳯.i/, the same proof still applies. Therefore, if we calculate the probability of obtaining any particular permutation, the calculation is identical to the one above, so that the probability of obtaining this permutation is also 1=nŠ.
You might think that to prove that a permutation is a uniform random permuta- tion, it suffices to show that, for each element AŒi􏳩, the probability that the element winds up in position j is 1=n. Exercise 5.3-4 shows that this weaker condition is, in fact, insufficient.
A better method for generating a random permutation is to permute the given array in place. The procedure RANDOMIZE-IN-PLACE does so in O.n/ time. In its ith iteration, it chooses the element AŒi􏳩 randomly from among elements AŒi􏳩 through AŒn􏳩. Subsequent to the ith iteration, AŒi􏳩 is never altered.
RANDOMIZE-IN-PLACE.A/
1 n D A:length
2 foriD1ton
3 swap AŒi􏳩 with AŒRANDOM.i; n/􏳩
We shall use a loop invariant to show that procedure RANDOMIZE-IN-PLACE produces a uniform random permutation. A k-permutation on a set of n ele- ments is a sequence containing k of the n elements, with no repetitions. (See Appendix C.) There are nŠ=.n 􏳣 k/Š such possible k-permutations.

5.3 Randomized algorithms 127
Lemma 5.5
Procedure RANDOMIZE-IN-PLACE computes a uniform random permutation. Proof We use the following loop invariant:
Just prior to the ith iteration of the for loop of lines 2–3, for each possible .i 􏳣 1/-permutation of the n elements, the subarray AŒ1 : : i 􏳣 1􏳩 contains this .i 􏳣 1/-permutation with probability .n 􏳣 i C 1/Š=nŠ.
We need to show that this invariant is true prior to the first loop iteration, that each iteration of the loop maintains the invariant, and that the invariant provides a useful property to show correctness when the loop terminates.
Initialization: Consider the situation just before the first loop iteration, so that i D 1. The loop invariant says that for each possible 0-permutation, the sub- array AŒ1 : : 0􏳩 contains this 0-permutation with probability .n 􏳣 i C 1/Š=nŠ D nŠ=nŠ D 1. The subarray AŒ1 : : 0􏳩 is an empty subarray, and a 0-permutation has no elements. Thus, AŒ1 : : 0􏳩 contains any 0-permutation with probability 1, and the loop invariant holds prior to the first iteration.
Maintenance: We assume that just before the ith iteration, each possible .i 􏳣 1/-permutation appears in the subarray AŒ1::i 􏳣 1􏳩 with probability .n 􏳣 i C 1/Š=nŠ, and we shall show that after the ith iteration, each possible i-permutation appears in the subarray AŒ1::i􏳩 with probability .n 􏳣 i/Š=nŠ. Incrementing i for the next iteration then maintains the loop invariant.
Let us examine the ith iteration. Consider a particular i-permutation, and de- note the elements in it by hx1; x2; : : : ; xi i. This permutation consists of an .i􏳣1/-permutationhx1;:::;xi􏳣1ifollowedbythevaluexi thatthealgorithm places in AŒi􏳩. Let E1 denote the event in which the first i 􏳣 1 iterations have created the particular .i 􏳣1/-permutation hx1;:::;xi􏳣1i in AŒ1::i 􏳣1􏳩. By the loop invariant, Pr fE1g D .n 􏳣 i C 1/Š=nŠ. Let E2 be the event that ith iteration putsxi inpositionAŒi􏳩.Thei-permutationhx1;:::;xiiappearsinAŒ1::i􏳩pre- cisely when both E1 and E2 occur, and so we wish to compute Pr fE2 \ E1g. Using equation (C.14), we have
PrfE2 \E1gDPrfE2 jE1gPrfE1g :
TheprobabilityPrfE2 jE1gequals1=.n􏳣iC1/becauseinline3thealgorithm choosesxi randomlyfromthen􏳣iC1valuesinpositionsAŒi::n􏳩.Thus,we have

128 Chapter 5 Probabilistic Analysis and Randomized Algorithms
PrfE2\E1g D PrfE2jE1gPrfE1g
D 1 􏳵 .n 􏳣 i C 1/Š
n􏳣iC1 nŠ D .n􏳣i/Š:
nŠ
Termination: At termination, i D n C 1, and we have that the subarray AŒ1 : : n􏳩
is a given n-permutation with probability .n􏳣.nC1/C1/=nŠ D 0Š=nŠ D 1=nŠ.
Thus, RANDOMIZE-IN-PLACE produces a uniform random permutation.
A randomized algorithm is often the simplest and most efficient way to solve a problem. We shall use randomized algorithms occasionally throughout this book.
Exercises
5.3-1
Professor Marceau objects to the loop invariant used in the proof of Lemma 5.5. He questions whether it is true prior to the first iteration. He reasons that we could just as easily declare that an empty subarray contains no 0-permutations. Therefore, the probability that an empty subarray contains a 0-permutation should be 0, thus invalidating the loop invariant prior to the first iteration. Rewrite the procedure RANDOMIZE-IN-PLACE so that its associated loop invariant applies to a nonempty subarray prior to the first iteration, and modify the proof of Lemma 5.5 for your procedure.
5.3-2
Professor Kelp decides to write a procedure that produces at random any permuta- tion besides the identity permutation. He proposes the following procedure:
PERMUTE-WITHOUT-IDENTITY.A/
1 n D A:length
2 foriD1ton􏳣1
3 swap AŒi􏳩 with AŒRANDOM.i C 1; n/􏳩
Does this code do what Professor Kelp intends?
5.3-3
Suppose that instead of swapping element AŒi􏳩 with a random element from the subarray AŒi : : n􏳩, we swapped it with a random element from anywhere in the array:

5.3 Randomized algorithms 129
PERMUTE-WITH-ALL.A/
1 2 3
n D A: length foriD1ton
swap AŒi􏳩 with AŒRANDOM.1; n/􏳩
Does this code produce a uniform random permutation? Why or why not?
5.3-4
Professor Armstrong suggests the following procedure for generating a uniform random permutation:
PERMUTE-BY-CYCLIC.A/
1 2 3 4 5 6 7 8 9
n D A: length
let BŒ1::n􏳩 be a new array offset D RANDOM.1;n/ foriD1ton
dest D i C offset if dest > n
dest D dest 􏳣 n BŒdest􏳩 D AŒi􏳩
return B
Show that each element AŒi􏳩 has a 1=n probability of winding up in any particular position in B. Then show that Professor Armstrong is mistaken by showing that the resulting permutation is not uniformly random.
5.3-5 ?
Prove that in the array P in procedure PERMUTE-BY-SORTING, the probability that all elements are unique is at least 1 􏳣 1=n.
5.3-6
Explain how to implement the algorithm PERMUTE-BY-SORTING to handle the case in which two or more priorities are identical. That is, your algorithm should produce a uniform random permutation, even if two or more priorities are identical.
5.3-7
Suppose we want to create a random sample of the set f1;2;3;:::;ng, that is, an m-element subset S, where 0 􏳥 m 􏳥 n, such that each m-subset is equally likely to be created. One way would be to set AŒi􏳩 D i for i D 1;2;3;:::;n, call RANDOMIZE-IN-PLACE.A/, and then take just the first m array elements. This method would make n calls to the RANDOM procedure. If n is much larger than m, we can create a random sample with fewer calls to RANDOM. Show that

130
Chapter 5 Probabilistic Analysis and Randomized Algorithms
the following recursive procedure returns a random m-subset S of f1; 2; 3; : : : ; ng, in which each m-subset is equally likely, while making only m calls to RANDOM:
RANDOM-SAMPLE.m; n/ 1 ifm==0
2
3 else 4
5
6
7
8
return ;
S D RANDOM-SAMPLE.m 􏳣 1; n 􏳣 1/ i D RANDOM.1;n/
if i 2 S
S D S [ fng else S D S [ fig
return S
? 5.4
Probabilistic analysis and further uses of indicator random variables
This advanced section further illustrates probabilistic analysis by way of four ex- amples. The first determines the probability that in a room of k people, two of them share the same birthday. The second example examines what happens when we randomly toss balls into bins. The third investigates “streaks” of consecutive heads when we flip coins. The final example analyzes a variant of the hiring prob- lem in which you have to make decisions without actually interviewing all the candidates.
5.4.1 The birthday paradox
Our first example is the birthday paradox. How many people must there be in a room before there is a 50% chance that two of them were born on the same day of the year? The answer is surprisingly few. The paradox is that it is in fact far fewer than the number of days in a year, or even half the number of days in a year, as we shall see.
To answer this question, we index the people in the room with the integers 1;2;:::;k, where k is the number of people in the room. We ignore the issue of leap years and assume that all years have n D 365 days. For i D 1;2;:::;k, let bi be the day of the year on which person i’s birthday falls, where 1 􏳥 bi 􏳥 n. We also assume that birthdays are uniformly distributed across the n days of the year, so that Prfbi D rg D 1=n for i D 1;2;:::;k and r D 1;2;:::;n.
The probability that two given people, say i and j, have matching birthdays depends on whether the random selection of birthdays is independent. We assume from now on that birthdays are independent, so that the probability that i ’s birthday

5.4 Probabilistic analysis and further uses of indicator random variables 131
and j ’s birthday both fall on day r is
Prfbi Drandbj Drg D Prfbi DrgPrfbj Drg
D 1=n2:
Thus, the probability that they both fall on the same day is
Xn rD1
Xn rD1
D 1=n: (5.6)
More intuitively, once bi is chosen, the probability that bj is chosen to be the same day is 1=n. Thus, the probability that i and j have the same birthday is the same as the probability that the birthday of one of them falls on a given day. Notice, however, that this coincidence depends on the assumption that the birthdays are independent.
We can analyze the probability of at least 2 out of k people having matching birthdays by looking at the complementary event. The probability that at least two of the birthdays match is 1 minus the probability that all the birthdays are different. The event that k people have distinct birthdays is
\k BkD Ai;
iD1
where Ai is the event that person i’s birthday is different from person j’s for all j < i. Since we can write Bk D Ak \ Bk􏳣1, we obtain from equation (C.16) the recurrence PrfBkg D PrfBk􏳣1gPrfAk j Bk􏳣1g ; (5.7) where we take PrfB1g D PrfA1g D 1 as an initial condition. In other words, the probability that b1 ; b2 ; : : : ; bk are distinct birthdays is the probability that b1; b2; : : : ; bk􏳣1 are distinct birthdays times the probability that bk ¤ bi for i D1;2;:::;k􏳣1,giventhatb1;b2;:::;bk􏳣1 aredistinct. If b1; b2; : : : ; bk􏳣1 are distinct, the conditional probability that bk ¤ bi for iD1;2;:::;k􏳣1isPrfAk jBk􏳣1gD.n􏳣kC1/=n,sinceoutofthendays, n 􏳣 .k 􏳣 1/ days are not taken. We iteratively apply the recurrence (5.7) to obtain Prfbi Dbjg D D Prfbi Drandbj Drg .1=n2/ 132 Chapter 5 Probabilistic Analysis and Randomized Algorithms PrfBkg D Pr fBk􏳣1g Pr fAk j Bk􏳣1g D Pr fBk􏳣2g Pr fAk􏳣1 j Bk􏳣2g Pr fAk j Bk􏳣1g : D PrfB1gPrfA2 j B1gPrfA3 j B2g􏳵􏳵􏳵PrfAk j Bk􏳣1g 􏳧n􏳣1􏳹􏳧n􏳣2􏳹 􏳧n􏳣kC1􏳹 D1􏳵nn􏳵􏳵􏳵n 􏳧 1􏳹􏳧 2􏳹 􏳧 k􏳣1􏳹 D1􏳵1􏳣n 1􏳣n􏳵􏳵􏳵1􏳣 n : Inequality (3.12), 1 C x 􏳥 ex , gives us PrfBkg 􏳥 e􏳣1=ne􏳣2=n 􏳵 􏳵 􏳵 e􏳣.k􏳣1/=n D e􏳣Pk􏳣1i=n iD1 D e􏳣k.k􏳣1/=2n 􏳥 1=2 when 􏳣k.k 􏳣 1/=2n 􏳥 ln.1=2/. The probability that all k birthdays are distinct is at most 1=2 when k.k 􏳣 1/ 􏳦 2n ln 2 or, solving the quadratic equation, when p k􏳦.1C 1C.8ln2/n/=2. FornD365,wemusthavek􏳦23. Thus,ifat least 23 people are in a room, the probability is at least 1=2 that at least two people have the same birthday. On Mars, a year is 669 Martian days long; it therefore takes 31 Martians to get the same effect. An analysis using indicator random variables We can use indicator random variables to provide a simpler but approximate anal- ysis of the birthday paradox. For each pair .i; j / of the k people in the room, we define the indicator random variable Xij , for 1 􏳥 i < j 􏳥 k, by Xij D I fperson i and person j have the same birthdayg ( 1 if person i and person j have the same birthday ; 0 otherwise : By equation (5.6), the probability that two people have matching birthdays is 1=n, and thus by Lemma 5.1, we have E ŒXij 􏳩 D Pr fperson i and person j have the same birthdayg D 1=n: Letting X be the random variable that counts the number of pairs of individuals having the same birthday, we have D 5.4 Probabilistic analysis and further uses of indicator random variables 133 Xk Xk X D Taking expectations of both sides and applying linearity of expectation, we obtain "XkXk # EŒX􏳩 D E Xij iD1 jDiC1 Xk Xk D EŒXij􏳩 iD1 jDiC1 ! k1 2n D k.k􏳣1/: 2n When k.k 􏳣 1/ 􏳦 2n, therefore, the expected number of pairs of people with the p same birthday is at least 1. Thus, if we have at least 2nC1 individuals in a room, we can expect at least two to have the same birthday. For n D 365, if k D 28, the expected number of pairs with the same birthday is .28 􏳵 27/=.2 􏳵 365/ 􏳬 1:0356. Thus, with at least 28 people, we expect to find at least one matching pair of birth- days. On Mars, where a year is 669 Martian days long, we need at least 38 Mar- tians. The first analysis, which used only probabilities, determined the number of peo- ple required for the probability to exceed 1=2 that a matching pair of birthdays exists, and the second analysis, which used indicator random variables, determined the number such that the expected number of matching birthdays is 1. Although the exact numbers of people differ for the two situations, they are the same asymp- totically: ‚.pn/. 5.4.2 Balls and bins Consider a process in which we randomly toss identical balls into b bins, numbered 1; 2; : : : ; b. The tosses are independent, and on each toss the ball is equally likely to end up in any bin. The probability that a tossed ball lands in any given bin is 1=b. Thus, the ball-tossing process is a sequence of Bernoulli trials (see Appendix C.4) with a probability 1=b of success, where success means that the ball falls in the given bin. This model is particularly useful for analyzing hashing (see Chapter 11), and we can answer a variety of interesting questions about the ball-tossing process. (Problem C-1 asks additional questions about balls and bins.) iD1 jDiC1 D Xij : 134 Chapter 5 Probabilistic Analysis and Randomized Algorithms How many balls fall in a given bin? The number of balls that fall in a given bin follows the binomial distribution b.kI n; 1=b/. If we toss n balls, equation (C.37) tells us that the expected number of balls that fall in the given bin is n=b. How many balls must we toss, on the average, until a given bin contains a ball? The number of tosses until the given bin receives a ball follows the geometric distribution with probability 1=b and, by equation (C.32), the expected number of tosses until success is 1=.1=b/ D b. How many balls must we toss until every bin contains at least one ball? Let us call a toss in which a ball falls into an empty bin a “hit.” We want to know the expected number n of tosses required to get b hits. Using the hits, we can partition the n tosses into stages. The i th stage consists of the tosses after the .i 􏳣 1/st hit until the i th hit. The first stage consists of the first toss, since we are guaranteed to have a hit when all bins are empty. For each toss during the ith stage, i 􏳣 1 bins contain balls and b 􏳣 i C 1 bins are empty. Thus, for each toss in the ith stage, the probability of obtaining a hit is .b 􏳣 i C 1/=b. Let ni denote the number of tosses in the ith stage. Thus, the number of tosses required to get b hits is n D Pbi D1 ni . Each random variable ni has a geometric distribution with probability of success .b 􏳣 i C 1/=b and thus, by equation (C.32), we have E Œni 􏳩 D b : b􏳣iC1 By linearity of expectation, we have EŒn􏳩 D E "Xb # ni iD1 Xb D EŒni􏳩 iD1 DXb b iD1 b􏳣iC1 Xb 1 Dbi iD1 D b.ln b C O.1// (by equation (A.7)) . It therefore takes approximately b ln b tosses before we can expect that every bin has a ball. This problem is also known as the coupon collector’s problem, which says that a person trying to collect each of b different coupons expects to acquire approximately b ln b randomly obtained coupons in order to succeed. 5.4 Probabilistic analysis and further uses of indicator random variables 135 5.4.3 Streaks Suppose you flip a fair coin n times. What is the longest streak of consecutive heads that you expect to see? The answer is ‚.lg n/, as the following analysis shows. We first prove that the expected length of the longest streak of heads is O.lg n/. The probability that each coin flip is a head is 1=2. Let Aik be the event that a streak of heads of length at least k begins with the ith coin flip or, more precisely, the event that the k consecutive coin flips i; i C 1; : : : ; i C k 􏳣 1 yield only heads, where 1 􏳥 k 􏳥 n and 1 􏳥 i 􏳥 n􏳣kC1. Since coin flips are mutually independent, for any given event Ai k , the probability that all k flips are heads is PrfAikg D 1=2k : For k D 2 dlg ne, Pr fAi;2dlg neg D 􏳥 (5.8) Pr Ai;2dlg ne 􏳥 1=n 1=n2 iD1 iD1 Xn 1=22dlg ne 1=22 lg n D 1=n2; and thus the probability that a streak of heads of length at least 2 dlg ne begins in position i is quite small. There are at most n 􏳣 2 dlg ne C 1 positions where such a streak can begin. The probability that a streak of heads of length at least 2 dlg ne begins anywhere is therefore (n􏳣2dlg neC1 ) n􏳣2dlg neC1 [X2 < D 1=n; iD1 since by Boole’s inequality (C.19), the probability of a union of events is at most the sum of the probabilities of the individual events. (Note that Boole’s inequality holds even for events such as these that are not independent.) We now use inequality (5.9) to bound the length of the longest streak. For j D0;1;2;:::;n,letLj betheeventthatthelongeststreakofheadshaslengthex- actly j , and let L be the length of the longest streak. By the definition of expected value, we have Xn jD0 E ŒL􏳩 D j Pr fLj g : (5.10) (5.9) 136 Chapter 5 Probabilistic Analysis and Randomized Algorithms We could try to evaluate this sum using upper bounds on each Pr fLj g similar to those computed in inequality (5.9). Unfortunately, this method would yield weak bounds. We can use some intuition gained by the above analysis to obtain a good bound, however. Informally, we observe that for no individual term in the sum- mation in equation (5.10) are both the factors j and Pr fLj g large. Why? When j 􏳦 2dlgne, then PrfLjg is very small, and when j < 2dlgne, then j is fairly small. More formally, we note that the events Lj for j D 0; 1; : : : ; n are disjoint, and so the probability that a streak of heads of length at least 2 dlg ne begins any- where is Pn Pr fLj g. By inequality (5.9), we have Pn Pr fLj g < 1=n. j D2dlg ne j D2dlg ne Also, noting that Pn Pr fLj g D 1, we have that P2dlg ne􏳣1 Pr fLj g 􏳥 1. Thus, jD0 jD0 we obtain E ŒL􏳩 D D < D < D j Pr fLj g 2dlg ne􏳣1 n Xn jD0 XX j Pr fLj g C XX j D0 2dlg ne􏳣1 j D2dlg ne j Pr fLj g n j D0 .2 dlg ne/ Pr fLj g C 2dlg ne􏳣1 n Pr fLj g n j D2dlg ne XX 2dlgne 2dlgne􏳵1Cn􏳵.1=n/ O.lgn/: j D0 PrfLjgCn PrfLjg j D2dlg ne The probability that a streak of heads exceeds r dlg ne flips diminishes quickly with r . For r 􏳦 1, the probability that a streak of at least r dlg ne heads starts in position i is Pr fAi;rdlg neg D 1=2rdlg ne 􏳥 1=nr : Thus, the probability is at most n=nr D 1=nr􏳣1 that the longest streak is at least r dlg ne, or equivalently, the probability is at least 1 􏳣 1=nr􏳣1 that the longest streak has length less than r dlg ne. As an example, for n D 1000 coin flips, the probability of having a streak of at least 2 dlg ne D 20 heads is at most 1=n D 1=1000. The chance of having a streak longer than 3 dlg ne D 30 heads is at most 1=n2 D 1=1,000,000. We now prove a complementary lower bound: the expected length of the longest streak of heads in n coin flips is 􏳫.lg n/. To prove this bound, we look for streaks 5.4 Probabilistic analysis and further uses of indicator random variables 137 of length s by partitioning the n flips into approximately n=s groups of s flips each. If we choose s D b.lg n/=2c, we can show that it is likely that at least one of these groups comes up all heads, and hence it is likely that the longest streak has length at least s D 􏳫.lg n/. We then show that the longest streak has expected length 􏳫.lg n/. We partition the n coin flips into at least bn= b.lg n/=2cc groups of b.lg n/=2c consecutive flips, and we bound the probability that no group comes up all heads. By equation (5.8), the probability that the group starting in position i comes up all heads is Pr fAi;b.lg n/=2cg D 1=2b.lg n/=2c p 􏳦 1= n: The probability that a streak of heads of length at least b.lg n/=2c does not begin in position i is therefore at most 1 􏳣 1=pn. Since the bn= b.lg n/=2cc groups are formed from mutually exclusive, independent coin flips, the probability that every one of these groups fails to be a streak of length b.lg n/=2c is at most 􏳣1 􏳣 1=pn􏳵bn=b.lg n/=2cc 􏳥 􏳥 􏳣1 􏳣 1=pn􏳵2n= lg n􏳣1 􏳣1 􏳣 1=pn􏳵n=b.lg n/=2c􏳣1 p 􏳥 e􏳣.2n= lg n􏳣1/= n D O.e􏳣lgn/ D O.1=n/ : For this argument, we used inequality (3.12), 1 C x 􏳥 ex , and the fact, which you might want to verify, that .2n= lg n 􏳣 1/=pn 􏳦 lg n for sufficiently large n. Thus, the probability that the longest streak exceeds b.lg n/=2c is Xn Pr fLj g 􏳦 1 􏳣 O.1=n/ : (5.11) j Db.lg n/=2cC1 We can now calculate a lower bound on the expected length of the longest streak, beginning with equation (5.10) and proceeding in a manner similar to our analysis of the upper bound: 138 Chapter 5 Probabilistic Analysis and Randomized Algorithms E ŒL􏳩 Xn D j Pr fLj g D jD0 b.lg n/=2c n XX j Pr fLj g C XX j Pr fLj g b.lg n/=2c Pr fLj g j D0 b.lg n/=2c j Db.lg n/=2cC1 n 􏳦 0 􏳵 Pr fLj g C j D0 D 0􏳵 􏳦 0 C b.lg n/=2c .1 􏳣 O.1=n// D 􏳫.lgn/: j Db.lg n/=2cC1 XX b.lg n/=2c n j D0 j Db.lg n/=2cC1 PrfLjgCb.lgn/=2c PrfLjg (by inequality (5.11)) As with the birthday paradox, we can obtain a simpler but approximate analysis using indicator random variables. We let Xi k D I fAi k g be the indicator random variable associated with a streak of heads of length at least k beginning with the ith coin flip. To count the total number of such streaks, we define n􏳣kC1 X X D Taking expectations and using linearity of expectation, we have iD1 EŒX􏳩 D E n􏳣kC1 Xik Xik : "n􏳣kC1 X # iD1 X D EŒXik􏳩 iD1 n􏳣kC1 X D PrfAikg iD1 D n􏳣kC1 Xk 1=2 D n􏳣kC1: 2k By plugging in various values for k, we can calculate the expected number of streaks of length k. If this number is large (much greater than 1), then we expect many streaks of length k to occur and the probability that one occurs is high. If iD1 5.4 Probabilistic analysis and further uses of indicator random variables 139 this number is small (much less than 1), then we expect few streaks of length k to occur and the probability that one occurs is low. If k D c lg n, for some positive constant c, we obtain EŒX􏳩 D D n􏳣clgnC1 2c lg n n􏳣clgnC1 nc D 1 􏳣.clgn􏳣1/=n nc 􏳣1 nc 􏳣1 D ‚.1=nc􏳣1/ : If c is large, the expected number of streaks of length c lg n is small, and we con- clude that they are unlikely to occur. On the other hand, if c D 1=2, then we obtain EŒX􏳩 D ‚.1=n1=2􏳣1/ D ‚.n1=2/, and we expect that there are a large number of streaks of length .1=2/ lg n. Therefore, one streak of such a length is likely to occur. From these rough estimates alone, we can conclude that the expected length of the longest streak is ‚.lg n/. 5.4.4 The on-line hiring problem As a final example, we consider a variant of the hiring problem. Suppose now that we do not wish to interview all the candidates in order to find the best one. We also do not wish to hire and fire as we find better and better applicants. Instead, we are willing to settle for a candidate who is close to the best, in exchange for hiring exactly once. We must obey one company requirement: after each interview we must either immediately offer the position to the applicant or immediately reject the applicant. What is the trade-off between minimizing the amount of interviewing and maximizing the quality of the candidate hired? We can model this problem in the following way. After meeting an applicant, we are able to give each one a score; let score.i/ denote the score we give to the ith applicant, and assume that no two applicants receive the same score. After we have seen j applicants, we know which of the j has the highest score, but we do not know whether any of the remaining n􏳣j applicants will receive a higher score. We decide to adopt the strategy of selecting a positive integer k < n, interviewing and then rejecting the first k applicants, and hiring the first applicant thereafter who has a higher score than all preceding applicants. If it turns out that the best-qualified applicant was among the first k interviewed, then we hire the nth applicant. We formalize this strategy in the procedure ON-LINE-MAXIMUM.k;n/, which returns the index of the candidate we wish to hire. 140 Chapter 5 Probabilistic Analysis and Randomized Algorithms ON-LINE-MAXIMUM.k; n/ 1 2 3 4 5 6 7 8 bestscore D 􏳣1 foriD1tok if score.i/ > bestscore bestscore D score.i/
foriDkC1ton
if score.i/ > bestscore
return i return n
We wish to determine, for each possible value of k, the probability that we hire the most qualified applicant. We then choose the best possible k, and implement the strategy with that value. For the moment, assume that k is fixed. Let M.j/ D max1􏳥i􏳥j fscore.i/g denote the maximum score among ap- plicants 1 through j . Let S be the event that we succeed in choosing the best- qualified applicant, and let Si be the event that we succeed when the best-qualified applicant is the ith one interviewed. Since the various Si are disjoint, we have that Pr fS g D Pni D1 Pr fSi g. Noting that we never succeed when the best-qualified applicant is one of the first k, we have that PrfSig D 0 for i D 1;2;:::;k. Thus, we obtain
Xn iDkC1
We now compute Pr fSi g. In order to succeed when the best-qualified applicant is the ith one, two things must happen. First, the best-qualified applicant must be in position i, an event which we denote by Bi. Second, the algorithm must not select any of the applicants in positions k C 1 through i 􏳣 1, which happens only if, for each j such that kC1 􏳥 j 􏳥 i 􏳣1, we find that score.j/ < bestscore in line 6. (Because scores are unique, we can ignore the possibility of score.j / D bestscore.) In other words, all of the values score.k C 1/ through score.i 􏳣 1/ must be less than M.k/; if any are greater than M.k/, we instead return the index of the first one that is greater. We use Oi to denote the event that none of the applicants in position k C 1 through i 􏳣 1 are chosen. Fortunately, the two events Bi and Oi are independent. The event Oi depends only on the relative ordering of the values in positions 1 through i 􏳣 1, whereas Bi depends only on whether the value in position i is greater than the values in all other positions. The ordering of the values in positions 1 through i 􏳣 1 does not affect whether the value in position i is greater than all of them, and the value in position i does not affect the ordering of the values in positions 1 through i 􏳣 1. Thus we can apply equation (C.15) to obtain PrfSgD PrfSig : (5.12) 5.4 Probabilistic analysis and further uses of indicator random variables 141 PrfSig D PrfBi \Oig D PrfBigPrfOig : The probability PrfBig is clearly 1=n, since the maximum is equally likely to be in any one of the n positions. For event Oi to occur, the maximum value in positions 1 through i 􏳣1, which is equally likely to be in any of these i 􏳣1 positions, must be in one of the first k positions. Consequently, Pr fOi g D k=.i 􏳣 1/ and Pr fSi g D k=.n.i 􏳣 1//. Using equation (5.12), we have PrfSg D D PrfSig Xn k Xn iDkC1 n.i 􏳣 1/ kXn 1 iDkC1 D D kX1: n iDkC1 i 􏳣 1 n􏳣1 niDk i We approximate by integrals to bound this summation from above and below. By the inequalities (A.12), we have n􏳣1 1 k.lnn􏳣lnk/􏳥PrfSg􏳥 k.ln.n􏳣1/􏳣ln.k􏳣1//; nn which provide a rather tight bound for PrfSg. Because we wish to maximize our probability of success, let us focus on choosing the value of k that maximizes the lower bound on Pr fS g. (Besides, the lower-bound expression is easier to maximize than the upper-bound expression.) Differentiating the expression .k=n/.ln n􏳣ln k/ with respect to k, we obtain 1 .ln n 􏳣 ln k 􏳣 1/ : n Setting this derivative equal to 0, we see that we maximize the lower bound on the probability when ln k D ln n 􏳣 1 D ln.n=e/ or, equivalently, when k D n=e. Thus, if we implement our strategy with k D n=e, we succeed in hiring our best-qualified applicant with probability at least 1=e. Z n􏳣1 Z n 1 x dx 􏳥 X1 i 􏳥 Evaluating these definite integrals gives us the bounds k iDk k􏳣1 x dx : 142 Chapter 5 Probabilistic Analysis and Randomized Algorithms Exercises 5.4-1 How many people must there be in a room before the probability that someone has the same birthday as you do is at least 1=2? How many people must there be before the probability that at least two people have a birthday on July 4 is greater than 1=2? 5.4-2 Suppose that we toss balls into b bins until some bin contains two balls. Each toss is independent, and each ball is equally likely to end up in any bin. What is the expected number of ball tosses? 5.4-3 ? For the analysis of the birthday paradox, is it important that the birthdays be mutu- ally independent, or is pairwise independence sufficient? Justify your answer. 5.4-4 ? How many people should be invited to a party in order to make it likely that there are three people with the same birthday? 5.4-5 ? What is the probability that a k-string over a set of size n forms a k-permutation? How does this question relate to the birthday paradox? 5.4-6 ? Suppose that n balls are tossed into n bins, where each toss is independent and the ball is equally likely to end up in any bin. What is the expected number of empty bins? What is the expected number of bins with exactly one ball? 5.4-7 ? Sharpen the lower bound on streak length by showing that in n flips of a fair coin, the probability is less than 1=n that no streak longer than lg n􏳣2 lg lg n consecutive heads occurs. Problems for Chapter 5 143 Problems 5-1 Probabilistic counting With a b-bit counter, we can ordinarily only count up to 2b 􏳣 1. With R. Morris’s probabilistic counting, we can count up to a much larger value at the expense of some loss of precision. Weletacountervalueofirepresentacountofni foriD0;1;:::;2b􏳣1,where the ni form an increasing sequence of nonnegative values. We assume that the ini- tial value of the counter is 0, representing a count of n0 D 0. The INCREMENT operation works on a counter containing the value i in a probabilistic manner. If i D 2b 􏳣 1, then the operation reports an overflow error. Otherwise, the INCRE- MENT operation increases the counter by 1 with probability 1=.niC1 􏳣 ni/, and it leaves the counter unchanged with probability 1 􏳣 1=.ni C1 􏳣 ni /. If we select ni D i for all i 􏳦 0, then the counter is an ordinary one. More interesting situations arise if we select, say, ni D 2i􏳣1 for i > 0 or ni D Fi (the ith Fibonacci number—see Section 3.2).
For this problem, assume that n2b􏳣1 is large enough that the probability of an overflow error is negligible.
a. b.
5-2
Show that the expected value represented by the counter after n INCREMENT operations have been performed is exactly n.
The analysis of the variance of the count represented by the counter depends on the sequence of the ni. Let us consider a simple case: ni D 100i for all i 􏳦 0. Estimate the variance in the value represented by the register after n INCREMENT operations have been performed.
Searching an unsorted array
This problem examines three algorithms for searching for a value x in an unsorted array A consisting of n elements.
Consider the following randomized strategy: pick a random index i into A. If AŒi􏳩 D x, then we terminate; otherwise, we continue the search by picking a new random index into A. We continue picking random indices into A until we find an index j such that AŒj 􏳩 D x or until we have checked every element of A. Note that we pick from the whole set of indices each time, so that we may examine a given element more than once.
a. Write pseudocode for a procedure RANDOM-SEARCH to implement the strat- egy above. Be sure that your algorithm terminates when all indices into A have been picked.

144 Chapter 5 Probabilistic Analysis and Randomized Algorithms
b. Suppose that there is exactly one index i such that AŒi􏳩 D x. What is the expected number of indices into A that we must pick before we find x and RANDOM-SEARCH terminates?
c. Generalizing your solution to part (b), suppose that there are k 􏳦 1 indices i such that AŒi􏳩 D x. What is the expected number of indices into A that we must pick before we find x and RANDOM-SEARCH terminates? Your answer should be a function of n and k.
d. Suppose that there are no indices i such that AŒi􏳩 D x. What is the expected number of indices into A that we must pick before we have checked all elements of A and RANDOM-SEARCH terminates?
Now consider a deterministic linear search algorithm, which we refer to as DETERMINISTIC-SEARCH. Specifically, the algorithm searches A for x in order, considering AŒ1􏳩; AŒ2􏳩; AŒ3􏳩; : : : ; AŒn􏳩 until either it finds AŒi 􏳩 D x or it reaches the end of the array. Assume that all possible permutations of the input array are equally likely.
e. Suppose that there is exactly one index i such that AŒi􏳩 D x. What is the average-case running time of DETERMINISTIC-SEARCH? What is the worst- case running time of DETERMINISTIC-SEARCH?
f. Generalizing your solution to part (e), suppose that there are k 􏳦 1 indices i such that AŒi􏳩 D x. What is the average-case running time of DETERMINISTIC- SEARCH? What is the worst-case running time of DETERMINISTIC-SEARCH? Your answer should be a function of n and k.
g. Suppose that there are no indices i such that AŒi􏳩 D x. What is the average-case running time of DETERMINISTIC-SEARCH? What is the worst-case running time of DETERMINISTIC-SEARCH?
Finally, consider a randomized algorithm SCRAMBLE-SEARCH that works by first randomly permuting the input array and then running the deterministic lin- ear search given above on the resulting permuted array.
h. LettingkbethenumberofindicesisuchthatAŒi􏳩Dx,givetheworst-caseand expected running times of SCRAMBLE-SEARCH for the cases in which k D 0 and k D 1. Generalize your solution to handle the case in which k 􏳦 1.
i. Which of the three searching algorithms would you use? Explain your answer.

Notes for Chapter 5 145
Chapter notes
Bolloba ́s [53], Hofri [174], and Spencer [321] contain a wealth of advanced prob- abilistic techniques. The advantages of randomized algorithms are discussed and surveyed by Karp [200] and Rabin [288]. The textbook by Motwani and Raghavan [262] gives an extensive treatment of randomized algorithms.
Several variants of the hiring problem have been widely studied. These problems are more commonly referred to as “secretary problems.” An example of work in this area is the paper by Ajtai, Meggido, and Waarts [11].

II Sorting and Order Statistics

Introduction
This part presents several algorithms that solve the following sorting problem: Input: Asequenceofnnumbersha1;a2;:::;ani.
Output: A permutation (reordering) ha10 ; a20 ; : : : ; an0 i of the input sequence such thata10 􏳥a20 􏳥􏳵􏳵􏳵􏳥an0.
The input sequence is usually an n-element array, although it may be represented in some other fashion, such as a linked list.
The structure of the data
In practice, the numbers to be sorted are rarely isolated values. Each is usually part of a collection of data called a record. Each record contains a key, which is the value to be sorted. The remainder of the record consists of satellite data, which are usually carried around with the key. In practice, when a sorting algorithm permutes the keys, it must permute the satellite data as well. If each record includes a large amount of satellite data, we often permute an array of pointers to the records rather than the records themselves in order to minimize data movement.
In a sense, it is these implementation details that distinguish an algorithm from a full-blown program. A sorting algorithm describes the method by which we determine the sorted order, regardless of whether we are sorting individual numbers or large records containing many bytes of satellite data. Thus, when focusing on the problem of sorting, we typically assume that the input consists only of numbers. Translating an algorithm for sorting numbers into a program for sorting records

148 Part II Sorting and Order Statistics
is conceptually straightforward, although in a given engineering situation other subtleties may make the actual programming task a challenge.
Why sorting?
Many computer scientists consider sorting to be the most fundamental problem in the study of algorithms. There are several reasons:
Sometimes an application inherently needs to sort information. For example, in order to prepare customer statements, banks need to sort checks by check number.
Algorithms often use sorting as a key subroutine. For example, a program that renders graphical objects which are layered on top of each other might have to sort the objects according to an “above” relation so that it can draw these objects from bottom to top. We shall see numerous algorithms in this text that use sorting as a subroutine.
We can draw from among a wide variety of sorting algorithms, and they em- ploy a rich set of techniques. In fact, many important techniques used through- out algorithm design appear in the body of sorting algorithms that have been developed over the years. In this way, sorting is also a problem of historical interest.
We can prove a nontrivial lower bound for sorting (as we shall do in Chapter 8). Our best upper bounds match the lower bound asymptotically, and so we know that our sorting algorithms are asymptotically optimal. Moreover, we can use the lower bound for sorting to prove lower bounds for certain other problems.
Many engineering issues come to the fore when implementing sorting algo- rithms. The fastest sorting program for a particular situation may depend on many factors, such as prior knowledge about the keys and satellite data, the memory hierarchy (caches and virtual memory) of the host computer, and the software environment. Many of these issues are best dealt with at the algorith- mic level, rather than by “tweaking” the code.
Sorting algorithms
We introduced two algorithms that sort n real numbers in Chapter 2. Insertion sort takes ‚.n2/ time in the worst case. Because its inner loops are tight, however, it is a fast in-place sorting algorithm for small input sizes. (Recall that a sorting algorithm sorts in place if only a constant number of elements of the input ar- ray are ever stored outside the array.) Merge sort has a better asymptotic running time, ‚.n lg n/, but the MERGE procedure it uses does not operate in place.
􏳮
􏳮
􏳮
􏳮
􏳮

Part II Sorting and Order Statistics 149
In this part, we shall introduce two more algorithms that sort arbitrary real num- bers. Heapsort, presented in Chapter 6, sorts n numbers in place in O.n lg n/ time. It uses an important data structure, called a heap, with which we can also imple- ment a priority queue.
Quicksort, in Chapter 7, also sorts n numbers in place, but its worst-case running time is ‚.n2/. Its expected running time is ‚.nlgn/, however, and it generally outperforms heapsort in practice. Like insertion sort, quicksort has tight code, and so the hidden constant factor in its running time is small. It is a popular algorithm for sorting large input arrays.
Insertion sort, merge sort, heapsort, and quicksort are all comparison sorts: they determine the sorted order of an input array by comparing elements. Chapter 8 be- gins by introducing the decision-tree model in order to study the performance limi- tations of comparison sorts. Using this model, we prove a lower bound of 􏳫.n lg n/ on the worst-case running time of any comparison sort on n inputs, thus showing that heapsort and merge sort are asymptotically optimal comparison sorts.
Chapter 8 then goes on to show that we can beat this lower bound of 􏳫.n lg n/ if we can gather information about the sorted order of the input by means other than comparing elements. The counting sort algorithm, for example, assumes that the input numbers are in the set f0; 1; : : : ; kg. By using array indexing as a tool for determining relative order, counting sort can sort n numbers in ‚.k C n/ time. Thus, when k D O.n/, counting sort runs in time that is linear in the size of the input array. A related algorithm, radix sort, can be used to extend the range of counting sort. If there are n integers to sort, each integer has d digits, and each digit can take on up to k possible values, then radix sort can sort the numbers in ‚.d.n C k// time. When d is a constant and k is O.n/, radix sort runs in linear time. A third algorithm, bucket sort, requires knowledge of the probabilistic distribution of numbers in the input array. It can sort n real numbers uniformly distributed in the half-open interval Œ0; 1/ in average-case O.n/ time.
The following table summarizes the running times of the sorting algorithms from Chapters 2 and 6–8. As usual, n denotes the number of items to sort. For counting sort, the items to sort are integers in the set f0; 1; : : : ; kg. For radix sort, each item is a d -digit number, where each digit takes on k possible values. For bucket sort, we assume that the keys are real numbers uniformly distributed in the half-open interval Œ0; 1/. The rightmost column gives the average-case or expected running time, indicating which it gives when it differs from the worst-case running time. We omit the average-case running time of heapsort because we do not analyze it in this book.

150 Part II Sorting and Order Statistics
Algorithm
Worst-case running time ‚.n2 /
‚.n lg n/
Average-case/expected running time
‚.n2 /
‚.n lg n/
—
‚.n lg n/ (expected) ‚.k C n/
‚.d.n C k//
‚.n/ (average-case)
Insertion sort
Merge sort
Heapsort O.nlgn/
Quicksort Counting sort Radix sort Bucket sort
Order statistics
‚.n2 / ‚.k C n/
‚.d.n C k// ‚.n2 /
The ith order statistic of a set of n numbers is the ith smallest number in the set. We can, of course, select the ith order statistic by sorting the input and indexing the ith element of the output. With no assumptions about the input distribution, this method runs in 􏳫.n lg n/ time, as the lower bound proved in Chapter 8 shows.
In Chapter 9, we show that we can find the ith smallest element in O.n/ time, even when the elements are arbitrary real numbers. We present a randomized algo- rithm with tight pseudocode that runs in ‚.n2/ time in the worst case, but whose expected running time is O.n/. We also give a more complicated algorithm that runs in O.n/ worst-case time.
Background
Although most of this part does not rely on difficult mathematics, some sections do require mathematical sophistication. In particular, analyses of quicksort, bucket sort, and the order-statistic algorithm use probability, which is reviewed in Ap- pendix C, and the material on probabilistic analysis and randomized algorithms in Chapter 5. The analysis of the worst-case linear-time algorithm for order statis- tics involves somewhat more sophisticated mathematics than the other worst-case analyses in this part.

6 Heapsort
6.1 Heaps
In this chapter, we introduce another sorting algorithm: heapsort. Like merge sort, but unlike insertion sort, heapsort’s running time is O.n lg n/. Like insertion sort, but unlike merge sort, heapsort sorts in place: only a constant number of array elements are stored outside the input array at any time. Thus, heapsort combines the better attributes of the two sorting algorithms we have already discussed.
Heapsort also introduces another algorithm design technique: using a data struc- ture, in this case one we call a “heap,” to manage information. Not only is the heap data structure useful for heapsort, but it also makes an efficient priority queue. The heap data structure will reappear in algorithms in later chapters.
The term “heap” was originally coined in the context of heapsort, but it has since come to refer to “garbage-collected storage,” such as the programming languages Java and Lisp provide. Our heap data structure is not garbage-collected storage, and whenever we refer to heaps in this book, we shall mean a data structure rather than an aspect of garbage collection.
The (binary) heap data structure is an array object that we can view as a nearly complete binary tree (see Section B.5.3), as shown in Figure 6.1. Each node of the tree corresponds to an element of the array. The tree is com- pletely filled on all levels except possibly the lowest, which is filled from the left up to a point. An array A that represents a heap is an object with two at- tributes: A:length, which (as usual) gives the number of elements in the array, and A:heap-size, which represents how many elements in the heap are stored within array A. That is, although AŒ1 : : A: length􏳩 may contain numbers, only the ele- ments in AŒ1::A:heap-size􏳩, where 0 􏳥 A:heap-size 􏳥 A:length, are valid ele- ments of the heap. The root of the tree is AŒ1􏳩, and given the index i of a node, we can easily compute the indices of its parent, left child, and right child:

152 Chapter 6
Heapsort
1
16 23
14 10 4567 8793
1 2 3 4 5 6 7 8 9 10
16
14
10
8
7
9
3
2
4
1
8 9 10 241
(a) (b)
Figure 6.1 A max-heap viewed as (a) a binary tree and (b) an array. The number within the circle at each node in the tree is the value stored at that node. The number above a node is the corresponding index in the array. Above and below the array are lines showing parent-child relationships; parents are always to the left of their children. The tree has height three; the node at index 4 (with value 8) has height one.
PARENT.i/
1 return bi=2c
LEFT.i/
1 return 2i
RIGHT.i/
1 return 2i C 1
On most computers, the LEFT procedure can compute 2i in one instruction by simply shifting the binary representation of i left by one bit position. Similarly, the RIGHT procedure can quickly compute 2i C1 by shifting the binary representation of i left by one bit position and then adding in a 1 as the low-order bit. The PARENT procedure can compute bi=2c by shifting i right one bit position. Good implementations of heapsort often implement these procedures as “macros” or “in- line” procedures.
There are two kinds of binary heaps: max-heaps and min-heaps. In both kinds, the values in the nodes satisfy a heap property, the specifics of which depend on the kind of heap. In a max-heap, the max-heap property is that for every node i other than the root,
AŒPARENT.i/􏳩 􏳦 AŒi􏳩 ;
that is, the value of a node is at most the value of its parent. Thus, the largest element in a max-heap is stored at the root, and the subtree rooted at a node contains

6.1 Heaps 153
values no larger than that contained at the node itself. A min-heap is organized in the opposite way; the min-heap property is that for every node i other than the root,
AŒPARENT.i/􏳩 􏳥 AŒi􏳩 :
The smallest element in a min-heap is at the root.
For the heapsort algorithm, we use max-heaps. Min-heaps commonly imple-
ment priority queues, which we discuss in Section 6.5. We shall be precise in specifying whether we need a max-heap or a min-heap for any particular applica- tion, and when properties apply to either max-heaps or min-heaps, we just use the term “heap.”
Viewing a heap as a tree, we define the height of a node in a heap to be the number of edges on the longest simple downward path from the node to a leaf, and we define the height of the heap to be the height of its root. Since a heap of n ele- ments is based on a complete binary tree, its height is ‚.lg n/ (see Exercise 6.1-2). We shall see that the basic operations on heaps run in time at most proportional to the height of the tree and thus take O.lg n/ time. The remainder of this chapter presents some basic procedures and shows how they are used in a sorting algorithm and a priority-queue data structure.
The MAX-HEAPIFY procedure, which runs in O.lg n/ time, is the key to main- taining the max-heap property.
The BUILD-MAX-HEAP procedure, which runs in linear time, produces a max- heap from an unordered input array.
The HEAPSORT procedure, which runs in O.nlgn/ time, sorts an array in place.
The MAX-HEAP-INSERT, HEAP-EXTRACT-MAX, HEAP-INCREASE-KEY, and HEAP-MAXIMUM procedures, which run in O.lg n/ time, allow the heap data structure to implement a priority queue.
Exercises
6.1-1
What are the minimum and maximum numbers of elements in a heap of height h? 6.1-2
Show that an n-element heap has height blg nc.
6.1-3
Show that in any subtree of a max-heap, the root of the subtree contains the largest value occurring anywhere in that subtree.
􏳮
􏳮
􏳮
􏳮

154 Chapter 6 Heapsort
6.1-4
Where in a max-heap might the smallest element reside, assuming that all elements are distinct?
6.1-5
Is an array that is in sorted order a min-heap?
6.1-6
Is the array with values h23; 17; 14; 6; 13; 10; 1; 5; 7; 12i a max-heap?
6.1-7
Show that, with the array representation for storing an n-element heap, the leaves are the nodes indexed by bn=2c C 1; bn=2c C 2; : : : ; n.
6.2 Maintaining the heap property
In order to maintain the max-heap property, we call the procedure MAX-HEAPIFY. Its inputs are an array A and an index i into the array. When it is called, MAX- HEAPIFY assumes that the binary trees rooted at LEFT.i/ and RIGHT.i/ are max- heaps, but that AŒi􏳩 might be smaller than its children, thus violating the max-heap property. MAX-HEAPIFY lets the value at AŒi􏳩 “float down” in the max-heap so that the subtree rooted at index i obeys the max-heap property.
MAX-HEAPIFY.A;i/
1 2 3 4 5 6 7 8 9
10
l D LEFT.i/
r D RIGHT.i/
if l 􏳥 A:heap-size and AŒl􏳩 > AŒi􏳩
largest D l else largest D i
if r 􏳥 A:heap-size and AŒr􏳩 > AŒlargest􏳩 largest D r
if largest ¤ i
exchange AŒi􏳩 with AŒlargest􏳩 MAX-HEAPIFY.A;largest/
Figure 6.2 illustrates the action of MAX-HEAPIFY. At each step, the largest of the elements AŒi􏳩, AŒLEFT.i/􏳩, and AŒRIGHT.i/􏳩 is determined, and its index is stored in largest. If AŒi􏳩 is largest, then the subtree rooted at node i is already a max-heap and the procedure terminates. Otherwise, one of the two children has the largest element, and AŒi􏳩 is swapped with AŒlargest􏳩, which causes node i and its

6.2
Maintaining the heap property 155
11
16 16 2323
i4 10 14 10 45674567 14 79 3 i4 79 3
8 9 10 8 9 10 281 281
(a) (b)
1
16 23
14 10 4567 8793
8 9i10 241
(c)
Figure 6.2 The action of MAX-HEAPIFY.A;2/, where A:heap-size D 10. (a) The initial con- figuration, with AŒ2􏳩 at node i D 2 violating the max-heap property since it is not larger than both children. The max-heap property is restored for node 2 in (b) by exchanging AŒ2􏳩 with AŒ4􏳩, which destroys the max-heap property for node 4. The recursive call M A X – H E A P I F Y.A; 4/ now has i D 4. After swapping AŒ4􏳩 with AŒ9􏳩, as shown in (c), node 4 is fixed up, and the recursive call MAX-HEAPIFY.A;9/ yields no further change to the data structure.
children to satisfy the max-heap property. The node indexed by largest, however, now has the original value AŒi􏳩, and thus the subtree rooted at largest might violate the max-heap property. Consequently, we call MAX-HEAPIFY recursively on that subtree.
The running time of MAX-HEAPIFY on a subtree of size n rooted at a given node i is the ‚.1/ time to fix up the relationships among the elements AŒi􏳩, AŒLEFT.i/􏳩, and AŒRIGHT.i/􏳩, plus the time to run MAX-HEAPIFY on a subtree rooted at one of the children of node i (assuming that the recursive call occurs). The children’s subtrees each have size at most 2n=3—the worst case occurs when the bottom level of the tree is exactly half full—and therefore we can describe the running time of MAX-HEAPIFY by the recurrence
T.n/ 􏳥 T.2n=3/ C ‚.1/ :

156 Chapter 6 Heapsort
The solution to this recurrence, by case 2 of the master theorem (Theorem 4.1), is T.n/ D O.lgn/. Alternatively, we can characterize the running time of MAX- HEAPIFY on a node of height h as O.h/.
Exercises
6.2-1
Using Figure 6.2 as a model, illustrate the operation of MAX-HEAPIFY.A;3/ on the array A D h27;17;3;16;13;10;1;5;7;12;4;8;9;0i.
6.2-2
Starting with the procedure MAX-HEAPIFY, write pseudocode for the procedure MIN-HEAPIFY.A;i/, which performs the corresponding manipulation on a min- heap. How does the running time of MIN-HEAPIFY compare to that of MAX- HEAPIFY?
6.2-3
What is the effect of calling MAX-HEAPIFY.A;i/ when the element AŒi􏳩 is larger than its children?
6.2-4
What is the effect of calling MAX-HEAPIFY.A;i/ for i > A:heap-size=2?
6.2-5
The code for MAX-HEAPIFY is quite efficient in terms of constant factors, except possibly for the recursive call in line 10, which might cause some compilers to produce inefficient code. Write an efficient MAX-HEAPIFY that uses an iterative control construct (a loop) instead of recursion.
6.2-6
Show that the worst-case running time of MAX-HEAPIFY on a heap of size n is 􏳫.lg n/. (Hint: For a heap with n nodes, give node values that cause M A X – HEAPIFY to be called recursively at every node on a simple path from the root down to a leaf.)
6.3 Building a heap
We can use the procedure MAX-HEAPIFY in a bottom-up manner to convert an array AŒ1 : : n􏳩, where n D A: length, into a max-heap. By Exercise 6.1-7, the elements in the subarray AŒ.bn=2cC1/ : : n􏳩 are all leaves of the tree, and so each is

6.3 Building a heap 157
a 1-element heap to begin with. The procedure BUILD-MAX-HEAP goes through the remaining nodes of the tree and runs MAX-HEAPIFY on each one.
BUILD-MAX-HEAP.A/
1 A:heap-size D A:length
2 for i D bA:length=2c downto 1
3 MAX-HEAPIFY.A;i/
Figure 6.3 shows an example of the action of BUILD-MAX-HEAP.
To show why BUILD-MAX-HEAP works correctly, we use the following loop
invariant:
At the start of each iteration of the for loop of lines 2–3, each node i C 1;
i C 2; : : : ; n is the root of a max-heap.
We need to show that this invariant is true prior to the first loop iteration, that each iteration of the loop maintains the invariant, and that the invariant provides a useful property to show correctness when the loop terminates.
Initialization: Prior to the first iteration of the loop, i D bn=2c. Each node bn=2cC1;bn=2cC2;:::;n is a leaf and is thus the root of a trivial max-heap.
Maintenance: To see that each iteration maintains the loop invariant, observe that the children of node i are numbered higher than i. By the loop invariant, there- fore, they are both roots of max-heaps. This is precisely the condition required for the call MAX-HEAPIFY.A;i/ to make node i a max-heap root. Moreover, the MAX-HEAPIFY call preserves the property that nodes i C 1; i C 2; : : : ; n are all roots of max-heaps. Decrementing i in the for loop update reestablishes the loop invariant for the next iteration.
Termination: At termination, i D 0. By the loop invariant, each node 1; 2; : : : ; n is the root of a max-heap. In particular, node 1 is.
We can compute a simple upper bound on the running time of BUILD-MAX- HEAP as follows. Each call to MAX-HEAPIFY costs O.lgn/ time, and BUILD- MAX-HEAP makes O.n/ such calls. Thus, the running time is O.n lg n/. This upper bound, though correct, is not asymptotically tight.
We can derive a tighter bound by observing that the time for MAX-HEAPIFY to run at a node varies with the height of the node in the tree, and the heights of most nodes are small. Our tighter analysis relies on the properties that an n-element heap has height blg nc (see Exercise 6.1-2) and at most ̇n=2hC1􏳽 nodes of any height h (see Exercise 6.3-3).
The time required by MAX-HEAPIFY when called on a node of height h is O.h/, and so we can express the total cost of BUILD-MAX-HEAP as being bounded from above by

158 Chapter 6
Heapsort
4
1
3
2
16
9
10
14
8
7
A
11
44 2323 1313 45674567
2 i169 10 i2 169 10
8 9 10 14 8 7
(a)
8 9 10 14 8 7
(b)
11
44 2323
1 3i i1 10 45674567
14 169 10 14 169 3 8 9 10 8 9 10
287 287
(c) (d)
11 i4 16
2323
16 10 14 10 45674567
14 79 3 8 79 3 8 9 10 8 9 10
281 241
(e) (f)
Figure 6.3 The operation of BUILD-MAX-HEAP, showing the data structure before the call to MAX-HEAPIFY in line 3 of BUILD-MAX-HEAP. (a) A 10-element input array A and the bi- nary tree it represents. The figure shows that the loop index i refers to node 5 before the call MAX-HEAPIFY.A;i/. (b) The data structure that results. The loop index i for the next iteration refers to node 4. (c)–(e) Subsequent iterations of the for loop in BUILD-MAX-HEAP. Observe that whenever MAX-HEAPIFY is called on a node, the two subtrees of that node are both max-heaps. (f) The max-heap after BUILD-MAX-HEAP finishes.

6.4 The heapsort algorithm 159
! X n O.h/DOnXh :
blg nc l m blg nc
2hC1 2h hD0
hD0
We evalaute the last summation by substituting x D 1=2 in the formula (A.8),
yielding
X1 h D 1=2 hD0 2h .1 􏳣 1=2/2
D2:
Thus, we can bound the running time of BUILD-MAX-HEAP as
blgnc ! 1 ! OnXhDOnXh
hD0
2h 2h hD0
D O.n/:
Hence, we can build a max-heap from an unordered array in linear time.
We can build a min-heap by the procedure BUILD-MIN-HEAP, which is the same as BUILD-MAX-HEAP but with the call to MAX-HEAPIFY in line 3 replaced by a call to MIN-HEAPIFY (see Exercise 6.2-2). BUILD-MIN-HEAP produces a
min-heap from an unordered linear array in linear time.
Exercises
6.3-1
Using Figure 6.3 as a model, illustrate the operation of BUILD-MAX-HEAP on the array A D h5;3;17;10;84;19;6;22;9i.
6.3-2
Why do we want the loop index i in line 2 of BUILD-MAX-HEAP to decrease from bA:length=2c to 1 rather than increase from 1 to bA:length=2c?
6.3-3 ̇ hC1􏳽
Show that there are at most n=2 nodes of height h in any n-element heap.
6.4 The heapsort algorithm
The heapsort algorithm starts by using BUILD-MAX-HEAP to build a max-heap on the input array AŒ1::n􏳩, where n D A:length. Since the maximum element of the array is stored at the root AŒ1􏳩, we can put it into its correct final position

160 Chapter 6 Heapsort
by exchanging it with AŒn􏳩. If we now discard node n from the heap—and we can do so by simply decrementing A:heap-size—we observe that the children of the root remain max-heaps, but the new root element might violate the max-heap property. All we need to do to restore the max-heap property, however, is call MAX-HEAPIFY.A;1/, which leaves a max-heap in AŒ1::n 􏳣 1􏳩. The heapsort algorithm then repeats this process for the max-heap of size n 􏳣 1 down to a heap of size 2. (See Exercise 6.4-2 for a precise loop invariant.)
HEAPSORT.A/
1 2 3 4 5
BUILD-MAX-HEAP.A/
for i D A:length downto 2
exchange AŒ1􏳩 with AŒi􏳩 A:heap-size D A:heap-size 􏳣 1 MAX-HEAPIFY.A;1/
Figure 6.4 shows an example of the operation of HEAPSORT after line 1 has built the initial max-heap. The figure shows the max-heap before the first iteration of the for loop of lines 2–5 and after each iteration.
The HEAPSORT procedure takes time O.n lg n/, since the call to BUILD-MAX- HEAP takes time O.n/ and each of the n 􏳣 1 calls to MAX-HEAPIFY takes time O.lg n/.
Exercises
6.4-1
Using Figure 6.4 as a model, illustrate the operation of HEAPSORT on the array A D h5;13;2;25;7;17;20;8;4i.
6.4-2
Argue the correctness of HEAPSORT using the following loop invariant:
At the start of each iteration of the for loop of lines 2–5, the subarray AŒ1 : : i 􏳩 is a max-heap containing the i smallest elements of AŒ1 : : n􏳩, and the subarray AŒi C 1 : : n􏳩 contains the n 􏳣 i largest elements of AŒ1 : : n􏳩, sorted.
6.4-3
What is the running time of HEAPSORT on an array A of length n that is already sorted in increasing order? What about decreasing order?
6.4-4
Show that the worst-case running time of HEAPSORT is 􏳫.n lg n/.

6.4 The heapsort algorithm 161
16 14 10
14 10 8 10 8 9
8793 4793 4713
2 4 1 2 1 16 i (a)
i
2 14 16
(b)
(c)
987 837343 4712 421i9 128i9
i 10 14 16 10 14 16 (d)
10 14 16
(e)
(f)
432 23 21 13i
1i789i47894789
10 14 16
(g)
1 i23
10 14 16
10 14 16
(h)
(k)
(i)
1
2
3
4
7
8
9
10
14
16
A
4789 10 14 16
(j)
Figure 6.4 The operation of HEAPSORT. (a) The max-heap data structure just after BUILD-MAX- HEAP has built it in line 1. (b)–(j) The max-heap just after each call of MAX-HEAPIFY in line 5, showing the value of i at that time. Only lightly shaded nodes remain in the heap. (k) The resulting sorted array A.

162
Chapter 6 Heapsort
6.5
6.4-5 ?
Show that when all elements are distinct, the best-case running time of HEAPSORT is 􏳫.n lg n/.
Priority queues
Heapsort is an excellent algorithm, but a good implementation of quicksort, pre- sented in Chapter 7, usually beats it in practice. Nevertheless, the heap data struc- ture itself has many uses. In this section, we present one of the most popular ap- plications of a heap: as an efficient priority queue. As with heaps, priority queues come in two forms: max-priority queues and min-priority queues. We will focus here on how to implement max-priority queues, which are in turn based on max- heaps; Exercise 6.5-3 asks you to write the procedures for min-priority queues.
A priority queue is a data structure for maintaining a set S of elements, each with an associated value called a key. A max-priority queue supports the following operations:
INSERT.S;x/ inserts the element x into the set S, which is equivalent to the oper- ation S D S [ fxg.
MAXIMUM.S/ returns the element of S with the largest key.
EXTRACT-MAX.S/ removes and returns the element of S with the largest key.
INCREASE-KEY.S;x;k/ increases the value of element x’s key to the new value k, which is assumed to be at least as large as x’s current key value.
Among their other applications, we can use max-priority queues to schedule jobs on a shared computer. The max-priority queue keeps track of the jobs to be performed and their relative priorities. When a job is finished or interrupted, the scheduler selects the highest-priority job from among those pending by calling EXTRACT-MAX. The scheduler can add a new job to the queue at any time by calling INSERT.
Alternatively, a min-priority queue supports the operations INSERT, MINIMUM, EXTRACT-MIN, and DECREASE-KEY. A min-priority queue can be used in an event-driven simulator. The items in the queue are events to be simulated, each with an associated time of occurrence that serves as its key. The events must be simulated in order of their time of occurrence, because the simulation of an event can cause other events to be simulated in the future. The simulation program calls EXTRACT-MIN at each step to choose the next event to simulate. As new events are produced, the simulator inserts them into the min-priority queue by calling INSERT.

6.5 Priority queues 163
We shall see other uses for min-priority queues, highlighting the DECREASE-KEY operation, in Chapters 23 and 24.
Not surprisingly, we can use a heap to implement a priority queue. In a given ap- plication, such as job scheduling or event-driven simulation, elements of a priority queue correspond to objects in the application. We often need to determine which application object corresponds to a given priority-queue element, and vice versa. When we use a heap to implement a priority queue, therefore, we often need to store a handle to the corresponding application object in each heap element. The exact makeup of the handle (such as a pointer or an integer) depends on the ap- plication. Similarly, we need to store a handle to the corresponding heap element in each application object. Here, the handle would typically be an array index. Because heap elements change locations within the array during heap operations, an actual implementation, upon relocating a heap element, would also have to up- date the array index in the corresponding application object. Because the details of accessing application objects depend heavily on the application and its imple- mentation, we shall not pursue them here, other than noting that in practice, these handles do need to be correctly maintained.
Now we discuss how to implement the operations of a max-priority queue. The procedure HEAP-MAXIMUM implements the MAXIMUM operation in ‚.1/ time.
HEAP-MAXIMUM.A/ 1 return AŒ1􏳩
The procedure HEAP-EXTRACT-MAX implements the EXTRACT-MAX opera- tion. It is similar to the for loop body (lines 3–5) of the HEAPSORT procedure.
HEAP-EXTRACT-MAX.A/ 1 if A: heap-size < 1 2 3 max D AŒ1􏳩 4 AŒ1􏳩 D AŒA: heap-size􏳩 5 A: heap-size D A: heap-size 􏳣 1 6 MAX-HEAPIFY.A;1/ 7 return max The running time of HEAP-EXTRACT-MAX is O.lgn/, since it performs only a constant amount of work on top of the O.lg n/ time for MAX-HEAPIFY. The procedure HEAP-INCREASE-KEY implements the INCREASE-KEY opera- tion. An index i into the array identifies the priority-queue element whose key we wish to increase. The procedure first updates the key of element AŒi􏳩 to its new value. Because increasing the key of AŒi􏳩 might violate the max-heap property, error “heap underflow” 164 Chapter 6 Heapsort the procedure then, in a manner reminiscent of the insertion loop (lines 5–7) of INSERTION-SORT from Section 2.1, traverses a simple path from this node toward the root to find a proper place for the newly increased key. As HEAP-INCREASE- KEY traverses this path, it repeatedly compares an element to its parent, exchang- ing their keys and continuing if the element’s key is larger, and terminating if the el- ement’s key is smaller, since the max-heap property now holds. (See Exercise 6.5-5 for a precise loop invariant.) HEAP-INCREASE-KEY.A;i;key/ 1 2 3 4 5 6 ifkey 1 and AŒPARENT.i/􏳩 < AŒi􏳩 exchange AŒi􏳩 with AŒPARENT.i/􏳩 i D PARENT.i/ Figure 6.5 shows an example of a HEAP-INCREASE-KEY operation. The running time of HEAP-INCREASE-KEY on an n-element heap is O.lgn/, since the path traced from the node updated in line 3 to the root has length O.lg n/. The procedure MAX-HEAP-INSERT implements the INSERT operation. It takes as an input the key of the new element to be inserted into max-heap A. The proce- dure first expands the max-heap by adding to the tree a new leaf whose key is 􏳣1. Then it calls HEAP-INCREASE-KEY to set the key of this new node to its correct value and maintain the max-heap property. MAX-HEAP-INSERT.A;key/ 1 A: heap-size D A: heap-size C 1 2 AŒA: heap-size􏳩 D 􏳣1 3 HEAP-INCREASE-KEY.A;A:heap-size;key/ The running time of MAX-HEAP-INSERT on an n-element heap is O.lg n/. In summary, a heap can support any priority-queue operation on a set of size n in O.lg n/ time. Exercises 6.5-1 Illustrate the operation of HEAP-EXTRACT-MAX on the heap A D h15; 13; 9; 5; 12;8;7;4;0;6;2;1i. 6.5 Priority queues 165 16 16 14 10 14 10 87938793 ii 2 4 1 (a) 2 15 1 (b) 16 14 10 15 10 i 15 79 3 14 79 3 281 281 (c) (d) Figure 6.5 The operation of HEAP-INCREASE-KEY. (a) The max-heap of Figure 6.4(a) with a node whose index is i heavily shaded. (b) This node has its key increased to 15. (c) After one iteration of the while loop of lines 4–6, the node and its parent have exchanged keys, and the index i moves up to the parent. (d) The max-heap after one more iteration of the while loop. At this point, AŒPARENT.i/􏳩 􏳦 AŒi􏳩. The max-heap property now holds and the procedure terminates. 6.5-2 Illustrate the operation of MAX-HEAP-INSERT.A;10/ on the heap A D h15;13;9; 5;12;8;7;4;0;6;2;1i. 6.5-3 Write pseudocode for the procedures HEAP-MINIMUM, HEAP-EXTRACT-MIN, HEAP-DECREASE-KEY, and MIN-HEAP-INSERT that implement a min-priority queue with a min-heap. 6.5-4 Why do we bother setting the key of the inserted node to 􏳣1 in line 2 of MAX- HEAP-INSERT when the next thing we do is increase its key to the desired value? i 16 166 Chapter 6 Heapsort Problems 6.5-5 Argue the correctness of HEAP-INCREASE-KEY using the following loop invari- ant: At the start of each iteration of the while loop of lines 4–6, the subarray AŒ1::A:heap-size􏳩 satisfies the max-heap property, except that there may be one violation: AŒi􏳩 may be larger than AŒPARENT.i/􏳩. You may assume that the subarray AŒ1 : : A: heap-size􏳩 satisfies the max-heap prop- erty at the time HEAP-INCREASE-KEY is called. 6.5-6 Each exchange operation on line 5 of HEAP-INCREASE-KEY typically requires three assignments. Show how to use the idea of the inner loop of INSERTION- SORT to reduce the three assignments down to just one assignment. 6.5-7 Show how to implement a first-in, first-out queue with a priority queue. Show how to implement a stack with a priority queue. (Queues and stacks are defined in Section 10.1.) 6.5-8 The operation HEAP-DELETE.A;i/ deletes the item in node i from heap A. Give an implementation of HEAP-DELETE that runs in O.lgn/ time for an n-element max-heap. 6.5-9 Give an O.nlgk/-time algorithm to merge k sorted lists into one sorted list, where n is the total number of elements in all the input lists. (Hint: Use a min- heap for k-way merging.) 6-1 Building a heap using insertion We can build a heap by repeatedly calling MAX-HEAP-INSERT to insert the ele- ments into the heap. Consider the following variation on the BUILD-MAX-HEAP procedure: Problems for Chapter 6 167 BUILD-MAX-HEAP0 .A/ 1 A:heap-size D 1 2 foriD2toA:length 3 MAX-HEAP-INSERT.A;AŒi􏳩/ Do the procedures BUILD-MAX-HEAP and BUILD-MAX-HEAP0 always create the same heap when run on the same input array? Prove that they do, or provide a counterexample. Show that in the worst case, BUILD-MAX-HEAP0 requires ‚.nlgn/ time to build an n-element heap. a. Howwouldyourepresentad-aryheapinanarray? b. What is the height of a d-ary heap of n elements in terms of n and d? c. Give an efficient implementation of EXTRACT-MAX in a d-ary max-heap. An- alyze its running time in terms of d and n. d. Give an efficient implementation of INSERT in a d-ary max-heap. Analyze its running time in terms of d and n. e. Give an efficient implementation of INCREASE-KEY.A;i;k/, which flags an error if k < AŒi 􏳩, but otherwise sets AŒi 􏳩 D k and then updates the d -ary max- heap structure appropriately. Analyze its running time in terms of d and n. 6-3 Young tableaus An m 􏳨 n Young tableau is an m 􏳨 n matrix such that the entries of each row are in sorted order from left to right and the entries of each column are in sorted order from top to bottom. Some of the entries of a Young tableau may be 1, which we treat as nonexistent elements. Thus, a Young tableau can be used to hold r 􏳥 mn finite numbers. a. Drawa4􏳨4Youngtableaucontainingtheelementsf9;16;3;2;4;8;5;14;12g. b. Argue that an m 􏳨 n Young tableau Y is empty if YŒ1;1􏳩 D 1. Argue that Y is full (contains mn elements) if Y Œm; n􏳩 < 1. a. b. Analysis of d-ary heaps 6-2 A d-ary heap is like a binary heap, but (with one possible exception) non-leaf nodes have d children instead of 2 children. 168 Chapter 6 Heapsort c. Give an algorithm to implement EXTRACT-MIN on a nonempty m 􏳨 n Young tableau that runs in O.m C n/ time. Your algorithm should use a recur- sive subroutine that solves an m 􏳨 n problem by recursively solving either an .m􏳣1/􏳨n or an m􏳨.n􏳣1/ subproblem. (Hint: Think about MAX- HEAPIFY.) Define T .p/, where p D m C n, to be the maximum running time of EXTRACT-MIN on any m 􏳨 n Young tableau. Give and solve a recurrence for T .p/ that yields the O.m C n/ time bound. d. Show how to insert a new element into a nonfull m 􏳨 n Young tableau in O.m C n/ time. e. Using no other sorting method as a subroutine, show how to use an n 􏳨 n Young tableau to sort n2 numbers in O.n3/ time. f. Give an O.m C n/-time algorithm to determine whether a given number is stored in a given m 􏳨 n Young tableau. Chapter notes The heapsort algorithm was invented by Williams [357], who also described how to implement a priority queue with a heap. The BUILD-MAX-HEAP procedure was suggested by Floyd [106]. We use min-heaps to implement min-priority queues in Chapters 16, 23, and 24. We also give an implementation with improved time bounds for certain operations in Chapter 19 and, assuming that the keys are drawn from a bounded set of non- negative integers, Chapter 20. If the data are b-bit integers, and the computer memory consists of addressable b-bit words, Fredman and Willard [115] showed how to implement MINIMUM in lgn/ time. Thorup [337] has lg n/ bound to O.lg lg n/ time. This bound uses an amount of space unbounded in n, but it can be implemented in linear space by using random- ized hashing. An important special case of priority queues occurs when the sequence of EXTRACT-MIN operations is monotone, that is, the values returned by succes- sive EXTRACT-MIN operations are monotonically increasing over time. This case arises in several important applications, such as Dijkstra’s single-source shortest- paths algorithm, which we discuss in Chapter 24, and in discrete-event simula- tion. For Dijkstra’s algorithm it is particularly important that the DECREASE-KEY operation be implemented efficiently. For the monotone case, if the data are in- tegers in the range 1;2;:::;C, Ahuja, Mehlhorn, Orlin, and Tarjan [8] describe O.1/ time and INSERT and EXTRACT-MIN in O. p improved the O. p Notes for Chapter 6 169 how to implement EXTRACT-MIN and INSERT in O.lgC/ amortized time (see Chapter 17 for more on amortized analysis) and DECREASE-KEY in O.1/ time, using a data structure called a radix heap. The O.lgC/ bound can be improved p lgC/ using Fibonacci heaps (see Chapter 19) in conjunction with radix heaps. Cherkassky, Goldberg, and Silverstein [65] further improved the bound to O.lg1=3C􏳮 C/ expected time by combining the multilevel bucketing structure of Denardo and Fox [85] with the heap of Thorup mentioned earlier. Raman [291] further improved these results to obtain a bound of O.min.lg1=4C􏳮 C;lg1=3C􏳮 n//, for any fixed 􏳮 > 0.
to O.

7 Quicksort
The quicksort algorithm has a worst-case running time of ‚.n2/ on an input array of n numbers. Despite this slow worst-case running time, quicksort is often the best practical choice for sorting because it is remarkably efficient on the average: its expected running time is ‚.n lg n/, and the constant factors hidden in the ‚.n lg n/ notation are quite small. It also has the advantage of sorting in place (see page 17), and it works well even in virtual-memory environments.
Section 7.1 describes the algorithm and an important subroutine used by quick- sort for partitioning. Because the behavior of quicksort is complex, we start with an intuitive discussion of its performance in Section 7.2 and postpone its precise analysis to the end of the chapter. Section 7.3 presents a version of quicksort that uses random sampling. This algorithm has a good expected running time, and no particular input elicits its worst-case behavior. Section 7.4 analyzes the random- ized algorithm, showing that it runs in ‚.n2/ time in the worst case and, assuming distinct elements, in expected O.n lg n/ time.
7.1 Description of quicksort
Quicksort, like merge sort, applies the divide-and-conquer paradigm introduced in Section 2.3.1. Here is the three-step divide-and-conquer process for sorting a typical subarray AŒp : : r 􏳩:
Divide: Partition (rearrange) the array AŒp : : r 􏳩 into two (possibly empty) subar- raysAŒp::q􏳣1􏳩andAŒqC1::r􏳩suchthateachelementofAŒp :: q􏳣1􏳩is less than or equal to AŒq􏳩, which is, in turn, less than or equal to each element of AŒq C 1 : : r 􏳩. Compute the index q as part of this partitioning procedure.
Conquer: SortthetwosubarraysAŒp::q􏳣1􏳩andAŒqC1::r􏳩byrecursivecalls to quicksort.

7.1 Description of quicksort 171
Combine: Becausethesubarraysarealreadysorted,noworkisneededtocombine them: the entire array AŒp : : r 􏳩 is now sorted.
The following procedure implements quicksort: QUICKSORT.A; p; r/
1 ifp x. 3. If k D r, then AŒk􏳩 D x.

172 Chapter 7 Quicksort
i p,j
r
2
8
7
1
3
5
6
4
(a)
(b)
(c)
(d)
(e)
(f)
(g)
(h)
(i)
p,i j r
p,ij r
p,i j r
pijr
pijr
pijr
pir
pir
2
8
7
1
3
5
6
4
2
8
7
1
3
5
6
4
2
8
7
1
3
5
6
4
2
1
7
8
3
5
6
4
2
1
3
8
7
5
6
4
2
1
3
8
7
5
6
4
2
1
3
8
7
5
6
4
2
1
3
4
7
5
6
8
Figure 7.1 The operation of PARTITION on a sample array. Array entry AŒr􏳩 becomes the pivot element x. Lightly shaded array elements are all in the first partition with values no greater than x. Heavily shaded elements are in the second partition with values greater than x. The unshaded el- ements have not yet been put in one of the first two partitions, and the final white element is the pivot x. (a) The initial array and variable settings. None of the elements have been placed in either of the first two partitions. (b) The value 2 is “swapped with itself” and put in the partition of smaller values. (c)–(d) The values 8 and 7 are added to the partition of larger values. (e) The values 1 and 8 are swapped, and the smaller partition grows. (f) The values 3 and 7 are swapped, and the smaller partition grows. (g)–(h) The larger partition grows to include 5 and 6, and the loop terminates. (i) In lines 7–8, the pivot element is swapped so that it lies between the two partitions.
The indices between j and r 􏳣 1 are not covered by any of the three cases, and the values in these entries have no particular relationship to the pivot x.
We need to show that this loop invariant is true prior to the first iteration, that each iteration of the loop maintains the invariant, and that the invariant provides a useful property to show correctness when the loop terminates.

7.1 Description of quicksort 173
pijr
≤ x > x unrestricted
Figure 7.2 The four regions maintained by the procedure PARTITION on a subarray AŒp : : r􏳩. The values in AŒp : : i􏳩 are all less than or equal to x, the values in AŒi C 1 : : j 􏳣 1􏳩 are all greater than x, and AŒr􏳩 D x. The subarray AŒj : : r 􏳣 1􏳩 can take on any values.
Initialization: Prior to the first iteration of the loop, i D p 􏳣 1 and j D p. Be- cause no values lie between p and i and no values lie between i C 1 and j 􏳣 1, the first two conditions of the loop invariant are trivially satisfied. The assign- ment in line 1 satisfies the third condition.
Maintenance: As Figure 7.3 shows, we consider two cases, depending on the outcome of the test in line 4. Figure 7.3(a) shows what happens when AŒj 􏳩 > x; the only action in the loop is to increment j . After j is incremented, condition 2 holds for AŒj 􏳣 1􏳩 and all other entries remain unchanged. Figure 7.3(b) shows what happens when AŒj􏳩 􏳥 x; the loop increments i, swaps AŒi􏳩 and AŒj􏳩, and then increments j. Because of the swap, we now have that AŒi􏳩 􏳥 x, and condition 1 is satisfied. Similarly, we also have that AŒj 􏳣 1􏳩 > x, since the item that was swapped into AŒj 􏳣 1􏳩 is, by the loop invariant, greater than x.
Termination: At termination, j D r. Therefore, every entry in the array is in one of the three sets described by the invariant, and we have partitioned the values in the array into three sets: those less than or equal to x, those greater than x, and a singleton set containing x.
The final two lines of PARTITION finish up by swapping the pivot element with the leftmost element greater than x, thereby moving the pivot into its correct place in the partitioned array, and then returning the pivot’s new index. The output of PARTITION now satisfies the specifications given for the divide step. In fact, it satisfies a slightly stronger condition: after line 2 of QUICKSORT, AŒq􏳩 is strictly less than every element of AŒq C 1 : : r􏳩.
The running time of PARTITION on the subarray AŒp : : r􏳩 is ‚.n/, where n D r 􏳣 p C 1 (see Exercise 7.1-3).
Exercises
7.1-1
Using Figure 7.1 as a model, illustrate the operation of PARTITION on the array A D h13;19;9;5;12;8;7;4;21;2;6;11i.
x

174
Chapter 7 Quicksort
pijr
(a)
>x
x
≤x >x pijr
≤x >x pijr
x
≤x
x
(b)
≤x >x pijr
≤x >x
x
7.2
Figure 7.3 The two cases for one iteration of procedure PARTITION. (a) If AŒj􏳩 > x, the only action is to increment j , which maintains the loop invariant. (b) If AŒj 􏳩 􏳥 x, index i is incremented, AŒi􏳩 and AŒj􏳩 are swapped, and then j is incremented. Again, the loop invariant is maintained.
7.1-2
What value of q does PARTITION return when all elements in the array AŒp : : r􏳩 have the same value? Modify PARTITION so that q D b.p C r/=2c when all elements in the array AŒp : : r 􏳩 have the same value.
7.1-3
Give a brief argument that the running time of PARTITION on a subarray of size n is ‚.n/.
7.1-4
How would you modify QUICKSORT to sort into nonincreasing order?
Performance of quicksort
The running time of quicksort depends on whether the partitioning is balanced or unbalanced, which in turn depends on which elements are used for partitioning. If the partitioning is balanced, the algorithm runs asymptotically as fast as merge

7.2 Performance of quicksort 175
sort. If the partitioning is unbalanced, however, it can run asymptotically as slowly as insertion sort. In this section, we shall informally investigate how quicksort performs under the assumptions of balanced versus unbalanced partitioning.
Worst-case partitioning
The worst-case behavior for quicksort occurs when the partitioning routine pro- duces one subproblem with n 􏳣 1 elements and one with 0 elements. (We prove this claim in Section 7.4.1.) Let us assume that this unbalanced partitioning arises in each recursive call. The partitioning costs ‚.n/ time. Since the recursive call on an array of size 0 just returns, T .0/ D ‚.1/, and the recurrence for the running time is
T.n/ D T.n􏳣1/CT.0/C‚.n/ D T.n􏳣1/C‚.n/:
Intuitively, if we sum the costs incurred at each level of the recursion, we get an arithmetic series (equation (A.2)), which evaluates to ‚.n2/. Indeed, it is straightforward to use the substitution method to prove that the recurrence T .n/ D T .n 􏳣 1/ C ‚.n/ has the solution T .n/ D ‚.n2 /. (See Exercise 7.2-1.)
Thus, if the partitioning is maximally unbalanced at every recursive level of the algorithm, the running time is ‚.n2/. Therefore the worst-case running time of quicksort is no better than that of insertion sort. Moreover, the ‚.n2/ running time occurs when the input array is already completely sorted—a common situation in which insertion sort runs in O.n/ time.
Best-case partitioning
In the most even possible split, PARTITION produces two subproblems, each of size no more than n=2, since one is of size bn=2c and one of size dn=2e 􏳣 1. In this case, quicksort runs much faster. The recurrence for the running time is then
T.n/ D 2T.n=2/ C ‚.n/ ;
where we tolerate the sloppiness from ignoring the floor and ceiling and from sub- tracting 1. By case 2 of the master theorem (Theorem 4.1), this recurrence has the solution T .n/ D ‚.n lg n/. By equally balancing the two sides of the partition at every level of the recursion, we get an asymptotically faster algorithm.
Balanced partitioning
The average-case running time of quicksort is much closer to the best case than to the worst case, as the analyses in Section 7.4 will show. The key to understand-

176 Chapter 7 Quicksort
n
1n 9n
1n 9n 9n 81n
cn
cn cn cn
􏳥 cn 􏳥 cn
O.nlgn/
10 10
log10 n
1
100
100
100
100
81n 729n 1000 1000
log10=9 n
A recursion tree for QUICKSORT in which PARTITION always produces a 9-to-1 split, yielding a running time of O.n lg n/. Nodes show subproblem sizes, with per-level costs on the right. The per-level costs include the constant c implicit in the ‚.n/ term.
ing why is to understand how the balance of the partitioning is reflected in the recurrence that describes the running time.
Suppose, for example, that the partitioning algorithm always produces a 9-to-1 proportional split, which at first blush seems quite unbalanced. We then obtain the recurrence
T .n/ D T .9n=10/ C T .n=10/ C cn ;
on the running time of quicksort, where we have explicitly included the constant c hidden in the ‚.n/ term. Figure 7.4 shows the recursion tree for this recurrence. Notice that every level of the tree has cost cn, until the recursion reaches a bound- ary condition at depth log10 n D ‚.lg n/, and then the levels have cost at most cn. The recursion terminates at depth log10=9 n D ‚.lg n/. The total cost of quick- sort is therefore O.n lg n/. Thus, with a 9-to-1 proportional split at every level of recursion, which intuitively seems quite unbalanced, quicksort runs in O.n lg n/ time—asymptotically the same as if the split were right down the middle. Indeed, even a 99-to-1 split yields an O.n lg n/ running time. In fact, any split of constant proportionality yields a recursion tree of depth ‚.lg n/, where the cost at each level is O.n/. The running time is therefore O.n lg n/ whenever the split has constant proportionality.
Figure 7.4
1

7.2
Performance of quicksort
177
n
(n–1)/2 – 1 (a)
Θ(n)
n
(b)
Θ(n)
0
n–1
(n–1)/2
(n–1)/2
(n–1)/2
Figure 7.5 (a) Two levels of a recursion tree for quicksort. The partitioning at the root costs n and produces a “bad” split: two subarrays of sizes 0 and n 􏳣 1. The partitioning of the subarray of size n 􏳣 1 costs n 􏳣 1 and produces a “good” split: subarrays of size .n 􏳣 1/=2 􏳣 1 and .n 􏳣 1/=2. (b) A single level of a recursion tree that is very well balanced. In both parts, the partitioning cost for the subproblems shown with elliptical shading is ‚.n/. Yet the subproblems remaining to be solved in (a), shown with square shading, are no larger than the corresponding subproblems remaining to be solved in (b).
Intuition for the average case
To develop a clear notion of the randomized behavior of quicksort, we must make an assumption about how frequently we expect to encounter the various inputs. The behavior of quicksort depends on the relative ordering of the values in the array elements given as the input, and not by the particular values in the array. As in our probabilistic analysis of the hiring problem in Section 5.2, we will assume for now that all permutations of the input numbers are equally likely.
When we run quicksort on a random input array, the partitioning is highly un- likely to happen in the same way at every level, as our informal analysis has as- sumed. We expect that some of the splits will be reasonably well balanced and that some will be fairly unbalanced. For example, Exercise 7.2-6 asks you to show that about 80 percent of the time PARTITION produces a split that is more balanced than 9 to 1, and about 20 percent of the time it produces a split that is less balanced than 9 to 1.
In the average case, PARTITION produces a mix of “good” and “bad” splits. In a recursion tree for an average-case execution of PARTITION, the good and bad splits are distributed randomly throughout the tree. Suppose, for the sake of intuition, that the good and bad splits alternate levels in the tree, and that the good splits are best-case splits and the bad splits are worst-case splits. Figure 7.5(a) shows the splits at two consecutive levels in the recursion tree. At the root of the tree, the cost is n for partitioning, and the subarrays produced have sizes n 􏳣 1 and 0: the worst case. At the next level, the subarray of size n 􏳣 1 undergoes best-case partitioning into subarrays of size .n 􏳣 1/=2 􏳣 1 and .n 􏳣 1/=2. Let’s assume that the boundary-condition cost is 1 for the subarray of size 0.

178 Chapter 7 Quicksort
The combination of the bad split followed by the good split produces three sub- arrays of sizes 0, .n 􏳣 1/=2 􏳣 1, and .n 􏳣 1/=2 at a combined partitioning cost of ‚.n/ C ‚.n 􏳣 1/ D ‚.n/. Certainly, this situation is no worse than that in Figure 7.5(b), namely a single level of partitioning that produces two subarrays of size .n 􏳣 1/=2, at a cost of ‚.n/. Yet this latter situation is balanced! Intuitively, the ‚.n 􏳣 1/ cost of the bad split can be absorbed into the ‚.n/ cost of the good split, and the resulting split is good. Thus, the running time of quicksort, when lev- els alternate between good and bad splits, is like the running time for good splits alone: still O.n lg n/, but with a slightly larger constant hidden by the O-notation. We shall give a rigorous analysis of the expected running time of a randomized version of quicksort in Section 7.4.2.
Exercises
7.2-1
Use the substitution method to prove that the recurrence T .n/ D T .n 􏳣 1/ C ‚.n/ has the solution T.n/ D ‚.n2/, as claimed at the beginning of Section 7.2.
7.2-2
What is the running time of QUICKSORT when all elements of array A have the same value?
7.2-3
Show that the running time of QUICKSORT is ‚.n2/ when the array A contains distinct elements and is sorted in decreasing order.
7.2-4
Banks often record transactions on an account in order of the times of the transac- tions, but many people like to receive their bank statements with checks listed in order by check number. People usually write checks in order by check number, and merchants usually cash them with reasonable dispatch. The problem of converting time-of-transaction ordering to check-number ordering is therefore the problem of sorting almost-sorted input. Argue that the procedure INSERTION-SORT would tend to beat the procedure QUICKSORT on this problem.
7.2-5
Suppose that the splits at every level of quicksort are in the proportion 1 􏳣 ̨ to ̨, where 0 < ̨ 􏳥 1=2 is a constant. Show that the minimum depth of a leaf in the re- cursion tree is approximately 􏳣 lg n= lg ̨ and the maximum depth is approximately 􏳣 lg n= lg.1 􏳣 ̨/. (Don’t worry about integer round-off.) 7.3 A randomized version of quicksort 179 7.2-6 ? Argue that for any constant 0 < ̨ 􏳥 1=2, the probability is approximately 1 􏳣 2 ̨ that on a random input array, PARTITION produces a split more balanced than 1􏳣 ̨ to ̨. 7.3 A randomized version of quicksort In exploring the average-case behavior of quicksort, we have made an assumption that all permutations of the input numbers are equally likely. In an engineering situation, however, we cannot always expect this assumption to hold. (See Exer- cise 7.2-4.) As we saw in Section 5.3, we can sometimes add randomization to an algorithm in order to obtain good expected performance over all inputs. Many peo- ple regard the resulting randomized version of quicksort as the sorting algorithm of choice for large enough inputs. In Section 5.3, we randomized our algorithm by explicitly permuting the in- put. We could do so for quicksort also, but a different randomization technique, called random sampling, yields a simpler analysis. Instead of always using AŒr􏳩 as the pivot, we will select a randomly chosen element from the subarray AŒp : : r 􏳩. We do so by first exchanging element AŒr􏳩 with an element chosen at random from AŒp : : r􏳩. By randomly sampling the range p; : : : ; r, we ensure that the pivot element x D AŒr􏳩 is equally likely to be any of the r 􏳣 p C 1 elements in the subarray. Because we randomly choose the pivot element, we expect the split of the input array to be reasonably well balanced on average. The changes to PARTITION and QUICKSORT are small. In the new partition procedure, we simply implement the swap before actually partitioning: RANDOMIZED-PARTITION.A;p;r/ 1 i D RANDOM.p;r/ 2 exchange AŒr􏳩 with AŒi􏳩 3 return PARTITION.A; p; r/ The new quicksort calls RANDOMIZED-PARTITION in place of PARTITION: RANDOMIZED-QUICKSORT.A;p;r/ 1 ifp aj to determine their relative order. We may not inspect the values of the elements or gain order information about them in any other way.
In this section, we assume without loss of generality that all the input elements are distinct. Given this assumption, comparisons of the form ai D aj are useless, so we can assume that no comparisons of this form are made. We also note that the comparisons ai 􏳥 aj, ai 􏳦 aj, ai > aj, and ai < aj are all equivalent in that 192 Chapter 8 Sorting in Linear Time 1:2 ≤>
2:3
≤> ≤>
1:3
〈1,2,3〉 1:3 〈2,1,3〉 2:3
≤> ≤> 〈1,3,2〉 〈3,1,2〉 〈2,3,1〉 〈3,2,1〉
Figure 8.1 The decision tree for insertion sort operating on three elements. An internal node an- notated by i :j indicates a comparison between ai and aj . A leaf annotated by the permutation h􏳬.1/; 􏳬.2/; : : : ; 􏳬.n/i indicates the ordering a􏳬.1/ 􏳥 a􏳬.2/ 􏳥 􏳵 􏳵 􏳵 􏳥 a􏳬.n/. The shaded path indicates the decisions made when sorting the input sequence ha1 D 6; a2 D 8; a3 D 5i; the permutation h3; 1; 2i at the leaf indicates that the sorted ordering is a3 D 5 􏳥 a1 D 6 􏳥 a2 D 8. There are 3Š D 6 possible permutations of the input elements, and so the decision tree must have at least 6 leaves.
they yield identical information about the relative order of ai and aj . We therefore assume that all comparisons have the form ai 􏳥 aj .
The decision-tree model
We can view comparison sorts abstractly in terms of decision trees. A decision tree is a full binary tree that represents the comparisons between elements that are performed by a particular sorting algorithm operating on an input of a given size. Control, data movement, and all other aspects of the algorithm are ignored. Figure 8.1 shows the decision tree corresponding to the insertion sort algorithm from Section 2.1 operating on an input sequence of three elements.
In a decision tree, we annotate each internal node by i:j for some i and j in the range 1 􏳥 i; j 􏳥 n, where n is the number of elements in the input sequence. We also annotate each leaf by a permutation h􏳬.1/; 􏳬.2/; : : : ; 􏳬.n/i. (See Section C.1 for background on permutations.) The execution of the sorting algorithm corre- sponds to tracing a simple path from the root of the decision tree down to a leaf. Each internal node indicates a comparison ai 􏳥 aj . The left subtree then dictates subsequent comparisons once we know that ai 􏳥 aj , and the right subtree dictates subsequent comparisons knowing that ai > aj . When we come to a leaf, the sort- ing algorithm has established the ordering a􏳬.1/ 􏳥 a􏳬.2/ 􏳥 􏳵 􏳵 􏳵 􏳥 a􏳬.n/. Because any correct sorting algorithm must be able to produce each permutation of its input, each of the nŠ permutations on n elements must appear as one of the leaves of the decision tree for a comparison sort to be correct. Furthermore, each of these leaves must be reachable from the root by a downward path corresponding to an actual

8.1 Lower bounds for sorting 193
execution of the comparison sort. (We shall refer to such leaves as “reachable.”) Thus, we shall consider only decision trees in which each permutation appears as a reachable leaf.
A lower bound for the worst case
The length of the longest simple path from the root of a decision tree to any of its reachable leaves represents the worst-case number of comparisons that the cor- responding sorting algorithm performs. Consequently, the worst-case number of comparisons for a given comparison sort algorithm equals the height of its decision tree. A lower bound on the heights of all decision trees in which each permutation appears as a reachable leaf is therefore a lower bound on the running time of any comparison sort algorithm. The following theorem establishes such a lower bound.
Theorem 8.1
Any comparison sort algorithm requires 􏳫.n lg n/ comparisons in the worst case.
Proof From the preceding discussion, it suffices to determine the height of a decision tree in which each permutation appears as a reachable leaf. Consider a decision tree of height h with l reachable leaves corresponding to a comparison sort on n elements. Because each of the nŠ permutations of the input appears as some leaf, we have nŠ 􏳥 l. Since a binary tree of height h has no more than 2h leaves, we have
nŠ 􏳥 l 􏳥 2h ;
which, by taking logarithms, implies
h 􏳦 lg.nŠ/ (since the lg function is monotonically increasing) D 􏳫.n lg n/ (by equation (3.19)) .
Corollary 8.2
Heapsort and merge sort are asymptotically optimal comparison sorts.
Proof The O.n lg n/ upper bounds on the running times for heapsort and merge
sort match the 􏳫.n lg n/ worst-case lower bound from Theorem 8.1. Exercises
8.1-1
What is the smallest possible depth of a leaf in a decision tree for a comparison sort?

194 Chapter 8 Sorting in Linear Time
8.1-2
Obtain asymptotically tight bounds on lg.nŠ/ without using Stirling’s approxi- mation. Instead, evaluate the summation PnkD1 lg k using techniques from Sec- tion A.2.
8.1-3
Show that there is no comparison sort whose running time is linear for at least half of the nŠ inputs of length n. What about a fraction of 1=n of the inputs of length n? What about a fraction 1=2n?
8.1-4
Suppose that you are given a sequence of n elements to sort. 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 variant of the sorting problem. (Hint: It is not rigorous to simply combine the lower bounds for the individual subsequences.)
8.2 Counting sort
Counting sort assumes that each of the n input elements is an integer in the range 0 to k, for some integer k. When k D O.n/, the sort runs in ‚.n/ time.
Counting sort determines, for each input element x, the number of elements less than x. It uses this information to place element x directly into its position in the output array. For example, if 17 elements are less than x, then x belongs in output position 18. We must modify this scheme slightly to handle the situation in which several elements have the same value, since we do not want to put them all in the same position.
In the code for counting sort, we assume that the input is an array AŒ1 : : n􏳩, and thus A: length D n. We require two other arrays: the array B Œ1 : : n􏳩 holds the sorted output, and the array C Œ0 : : k􏳩 provides temporary working storage.

8.2 Counting sort 195
12345678 12345678 A 012345 B
012345 C 012345 CC
2
5
3
0
2
3
0
3
3
2
2
4
7
7
8
2
0
2
3
0
1
2
2
4
6
7
8
(c)
12345678
B
(f)
Figure 8.2 The operation of COUNTING-SORT on an input array AŒ1::8􏳩, where each element of A is a nonnegative integer no larger than k D 5. (a) The array A and the auxiliary array C after line 5. (b) The array C after line 8. (c)–(e) The output array B and the auxiliary array C after one, two, and three iterations of the loop in lines 10–12, respectively. Only the lightly shaded elements of array B have been filled in. (f) The final sorted output array B.
COUNTING-SORT.A; B; k/
(a) (b) 12345678 12345678
BB
012345 012345
CC
(d) (e)
0
3
0
3
3
0
0
2
2
3
3
3
5
1
2
4
6
7
8
1
2
4
5
7
8
1 2 3 4 5 6 7 8 9
10 11 12
let CŒ0::k􏳩 be a new array foriD0tok
CŒi􏳩 D 0
for j D 1 to A:length
CŒAŒj􏳩􏳩 D CŒAŒj􏳩􏳩 C 1 //CŒi􏳩nowcontainsthenumberofelementsequaltoi. foriD1tok
CŒi􏳩 D CŒi􏳩CCŒi 􏳣1􏳩 //CŒi􏳩nowcontainsthenumberofelementslessthanorequaltoi. for j D A: length downto 1
BŒCŒAŒj􏳩􏳩􏳩 D AŒj􏳩 CŒAŒj􏳩􏳩 D CŒAŒj􏳩􏳩 􏳣 1
Figure 8.2 illustrates counting sort. After the for loop of lines 2–3 initializes the array C to all zeros, the for loop of lines 4–5 inspects each input element. If the value of an input element is i, we increment CŒi􏳩. Thus, after line 5, CŒi􏳩 holds the number of input elements equal to i for each integer i D 0; 1; : : : ; k. Lines 7–8 determine for each i D 0; 1; : : : ; k how many input elements are less than or equal to i by keeping a running sum of the array C .

196 Chapter 8 Sorting in Linear Time
Finally, the for loop of lines 10–12 places each element AŒj􏳩 into its correct sorted position in the output array B. If all n elements are distinct, then when we first enter line 10, for each AŒj􏳩, the value CŒAŒj􏳩􏳩 is the correct final position of AŒj􏳩 in the output array, since there are CŒAŒj􏳩􏳩 elements less than or equal to AŒj 􏳩. Because the elements might not be distinct, we decrement C ŒAŒj 􏳩􏳩 each time we place a value AŒj􏳩 into the B array. Decrementing CŒAŒj􏳩􏳩 causes the next input element with a value equal to AŒj 􏳩, if one exists, to go to the position immediately before AŒj 􏳩 in the output array.
How much time does counting sort require? The for loop of lines 2–3 takes time ‚.k/, the for loop of lines 4–5 takes time ‚.n/, the for loop of lines 7–8 takes time ‚.k/, and the for loop of lines 10–12 takes time ‚.n/. Thus, the overall time is ‚.k C n/. In practice, we usually use counting sort when we have k D O.n/, in which case the running time is ‚.n/.
Counting sort beats the lower bound of 􏳫.n lg n/ proved in Section 8.1 because it is not a comparison sort. In fact, no comparisons between input elements occur anywhere in the code. Instead, counting sort uses the actual values of the elements to index into an array. The 􏳫.n lg n/ lower bound for sorting does not apply when we depart from the comparison sort model.
An important property of counting sort is that it is stable: numbers with the same value appear in the output array in the same order as they do in the input array. That is, it breaks ties between two numbers by the rule that whichever number appears first in the input array appears first in the output array. Normally, the property of stability is important only when satellite data are carried around with the element being sorted. Counting sort’s stability is important for another reason: counting sort is often used as a subroutine in radix sort. As we shall see in the next section, in order for radix sort to work correctly, counting sort must be stable.
Exercises
8.2-1
Using Figure 8.2 as a model, illustrate the operation of COUNTING-SORT on the array A D h6;0;2;0;1;3;4;6;1;3;2i.
8.2-2
Prove that COUNTING-SORT is stable.
8.2-3
Suppose that we were to rewrite the for loop header in line 10 of the COUNTING- SORT as
10 forjD1toA:length
Show that the algorithm still works properly. Is the modified algorithm stable?

8.3 Radix sort 197
8.2-4
Describe an algorithm that, given n integers in the range 0 to k, preprocesses its input and then answers any query about how many of the n integers fall into a range Œa : : b􏳩 in O.1/ time. Your algorithm should use ‚.n C k/ preprocessing time.
8.3 Radix sort
Radix sort is the algorithm used by the card-sorting machines you now find only in computer museums. The cards have 80 columns, and in each column a machine can punch a hole in one of 12 places. The sorter can be mechanically “programmed” to examine a given column of each card in a deck and distribute the card into one of 12 bins depending on which place has been punched. An operator can then gather the cards bin by bin, so that cards with the first place punched are on top of cards with the second place punched, and so on.
For decimal digits, each column uses only 10 places. (The other two places are reserved for encoding nonnumeric characters.) A d-digit number would then occupy a field of d columns. Since the card sorter can look at only one column at a time, the problem of sorting n cards on a d-digit number requires a sorting algorithm.
Intuitively, you might sort numbers on their most significant digit, sort each of the resulting bins recursively, and then combine the decks in order. Unfortunately, since the cards in 9 of the 10 bins must be put aside to sort each of the bins, this procedure generates many intermediate piles of cards that you would have to keep track of. (See Exercise 8.3-5.)
Radix sort solves the problem of card sorting—counterintuitively—by sorting on the least significant digit first. The algorithm then combines the cards into a single deck, with the cards in the 0 bin preceding the cards in the 1 bin preceding the cards in the 2 bin, and so on. Then it sorts the entire deck again on the second-least significant digit and recombines the deck in a like manner. The process continues until the cards have been sorted on all d digits. Remarkably, at that point the cards are fully sorted on the d-digit number. Thus, only d passes through the deck are required to sort. Figure 8.3 shows how radix sort operates on a “deck” of seven 3-digit numbers.
In order for radix sort to work correctly, the digit sorts must be stable. The sort performed by a card sorter is stable, but the operator has to be wary about not changing the order of the cards as they come out of a bin, even though all the cards in a bin have the same digit in the chosen column.

198 Chapter 8 Sorting in Linear Time
329 720 457 355 657 436 839 457 436 657 720 329 355 839
720 329 329 355 436 436 839 457 355 657 457 720 657 839
Figure 8.3 The operation of radix sort on a list of seven 3-digit numbers. The leftmost column is the input. The remaining columns show the list after successive sorts on increasingly significant digit positions. Shading indicates the digit position sorted on to produce each list from the previous one.
In a typical computer, which is a sequential random-access machine, we some- times use radix sort to sort records of information that are keyed by multiple fields. For example, we might wish to sort dates by three keys: year, month, and day. We could run a sorting algorithm with a comparison function that, given two dates, compares years, and if there is a tie, compares months, and if another tie occurs, compares days. Alternatively, we could sort the information three times with a stable sort: first on day, next on month, and finally on year.
The code for radix sort is straightforward. The following procedure assumes that each element in the n-element array A has d digits, where digit 1 is the lowest-order digit and digit d is the highest-order digit.
RADIX-SORT.A;d/ 1 foriD1tod
2 use a stable sort to sort array A on digit i
Lemma 8.3
Given n d -digit numbers in which each digit can take on up to k possible values, RADIX-SORT correctly sorts these numbers in ‚.d.n C k// time if the stable sort it uses takes ‚.n C k/ time.
Proof The correctness of radix sort follows by induction on the column being sorted (see Exercise 8.3-3). The analysis of the running time depends on the stable sort used as the intermediate sorting algorithm. When each digit is in the range 0 to k􏳣1 (so that it can take on k possible values), and k is not too large, counting sort is the obvious choice. Each pass over n d -digit numbers then takes time ‚.n C k/. There are d passes, and so the total time for radix sort is ‚.d.n C k//.
When d is constant and k D O.n/, we can make radix sort run in linear time. More generally, we have some flexibility in how to break each key into digits.

8.3 Radix sort 199
Lemma 8.4
Given n b-bit numbers and any positive integer r 􏳥 b, RADIX-SORT correctly sorts these numbers in ‚..b=r/.n C 2r // time if the stable sort it uses takes ‚.n C k/ time for inputs in the range 0 to k.
Proof For a value r 􏳥 b, we view each key as having d D db=re digits of r bits each. Each digit is an integer in the range 0 to 2r 􏳣 1, so that we can use counting sort with k D 2r 􏳣 1. (For example, we can view a 32-bit word as having four 8-bit digits, so that b D 32, r D 8, k D 2r 􏳣 1 D 255, and d D b=r D 4.) Each pass of counting sort takes time ‚.n C k/ D ‚.n C 2r / and there are d passes, for a total running time of ‚.d.n C 2r // D ‚..b=r/.n C 2r //.
For given values of n and b, we wish to choose the value of r, with r 􏳥 b, that minimizes the expression .b=r/.n C 2r /. If b < blg nc, then for any value of r 􏳥 b, we have that .n C 2r/ D ‚.n/. Thus, choosing r D b yields a running time of .b=b/.n C 2b / D ‚.n/, which is asymptotically optimal. If b 􏳦 blg nc, then choosing r D blg nc gives the best time to within a constant factor, which we can see as follows. Choosing r D blg nc yields a running time of ‚.b n= lg n/. As we increase r above blg nc, the 2r term in the numerator increases faster than the r term in the denominator, and so increasing r above blg nc yields a running time of 􏳫.bn= lg n/. If instead we were to decrease r below blg nc, then the b=r term increases and the n C 2r term remains at ‚.n/. Is radix sort preferable to a comparison-based sorting algorithm, such as quick- sort? If b D O.lg n/, as is often the case, and we choose r 􏳬 lg n, then radix sort’s running time is ‚.n/, which appears to be better than quicksort’s expected running time of ‚.n lg n/. The constant factors hidden in the ‚-notation differ, however. Although radix sort may make fewer passes than quicksort over the n keys, each pass of radix sort may take significantly longer. Which sorting algorithm we prefer depends on the characteristics of the implementations, of the underlying machine (e.g., quicksort often uses hardware caches more effectively than radix sort), and of the input data. Moreover, the version of radix sort that uses counting sort as the intermediate stable sort does not sort in place, which many of the ‚.n lg n/-time comparison sorts do. Thus, when primary memory storage is at a premium, we might prefer an in-place algorithm such as quicksort. Exercises 8.3-1 Using Figure 8.3 as a model, illustrate the operation of RADIX-SORT on the fol- lowing list of English words: COW, DOG, SEA, RUG, ROW, MOB, BOX, TAB, BAR, EAR, TAR, DIG, BIG, TEA, NOW, FOX. 200 Chapter 8 Sorting in Linear Time 8.3-2 Which of the following sorting algorithms are stable: insertion sort, merge sort, heapsort, and quicksort? Give a simple scheme that makes any sorting algorithm stable. How much additional time and space does your scheme entail? 8.3-3 Use induction to prove that radix sort works. Where does your proof need the assumption that the intermediate sort is stable? 8.3-4 Show how to sort n integers in the range 0 to n3 􏳣 1 in O.n/ time. 8.3-5 ? In the first card-sorting algorithm in this section, exactly how many sorting passes are needed to sort d -digit decimal numbers in the worst case? How many piles of cards would an operator need to keep track of in the worst case? 8.4 Bucket sort Bucket sort assumes that the input is drawn from a uniform distribution and has an average-case running time of O.n/. Like counting sort, bucket sort is fast because it assumes something about the input. Whereas counting sort assumes that the input consists of integers in a small range, bucket sort assumes that the input is generated by a random process that distributes elements uniformly and independently over the interval Œ0; 1/. (See Section C.2 for a definition of uniform distribution.) Bucket sort divides the interval Œ0; 1/ into n equal-sized subintervals, or buckets, and then distributes the n input numbers into the buckets. Since the inputs are uni- formly and independently distributed over Œ0; 1/, we do not expect many numbers to fall into each bucket. To produce the output, we simply sort the numbers in each bucket and then go through the buckets in order, listing the elements in each. Our code for bucket sort assumes that the input is an n-element array A and that each element AŒi􏳩 in the array satisfies 0 􏳥 AŒi􏳩 < 1. The code requires an auxiliary array B Œ0 : : n 􏳣 1􏳩 of linked lists (buckets) and assumes that there is a mechanism for maintaining such lists. (Section 10.2 describes how to implement basic operations on linked lists.) 8.4 Bucket sort 201 AB 10 21 32 43 54 65 76 87 98 10 9 (a) (b) Figure 8.4 The operation of BUCKET-SORT for n D 10. (a) The input array AŒ1 : : 10􏳩. (b) The array BŒ0::9􏳩 of sorted lists (buckets) after line 8 of the algorithm. Bucket i holds values in the half-open interval Œi=10; .i C 1/=10/. The sorted output consists of a concatenation in order of the lists BŒ0􏳩; BŒ1􏳩; : : : ; BŒ9􏳩. BUCKET-SORT.A/ .78 .17 .39 .26 .72 .94 .21 .12 .23 .68 .12 .17 .21 .23 .26 .39 .68 .72 .78 .94 1 2 3 4 5 6 7 8 9 letBŒ0::n􏳣1􏳩beanewarray n D A: length foriD0ton􏳣1 make BŒi􏳩 an empty list foriD1ton insert AŒi􏳩 into list BŒbnAŒi􏳩c􏳩 foriD0ton􏳣1 sort list BŒi􏳩 with insertion sort concatenate the lists B Œ0􏳩; B Œ1􏳩; : : : ; B Œn 􏳣 1􏳩 together in order Figure 8.4 shows the operation of bucket sort on an input array of 10 numbers. To see that this algorithm works, consider two elements AŒi􏳩 and AŒj􏳩. Assume without loss of generality that AŒi 􏳩 􏳥 AŒj 􏳩. Since bnAŒi 􏳩c 􏳥 bnAŒj 􏳩c, either element AŒi 􏳩 goes into the same bucket as AŒj 􏳩 or it goes into a bucket with a lower index. If AŒi 􏳩 and AŒj 􏳩 go into the same bucket, then the for loop of lines 7–8 puts them into the proper order. If AŒi􏳩 and AŒj􏳩 go into different buckets, then line 9 puts them into the proper order. Therefore, bucket sort works correctly. To analyze the running time, observe that all lines except line 8 take O.n/ time in the worst case. We need to analyze the total time taken by the n calls to insertion sort in line 8. 202 Chapter 8 Sorting in Linear Time To analyze the cost of the calls to insertion sort, let ni be the random variable denoting the number of elements placed in bucket BŒi􏳩. Since insertion sort runs in quadratic time (see Section 2.2), the running time of bucket sort is n􏳣1 T . n / D ‚ . n / C X O . n 2i / : iD0 We now analyze the average-case running time of bucket sort, by computing the expected value of the running time, where we take the expectation over the input distribution. Taking expectations of both sides and using linearity of expectation, we have " n􏳣1 # EŒT.n/􏳩 D E ‚.n/CXO.n2i/ D ‚.n/ C D ‚.n/ C We claim that E 􏳨n2􏳤 D 2 􏳣 1=n n􏳣1 iD0 i iD0 X􏳨2􏳤 E O.ni / X 􏳣 􏳨 2􏳤􏳵 (by linearity of expectation) (by equation (C.22)) . n􏳣1 iD0 O E ni (8.1) (8.2) for i D 0;1;:::;n􏳣1. It is no surprise that each bucket i has the same value of E Œn2i 􏳩, since each value in the input array A is equally likely to fall in any bucket. To prove equation (8.2), we define indicator random variables Xij DIfAŒj􏳩fallsinbucketig fori D0;1;:::;n􏳣1andj D1;2;:::;n. Thus, Xn ni D To compute E Œn2i 􏳩, we expand the square and regroup terms: jD1 Xij : 8.4 Bucket sort 203 􏳨2􏳤 Eni "Xn !2# DE Xij " jD1 Xn Xn XijXik Xn XX D E DE4 X2C jD1 1􏳥j􏳥n 1􏳥k􏳥n k¤j Xn 􏳨 2 􏳤 X X D EXij C 2jD1 kD1 ij 3 XijXik5 EŒXijXik􏳩; (8.3) jD1 1􏳥j􏳥n 1􏳥k􏳥n k¤j # where the last line follows by linearity of expectation. We evaluate the two sum- mations separately. Indicator random variable Xij is 1 with probability 1=n and 0 otherwise, and therefore 􏳨􏳤 1􏳧1􏳹 EX2 D 12􏳵 C02􏳵 1􏳣 ij n n D1: n When k ¤ j , the variables Xij and Xi k are independent, and hence EŒXijXik􏳩 D EŒXij􏳩EŒXik􏳩 D 1􏳵1 nn D1: n2 Substituting these two expected values in equation (8.3), we obtain E 􏳨 n 2 􏳤 D Xn 1 C X X 1 i n n2 jD1 1􏳥j􏳥n 1􏳥k􏳥n k¤j D n􏳵1Cn.n􏳣1/􏳵 1 n n2 D 1Cn􏳣1 n D2􏳣1; n which proves equation (8.2). 204 Chapter 8 Sorting in Linear Time Using this expected value in equation (8.1), we conclude that the average-case running time for bucket sort is ‚.n/ C n 􏳵 O.2 􏳣 1=n/ D ‚.n/. Even if the input is not drawn from a uniform distribution, bucket sort may still run in linear time. As long as the input has the property that the sum of the squares of the bucket sizes is linear in the total number of elements, equation (8.1) tells us that bucket sort will run in linear time. Exercises 8.4-1 Using Figure 8.4 as a model, illustrate the operation of BUCKET-SORT on the array A D h:79; :13; :16; :64; :39; :20; :89; :53; :71; :42i. 8.4-2 Explain why the worst-case running time for bucket sort is ‚.n2/. What simple change to the algorithm preserves its linear average-case running time and makes its worst-case running time O.n lg n/? 8.4-3 Let X be a random variable that is equal to the number of heads in two flips of a fair coin. What is E ŒX2􏳩? What is E2 ŒX􏳩? 8.4-4 ? Wearegivennpointsintheunitcircle,pi D.xi;yi/,suchthat0 1 leaves, and let LT and RT be the left and right subtrees of T . Show that D.T / D D.LT/ C D.RT/ C k.
c. Let d.k/ be the minimum value of D.T / over all decision trees T with k > 1 leaves. Show that d.k/ D min1􏳥i􏳥k􏳣1 fd.i/ C d.k 􏳣 i/ C kg. (Hint: Consider a decision tree T with k leaves that achieves the minimum. Let i0 be the number of leaves in LT and k 􏳣 i0 the number of leaves in RT.)
d. Provethatforagivenvalueofk>1andiintherange1􏳥i􏳥k􏳣1,the function i lg i C .k 􏳣 i/ lg.k 􏳣 i/ is minimized at i D k=2. Conclude that d.k/ D 􏳫.k lg k/.
e. Prove that D.TA/ D 􏳫.nŠlg.nŠ//, and conclude that the average-case time to sort n elements is 􏳫.n lg n/.
Now, consider a randomized comparison sort B. We can extend the decision- tree model to handle randomization by incorporating two kinds of nodes: ordinary comparison nodes and “randomization” nodes. A randomization node models a random choice of the form RANDOM.1;r/ made by algorithm B; the node has r children, each of which is equally likely to be chosen during an execution of the algorithm.
f. Show that for any randomized comparison sort B, there exists a deterministic comparison sort A whose expected number of comparisons is no more than those made by B.

206 Chapter 8 Sorting in Linear Time
8-2 Sorting in place in linear time
Suppose that we have an array of n data records to sort and that the key of each record has the value 0 or 1. An algorithm for sorting such a set of records might possess some subset of the following three desirable characteristics:
1. The algorithm runs in O.n/ time.
2. The algorithm is stable.
3. The algorithm sorts in place, using no more than a constant amount of storage space in addition to the original array.
a. Give an algorithm that satisfies criteria 1 and 2 above.
b. Give an algorithm that satisfies criteria 1 and 3 above.
c. Give an algorithm that satisfies criteria 2 and 3 above.
d. Can you use any of your sorting algorithms from parts (a)–(c) as the sorting method used in line 2 of RADIX-SORT, so that RADIX-SORT sorts n records with b-bit keys in O.bn/ time? Explain how or why not.
e. Suppose that the n records have keys in the range from 1 to k. Show how to modify counting sort so that it sorts the records in place in O.n C k/ time. You may use O.k/ storage outside the input array. Is your algorithm stable? (Hint: How would you do it for k D 3?)
8-3 Sorting variable-length items
a. You are given an array of integers, where different integers may have different
numbers of digits, but the total number of digits over all the integers in the array is n. Show how to sort the array in O.n/ time.
b. You are given an array of strings, where different strings may have different numbers of characters, but the total number of characters over all the strings is n. Show how to sort the strings in O.n/ time.
(Note that the desired order here is the standard alphabetical order; for example, a AŒj􏳩
2 exchange AŒi 􏳩 with AŒj 􏳩
After the compare-exchange operation, we know that AŒi 􏳩 􏳥 AŒj 􏳩.
An oblivious compare-exchange algorithm operates solely by a sequence of prespecified compare-exchange operations. The indices of the positions compared in the sequence must be determined in advance, and although they can depend on the number of elements being sorted, they cannot depend on the values being sorted, nor can they depend on the result of any prior compare-exchange operation. For example, here is insertion sort expressed as an oblivious compare-exchange
algorithm: INSERTION-SORT.A/
1 2 3
for j D 2 to A:length
fori D j 􏳣1downto1
COMPARE-EXCHANGE.A; i; i C 1/
The 0-1 sorting lemma and columnsort

Problems for Chapter 8 209
The 0-1 sorting lemma provides a powerful way to prove that an oblivious compare-exchange algorithm produces a sorted result. It states that if an oblivi- ous compare-exchange algorithm correctly sorts all input sequences consisting of only 0s and 1s, then it correctly sorts all inputs containing arbitrary values.
You will prove the 0-1 sorting lemma by proving its contrapositive: if an oblivi- ous compare-exchange algorithm fails to sort an input containing arbitrary values, then it fails to sort some 0-1 input. Assume that an oblivious compare-exchange al- gorithm X fails to correctly sort the array AŒ1 : : n􏳩. Let AŒp􏳩 be the smallest value in A that algorithm X puts into the wrong location, and let AŒq􏳩 be the value that algorithm X moves to the location into which AŒp􏳩 should have gone. Define an array BŒ1 : : n􏳩 of 0s and 1s as follows:
(
0 ifAŒi􏳩􏳥AŒp􏳩; 1 ifAŒi􏳩>AŒp􏳩:
BŒi􏳩 D
a. Argue that AŒq􏳩 > AŒp􏳩, so that BŒp􏳩 D 0 and BŒq􏳩 D 1.
b. To complete the proof of the 0-1 sorting lemma, prove that algorithm X fails to sort array B correctly.
Now you will use the 0-1 sorting lemma to prove that a particular sorting algo-
rithm works correctly. The algorithm, columnsort, works on a rectangular array of n elements. The array has r rows and s columns (so that n D rs), subject to three restrictions:
r must be even,
s must be a divisor of r, and r 􏳦 2s2.
When columnsort completes, the array is sorted in column-major order: reading down the columns, from left to right, the elements monotonically increase.
Columnsort operates in eight steps, regardless of the value of n. The odd steps are all the same: sort each column individually. Each even step is a fixed permuta- tion. Here are the steps:
1. Sorteachcolumn.
2. Transpose the array, but reshape it back to r rows and s columns. In other words, turn the leftmost column into the top r=s rows, in order; turn the next column into the next r=s rows, in order; and so on.
3. Sorteachcolumn.
4. Performtheinverseofthepermutationperformedinstep2.
􏳮 􏳮 􏳮

210 Chapter 8 Sorting in Linear Time
10 14 5 8 7 17
12 1 6 16 9 11
4 1 2
8 3 5 10 7 6 12 9 11 16 14 13 18 15 17
4 8 10 12 16 18 1 3 7
9 14 15
2 5 6 11 13 17
(c)
410 16 511 17 612 18 713 814 915
1 3 6 1411 2 5 7 3814 4 8 10 61017 9 13 15 2912
11 14 17 51316 12 16 18 71518
(d) (e)
17 13 28 14 39 15 410 16 511 17 612 18
415 18 3
(a)
14 28 39 5 10 6 13 7 15
(f)
2 13
11
12
14
16
17
18
(b)
510 613 715 411 812 914
16 17 18
1 2 3
1 2 3
(g) (h) (i)
Figure 8.5
sorting each column in step 1. (c) After transposing and reshaping in step 2. (d) After sorting each column in step 3. (e) After performing step 4, which inverts the permutation from step 2. (f) After sorting each column in step 5. (g) After shifting by half a column in step 6. (h) After sorting each column in step 7. (i) After performing step 8, which inverts the permutation from step 6. The array is now sorted in column-major order.
5. Sort each column.
6. Shift the top half of each column into the bottom half of the same column, and shift the bottom half of each column into the top half of the next column to the right. Leave the top half of the leftmost column empty. Shift the bottom half of the last column into the top half of a new rightmost column, and leave the bottom half of this new column empty.
7. Sort each column.
8. Perform the inverse of the permutation performed in step 6.
Figure 8.5 shows an example of the steps of columnsort with r D 6 and s D 3. (Even though this example violates the requirement that r 􏳦 2s2, it happens to work.)
c. Argue that we can treat columnsort as an oblivious compare-exchange algo- rithm, even if we do not know what sorting method the odd steps use.
Although it might seem hard to believe that columnsort actually sorts, you will use the 0-1 sorting lemma to prove that it does. The 0-1 sorting lemma applies because we can treat columnsort as an oblivious compare-exchange algorithm. A
The steps of columnsort. (a) The input array with 6 rows and 3 columns. (b) After

Notes for Chapter 8 211
couple of definitions will help you apply the 0-1 sorting lemma. We say that an area of an array is clean if we know that it contains either all 0s or all 1s. Otherwise, the area might contain mixed 0s and 1s, and it is dirty. From here on, assume that the input array contains only 0s and 1s, and that we can treat it as an array with r rows and s columns.
d. Provethataftersteps1–3,thearrayconsistsofsomecleanrowsof0satthetop, some clean rows of 1s at the bottom, and at most s dirty rows between them.
e. Prove that after step 4, the array, read in column-major order, starts with a clean area of 0s, ends with a clean area of 1s, and has a dirty area of at most s2 elements in the middle.
f. Prove that steps 5–8 produce a fully sorted 0-1 output. Conclude that column- sort correctly sorts all inputs containing arbitrary values.
g. Now suppose that s does not divide r. Prove that after steps 1–3, the array consists of some clean rows of 0s at the top, some clean rows of 1s at the bottom, and at most 2s 􏳣 1 dirty rows between them. How large must r be, compared with s, for columnsort to correctly sort when s does not divide r?
h. Suggest a simple change to step 1 that allows us to maintain the requirement that r 􏳦 2s2 even when s does not divide r, and prove that with your change, columnsort correctly sorts.
Chapter notes
The decision-tree model for studying comparison sorts was introduced by Ford and Johnson [110]. Knuth’s comprehensive treatise on sorting [211] covers many variations on the sorting problem, including the information-theoretic lower bound on the complexity of sorting given here. Ben-Or [39] studied lower bounds for sorting using generalizations of the decision-tree model.
Knuth credits H. H. Seward with inventing counting sort in 1954, as well as with the idea of combining counting sort with radix sort. Radix sorting starting with the least significant digit appears to be a folk algorithm widely used by operators of mechanical card-sorting machines. According to Knuth, the first published refer- ence to the method is a 1929 document by L. J. Comrie describing punched-card equipment. Bucket sorting has been in use since 1956, when the basic idea was proposed by E. J. Isaac and R. C. Singleton [188].
Munro and Raman [263] give a stable sorting algorithm that performs O.n1C􏳮/ comparisons in the worst case, where 0 < 􏳮 􏳥 1 is any fixed constant. Although 212 Chapter 8 Sorting in Linear Time any of the O.n lg n/-time algorithms make fewer comparisons, the algorithm by Munro and Raman moves data only O.n/ times and operates in place. The case of sorting n b-bit integers in o.nlgn/ time has been considered by many researchers. Several positive results have been obtained, each under slightly different assumptions about the model of computation and the restrictions placed on the algorithm. All the results assume that the computer memory is divided into addressable b-bit words. Fredman and Willard [115] introduced the fusion tree data structure and used it to sort n integers in O.n lg n= lg lg n/ time. This bound was p lg n/ time by Andersson [16]. These algorithms require the use of multiplication and several precomputed constants. Andersson, Hagerup, Nilsson, and Raman [17] have shown how to sort n integers in O.n lg lg n/ time without using multiplication, but their method requires storage that can be un- bounded in terms of n. Using multiplicative hashing, we can reduce the storage needed to O.n/, but then the O.n lg lg n/ worst-case bound on the running time becomes an expected-time bound. Generalizing the exponential search trees of Andersson [16], Thorup [335] gave an O.n.lg lg n/2/-time sorting algorithm that does not use multiplication or randomization, and it uses linear space. Combining these techniques with some new ideas, Han [158] improved the bound for sorting to O.n lg lg n lg lg lg n/ time. Although these algorithms are important theoretical breakthroughs, they are all fairly complicated and at the present time seem unlikely to compete with existing sorting algorithms in practice. The columnsort algorithm in Problem 8-7 is by Leighton [227]. later improved to O.n 9 Medians and Order Statistics The ith order statistic of a set of n elements is the ith smallest element. For example, the minimum of a set of elements is the first order statistic (i D 1), and the maximum is the nth order statistic (i D n). A median, informally, is the “halfway point” of the set. When n is odd, the median is unique, occurring at i D .n C 1/=2. When n is even, there are two medians, occurring at i D n=2 and i D n=2C1. Thus, regardless of the parity of n, medians occur at i D b.n C 1/=2c (the lower median) and i D d.n C 1/=2e (the upper median). For simplicity in this text, however, we consistently use the phrase “the median” to refer to the lower median. This chapter addresses the problem of selecting the ith order statistic from a set of n distinct numbers. We assume for convenience that the set contains dis- tinct numbers, although virtually everything that we do extends to the situation in which a set contains repeated values. We formally specify the selection problem as follows: Input: A set A of n (distinct) numbers and an integer i, with 1 􏳥 i 􏳥 n. Output: The element x 2 A that is larger than exactly i 􏳣 1 other elements of A. We can solve the selection problem in O.n lg n/ time, since we can sort the num- bers using heapsort or merge sort and then simply index the ith element in the output array. This chapter presents faster algorithms. In Section 9.1, we examine the problem of selecting the minimum and maxi- mum of a set of elements. More interesting is the general selection problem, which we investigate in the subsequent two sections. Section 9.2 analyzes a practical randomized algorithm that achieves an O.n/ expected running time, assuming dis- tinct elements. Section 9.3 contains an algorithm of more theoretical interest that achieves the O.n/ running time in the worst case. 214 Chapter 9 Medians and Order Statistics 9.1 Minimum and maximum How many comparisons are necessary to determine the minimum of a set of n elements? We can easily obtain an upper bound of n 􏳣 1 comparisons: examine each element of the set in turn and keep track of the smallest element seen so far. In the following procedure, we assume that the set resides in array A, where A:length D n. MINIMUM.A/ 1 2 3 4 5 min D AŒ1􏳩 foriD2toA:length if min > AŒi􏳩 min D AŒi􏳩
return min
We can, of course, find the maximum with n 􏳣 1 comparisons as well.
Is this the best we can do? Yes, since we can obtain a lower bound of n 􏳣 1 comparisons for the problem of determining the minimum. Think of any algorithm that determines the minimum as a tournament among the elements. Each compar- ison is a match in the tournament in which the smaller of the two elements wins. Observing that every element except the winner must lose at least one match, we conclude that n 􏳣 1 comparisons are necessary to determine the minimum. Hence, the algorithm MINIMUM is optimal with respect to the number of comparisons
performed.
Simultaneous minimum and maximum
In some applications, we must find both the minimum and the maximum of a set of n elements. For example, a graphics program may need to scale a set of .x; y/ data to fit onto a rectangular display screen or other graphical output device. To do so, the program must first determine the minimum and maximum value of each coordinate.
At this point, it should be obvious how to determine both the minimum and the maximum of n elements using ‚.n/ comparisons, which is asymptotically optimal: simply find the minimum and maximum independently, using n 􏳣 1 comparisons for each, for a total of 2n 􏳣 2 comparisons.
In fact, we can find both the minimum and the maximum using at most 3 bn=2c comparisons. We do so by maintaining both the minimum and maximum elements seen thus far. Rather than processing each element of the input by comparing it against the current minimum and maximum, at a cost of 2 comparisons per element,

9.2 Selection in expected linear time 215
we process elements in pairs. We compare pairs of elements from the input first with each other, and then we compare the smaller with the current minimum and the larger to the current maximum, at a cost of 3 comparisons for every 2 elements.
How we set up initial values for the current minimum and maximum depends on whether n is odd or even. If n is odd, we set both the minimum and maximum to the value of the first element, and then we process the rest of the elements in pairs. If n is even, we perform 1 comparison on the first 2 elements to determine the initial values of the minimum and maximum, and then process the rest of the elements in pairs as in the case for odd n.
Let us analyze the total number of comparisons. If n is odd, then we perform 3 bn=2c comparisons. If n is even, we perform 1 initial comparison followed by 3.n 􏳣 2/=2 comparisons, for a total of 3n=2 􏳣 2. Thus, in either case, the total number of comparisons is at most 3 bn=2c.
Exercises
9.1-1
Show that the second smallest of n elements can be found with n C dlg ne 􏳣 2 comparisons in the worst case. (Hint: Also find the smallest element.)
9.1-2 ?
Prove the lower bound of d3n=2e 􏳣 2 comparisons in the worst case to find both the maximum and minimum of n numbers. (Hint: Consider how many numbers are potentially either the maximum or minimum, and investigate how a comparison affects these counts.)
9.2 Selection in expected linear time
The general selection problem appears more difficult than the simple problem of finding a minimum. Yet, surprisingly, the asymptotic running time for both prob- lems is the same: ‚.n/. In this section, we present a divide-and-conquer algorithm for the selection problem. The algorithm RANDOMIZED-SELECT is modeled after the quicksort algorithm of Chapter 7. As in quicksort, we partition the input array recursively. But unlike quicksort, which recursively processes both sides of the partition, RANDOMIZED-SELECT works on only one side of the partition. This difference shows up in the analysis: whereas quicksort has an expected running time of ‚.n lg n/, the expected running time of RANDOMIZED-SELECT is ‚.n/, assuming that the elements are distinct.

216 Chapter 9 Medians and Order Statistics
RANDOMIZED-SELECT uses the procedure RANDOMIZED-PARTITION intro- duced in Section 7.3. Thus, like RANDOMIZED-QUICKSORT, it is a randomized al- gorithm, since its behavior is determined in part by the output of a random-number generator. The following code for RANDOMIZED-SELECT returns the ith smallest element of the array AŒp : : r 􏳩.
RANDOMIZED-SELECT.A;p;r;i/
1 2 3 4 5 6 7 8 9
ifp==r
return AŒp􏳩
q D RANDOMIZED-PARTITION.A; p; r/ kDq􏳣pC1
if i == k // the pivot value is the answer
return AŒq􏳩 elseifi k, however, then the desired element lies on the high side of the partition. Since we already know k values that are smaller than the i th smallest element of AŒp : : r 􏳩—namely, the elements of AŒp : : q􏳩—the desired element is the .i 􏳣 k/th smallest element of AŒq C 1 : : r 􏳩, which line 9 finds recursively. The code appears to allow recursive calls to subarrays with 0 elements, but Exercise 9.2-1 asks you to show that this situation cannot happen.
The worst-case running time for RANDOMIZED-SELECT is ‚.n2/, even to find the minimum, because we could be extremely unlucky and always partition around the largest remaining element, and partitioning takes ‚.n/ time. We will see that

9.2 Selection in expected linear time 217
the algorithm has a linear expected running time, though, and because it is random- ized, no particular input elicits the worst-case behavior.
To analyze the expected running time of RANDOMIZED-SELECT, we let the run- ning time on an input array AŒp : : r 􏳩 of n elements be a random variable that we denote by T .n/, and we obtain an upper bound on E ŒT .n/􏳩 as follows. The pro- cedure RANDOMIZED-PARTITION is equally likely to return any element as the pivot. Therefore, for each k such that 1 􏳥 k 􏳥 n, the subarray AŒp : : q􏳩 has k ele- ments (all less than or equal to the pivot) with probability 1=n. For k D 1; 2; : : : ; n, we define indicator random variables Xk where
Xk D I fthe subarray AŒp : : q􏳩 has exactly k elementsg ;
and so, assuming that the elements are distinct, we have
EŒXk􏳩 D 1=n : (9.1)
When we call RANDOMIZED-SELECT and choose AŒq􏳩 as the pivot element, we do not know, a priori, if we will terminate immediately with the correct answer, recurse on the subarray AŒp : : q 􏳣 1􏳩, or recurse on the subarray AŒq C 1 : : r􏳩. This decision depends on where the ith smallest element falls relative to AŒq􏳩. Assuming that T.n/ is monotonically increasing, we can upper-bound the time needed for the recursive call by the time needed for the recursive call on the largest possible input. In other words, to obtain an upper bound, we assume that the ith element is always on the side of the partition with the greater number of elements. For a given call of RANDOMIZED-SELECT, the indicator random variable Xk has thevalue1forexactlyonevalueofk,anditis0forallotherk. WhenXk D1,the two subarrays on which we might recurse have sizes k 􏳣 1 and n 􏳣 k. Hence, we have the recurrence
Xn kD1
Xn kD1
T.n/ 􏳥 D
Xk 􏳵 .T.max.k 􏳣 1;n 􏳣 k// C O.n// Xk 􏳵T.max.k􏳣1;n􏳣k//CO.n/:

218 Chapter 9 Medians and Order Statistics
Taking expected values, we have E ŒT .n/􏳩
#
Xk 􏳵T.max.k􏳣1;n􏳣k//CO.n/
E ŒXk 􏳵 T .max.k 􏳣 1; n 􏳣 k//􏳩 C O.n/ EŒXk􏳩􏳵EŒT.max.k􏳣1;n􏳣k//􏳩CO.n/ (byequation(C.24))
D Xn 1􏳵EŒT.max.k􏳣1;n􏳣k//􏳩CO.n/ (byequation(9.1)) .
kD1 n
In order to apply equation (C.24), we rely on Xk and T .max.k 􏳣 1; n 􏳣 k// being independent random variables. Exercise 9.2-2 asks you to justify this assertion.
Let us consider the expression max.k 􏳣 1; n 􏳣 k/. We have (
􏳥 E Xn
D
D
(by linearity of expectation)
kD1 Xn
kD1
“Xn kD1
max.k 􏳣 1; n 􏳣 k/ D
k􏳣1 ifk>dn=2e; n􏳣k ifk􏳥dn=2e:
If n is even, each term from T .dn=2e/ up to T .n 􏳣 1/ appears exactly twice in the summation, and if n is odd, all these terms appear twice and T .bn=2c/ appears once. Thus, we have
n􏳣1 2X
EŒT.n/􏳩􏳥 n
We show that E ŒT .n/􏳩 D O.n/ by substitution. Assume that E ŒT .n/􏳩 􏳥 cn for some constant c that satisfies the initial conditions of the recurrence. We assume that T .n/ D O.1/ for n less than some constant; we shall pick this constant later. We also pick a constant a such that the function described by the O.n/ term above (which describes the non-recursive component of the running time of the algo- rithm) is bounded from above by an for all n > 0. Using this inductive hypothesis, we have
n􏳣1
EŒT.n/􏳩 􏳥 2 X ckCan
EŒT.k/􏳩CO.n/:
kDbn=2c
n kDbn=2c
n􏳣1 bn=2c􏳣1 !
D 2c Xk􏳣 X k Can n kD1 kD1

9.2 Selection in expected linear time 219
2c 􏳧.n􏳣1/n .bn=2c􏳣1/bn=2c􏳹
D n 2 􏳣 2 Can
2c 􏳧.n 􏳣 1/n .n=2 􏳣 2/.n=2 􏳣 1/􏳹 􏳥n2􏳣 2 Can
2c 􏳧n2 􏳣n n2=4􏳣3n=2C2􏳹 Dn2􏳣 2 Can
c􏳧3n2 n 􏳹 Dn 4C2􏳣2Can
􏳧3n 1 2􏳹
D c 4C2􏳣n Can
􏳥 3cnCcCan 4􏳰2􏳳
D cn􏳣 cn􏳣c􏳣an : 42
In order to complete the proof, we need to show that for sufficiently large n, this last expression is at most cn or, equivalently, that cn=4 􏳣 c=2 􏳣 an 􏳦 0. If we add c=2 to both sides and factor out n, we get n.c=4 􏳣 a/ 􏳦 c=2. As long as we choose the constant c so that c=4 􏳣 a > 0, i.e., c > 4a, we can divide both sides by c=4 􏳣 a, giving
n􏳦 c=2 D 2c : c=4 􏳣 a c 􏳣 4a
Thus, if we assume that T .n/ D O.1/ for n < 2c=.c 􏳣4a/, then E ŒT .n/􏳩 D O.n/. We conclude that we can find any order statistic, and in particular the median, in expected linear time, assuming that the elements are distinct. Exercises 9.2-1 Show that RANDOMIZED-SELECT never makes a recursive call to a 0-length array. 9.2-2 Argue that the indicator random variable Xk and the value T .max.k 􏳣 1; n 􏳣 k// are independent. 9.2-3 Write an iterative version of RANDOMIZED-SELECT. 220 Chapter 9 Medians and Order Statistics 9.2-4 Suppose we use RANDOMIZED-SELECT to select the minimum element of the array A D h3; 2; 9; 0; 7; 5; 4; 8; 6; 1i. Describe a sequence of partitions that results in a worst-case performance of RANDOMIZED-SELECT. 9.3 Selection in worst-case linear time We now examine a selection algorithm whose running time is O.n/ in the worst case. Like RANDOMIZED-SELECT, the algorithm SELECT finds the desired ele- ment by recursively partitioning the input array. Here, however, we guarantee a good split upon partitioning the array. SELECT uses the deterministic partitioning algorithm PARTITION from quicksort (see Section 7.1), but modified to take the element to partition around as an input parameter. The SELECT algorithm determines the ith smallest of an input array of n > 1 distinct elements by executing the following steps. (If n D 1, then SELECT merely returns its only input value as the ith smallest.)
1. Divide the n elements of the input array into bn=5c groups of 5 elements each and at most one group made up of the remaining n mod 5 elements.
2. Find the median of each of the dn=5e groups by first insertion-sorting the ele- ments of each group (of which there are at most 5) and then picking the median from the sorted list of group elements.
3. Use S E L E C T recursively to find the median x of the dn=5e medians found in step 2. (If there are an even number of medians, then by our convention, x is the lower median.)
4. Partition the input array around the median-of-medians x using the modified version of PARTITION. Let k be one more than the number of elements on the low side of the partition, so that x is the kth smallest element and there are n􏳣k elements on the high side of the partition.
5. If i D k, then return x. Otherwise, use SELECT recursively to find the ith smallest element on the low side if i < k, or the .i 􏳣 k/th smallest element on the high side if i > k.
To analyze the running time of SELECT, we first determine a lower bound on the
number of elements that are greater than the partitioning element x. Figure 9.1 helps us to visualize this bookkeeping. At least half of the medians found in

9.3 Selection in worst-case linear time 221
x
Figure 9.1 Analysis of the algorithm SELECT. The n elements are represented by small circles, and each group of 5 elements occupies a column. The medians of the groups are whitened, and the median-of-medians x is labeled. (When finding the median of an even number of elements, we use the lower median.) Arrows go from larger elements to smaller, from which we can see that 3 out of every full group of 5 elements to the right of x are greater than x, and 3 out of every group of 5 elements to the left of x are less than x. The elements known to be greater than x appear on a shaded background.
step 2 are greater than or equal to the median-of-medians x.1 Thus, at least half of the dn=5e groups contribute at least 3 elements that are greater than x, except for the one group that has fewer than 5 elements if 5 does not divide n exactly, and the one group containing x itself. Discounting these two groups, it follows that the number of elements greater than x is at least
􏳧􏳺1 lnm􏳬 􏳹 3n
3 2 5 􏳣2 􏳦 10􏳣6:
Similarly, at least 3n=10 􏳣 6 elements are less than x. Thus, in the worst case, step 5 calls SELECT recursively on at most 7n=10 C 6 elements.
We can now develop a recurrence for the worst-case running time T .n/ of the algorithm SELECT. Steps 1, 2, and 4 take O.n/ time. (Step 2 consists of O.n/ calls of insertion sort on sets of size O.1/.) Step 3 takes time T .dn=5e/, and step 5 takes time at most T .7n=10 C 6/, assuming that T is monotonically increasing. We make the assumption, which seems unmotivated at first, that any input of fewer than 140 elements requires O.1/ time; the origin of the magic constant 140 will be clear shortly. We can therefore obtain the recurrence
1Because of our assumption that the numbers are distinct, all medians except x are either greater than or less than x.

222 Chapter 9
Medians and Order Statistics
(
T .n/ 􏳥
We show that the running time is linear by substitution. More specifically, we will show that T .n/ 􏳥 cn for some suitably large constant c and all n > 0. We begin by assuming that T .n/ 􏳥 cn for some suitably large constant c and all n < 140; this assumption holds if c is large enough. We also pick a constant a such that the func- tion described by the O.n/ term above (which describes the non-recursive compo- nent of the running time of the algorithm) is bounded above by an for all n > 0. Substituting this inductive hypothesis into the right-hand side of the recurrence yields
O.1/ if n < 140 ; T.dn=5e/CT.7n=10C6/CO.n/ ifn􏳦140: T.n/ 􏳥 cdn=5eCc.7n=10C6/Can 􏳥 cn=5CcC7cn=10C6cCan D 9cn=10C7cCan D cnC.􏳣cn=10C7cCan/; which is at most cn if 􏳣cn=10 C 7c C an 􏳥 0 : (9.2) Inequality (9.2) is equivalent to the inequality c 􏳦 10a.n=.n 􏳣 70// when n > 70.
Because we assume that n 􏳦 140, we have n=.n 􏳣 70/ 􏳥 2, and so choos- ing c 􏳦 20a will satisfy inequality (9.2). (Note that there is nothing special about the constant 140; we could replace it by any integer strictly greater than 70 and then choose c accordingly.) The worst-case running time of SELECT is therefore linear.
As in a comparison sort (see Section 8.1), SELECT and RANDOMIZED-SELECT determine information about the relative order of elements only by comparing ele- ments. Recall from Chapter 8 that sorting requires 􏳫.n lg n/ time in the compari- son model, even on average (see Problem 8-1). The linear-time sorting algorithms in Chapter 8 make assumptions about the input. In contrast, the linear-time se- lection algorithms in this chapter do not require any assumptions about the input. They are not subject to the 􏳫.n lg n/ lower bound because they manage to solve the selection problem without sorting. Thus, solving the selection problem by sort- ing and indexing, as presented in the introduction to this chapter, is asymptotically inefficient.

9.3 Selection in worst-case linear time 223
Exercises
9.3-1
In the algorithm SELECT, the input elements are divided into groups of 5. Will the algorithm work in linear time if they are divided into groups of 7? Argue that SELECT does not run in linear time if groups of 3 are used.
9.3-2
Analyze SELECT to show that if n 􏳦 140, then at least dn=4e elements are greater than the median-of-medians x and at least dn=4e elements are less than x.
9.3-3
Show how quicksort can be made to run in O.n lg n/ time in the worst case, as- suming that all elements are distinct.
9.3-4 ?
Suppose that an algorithm uses only comparisons to find the ith smallest element in a set of n elements. Show that it can also find the i 􏳣 1 smaller elements and the n 􏳣 i larger elements without performing any additional comparisons.
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 arbi- trary order statistic.
9.3-6
The kth quantiles of an n-element set are the k 􏳣 1 order statistics that divide the sorted set into k equal-sized sets (to within 1). Give an O.n lg k/-time algorithm to list the kth quantiles of a set.
9.3-7
Describe an O.n/-time algorithm that, given a set S of n distinct numbers and a positive integer k 􏳥 n, determines the k numbers in S that are closest to the median of S.
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 to find the median of all 2n elements in arrays X and Y .
9.3-9
Professor Olay is consulting for an oil company, which is planning a large pipeline running east to west through an oil field of n wells. The company wants to connect

224 Chapter 9 Medians and Order Statistics
Problems
Figure 9.2 Professor Olay needs to determine the position of the east-west oil pipeline that mini- mizes the total length of the north-south spurs.
a spur pipeline from each well directly to the main pipeline along a shortest route (either north or south), as shown in Figure 9.2. Given the x- and y-coordinates of the wells, how should the professor pick the optimal location of the main pipeline, which would be the one that minimizes the total length of the spurs? Show how to determine the optimal location in linear time.
9-1 Largest i numbers in sorted order
Given a set of n numbers, we wish to find the i largest in sorted order using a comparison-based algorithm. Find the algorithm that implements each of the fol- lowing methods with the best asymptotic worst-case running time, and analyze the running times of the algorithms in terms of n and i.
a. Sort the numbers, and list the i largest.
b. Build a max-priority queue from the numbers, and call EXTRACT-MAX i times.
c. Use an order-statistic algorithm to find the ith largest number, partition around that number, and sort the i largest numbers.

Problems for Chapter 9 225
9-2 Weighted median
Forndistinctelementsx1;x2;:::;xn withpositiveweightsw1;w2;:::;wn such that PniD1 wi D 1, the weighted (lower) median is the element xk satisfying
X1
wi < 2 xi xk 2
For example, if the elements are 0:1; 0:35; 0:05; 0:1; 0:15; 0:05; 0:2 and each ele- mentequalsitsweight(thatis,wi Dxi fori D1;2;:::;7),thenthemedianis0:1, but the weighted median is 0:2.
a. Argue that the median of x1; x2; : : : ; xn is the weighted median of the xi with weights wi D 1=n for i D 1;2;:::;n.
b. Show how to compute the weighted median of n elements in O.n lg n/ worst- case time using sorting.
c. Show how to compute the weighted median in ‚.n/ worst-case time using a linear-time median algorithm such as SELECT from Section 9.3.
The post-office location problem is defined as follows. We are given n points p ;p ;:::;p with associated weights w ;w ;:::;w . We wish to find a point p
12 n 12 n Pn
(not necessarily one of the input points) that minimizes the sum iD1 wi d.p;pi/, where d.a; b/ is the distance between points a and b.
d.
e.
9-3
Argue that the weighted median is a best solution for the 1-dimensional post- office location problem, in which points are simply real numbers and the dis- tance between points a and b is d.a; b/ D ja 􏳣 bj.
Find the best solution for the 2-dimensional post-office location problem, in which the points are .x;y/ coordinate pairs and the distance between points a D .x1; y1/ and b D .x2; y2/ is the Manhattan distance given by d.a; b/ D jx1 􏳣x2jCjy1 􏳣y2j.
Small order statistics
We showed that the worst-case number T.n/ of comparisons used by SELECT to select the ith order statistic from n numbers satisfies T.n/ D ‚.n/, but the constant hidden by the ‚-notation is rather large. When i is small relative to n, we can implement a different procedure that uses SELECT as a subroutine but makes fewer comparisons in the worst case.

226 Chapter 9 Medians and Order Statistics
a. Describe an algorithm that uses Ui .n/ comparisons to find the i th smallest of n elements, where
(
T .n/ if i 􏳦 n=2 ; bn=2cCUi.dn=2e/CT.2i/ otherwise:
Ui .n/ D
(Hint: Begin with bn=2c disjoint pairwise comparisons, and recurse on the set
containing the smaller element from each pair.)
b. Showthat,ifi k return NIL
searching a sorted linked list, in which index i points to each position of the list in
1Because we have defined a mergeable heap to support MINIMUM and EXTRACT-MIN, we can also refer to it as a mergeable min-heap. Alternatively, if it supported MAXIMUM and EXTRACT-MAX, it would be a mergeable max-heap.

Problems for Chapter 10 251
turn. The search terminates once the index i “falls off” the end of the list or once keyŒi􏳩 􏳦 k. In the latter case, if keyŒi􏳩 D k, clearly we have found a key with the value k. If, however, keyŒi􏳩 > k, then we will never find a key with the value k, and so terminating the search was the right thing to do.
Lines 3–7 attempt to skip ahead to a randomly chosen position j . Such a skip benefits us if keyŒj􏳩 is larger than keyŒi􏳩 and no larger than k; in such a case, j marks a position in the list that i would have to reach during an ordinary list search. Because the list is compact, we know that any choice of j between 1 and n indexes some object in the list rather than a slot on the free list.
Instead of analyzing the performance of COMPACT-LIST-SEARCH directly, we shall analyze a related algorithm, COMPACT-LIST-SEARCH0, which executes two separate loops. This algorithm takes an additional parameter t which determines an upper bound on the number of iterations of the first loop.
COMPACT-LIST-SEARCH0 .L; n; k; t/
1iDL
2 forqD1tot
3 j D RANDOM.1;n/
4 if keyŒi􏳩 < keyŒj􏳩 and keyŒj􏳩 􏳥 k 5 iDj 6 if keyŒi􏳩 == k 7 return i 8 whilei¤NILandkeyŒi􏳩k 11 return NIL
12 else return i
To compare the execution of the algorithms COMPACT-LIST-SEARCH.L; n; k/ and COMPACT-LIST-SEARCH0.L; n; k; t/, assume that the sequence of integers re- turned by the calls of RANDOM.1;n/ is the same for both algorithms.
a. Suppose that COMPACT-LIST-SEARCH.L; n; k/ takes t iterations of the while loop of lines 2–8. Argue that COMPACT-LIST-SEARCH0.L; n; k; t/ returns the same answer and that the total number of iterations of both the for and while loops within COMPACT-LIST-SEARCH0 is at least t.
In the call COMPACT-LIST-SEARCH0.L; n; k; t/, let Xt be the random variable that describes the distance in the linked list (that is, through the chain of next pointers) from position i to the desired key k after t iterations of the for loop of lines 2–7 have occurred.

252 Chapter 10 Elementary Data Structures
b. Argue that the expected running time of COMPACT-LIST-SEARCH0.L; n; k; t/ is O.t C E ŒXt 􏳩/.
c. Show that E ŒXt 􏳩 􏳥 PnrD1.1 􏳣 r=n/t . (Hint: Use equation (C.25).) d. ShowthatPn􏳣1rt 􏳥ntC1=.tC1/.
rD0
e. ProvethatEŒXt􏳩􏳥n=.tC1/.
f. Show that COMPACT-LIST-SEARCH0.L; n; k; t/ runs in O.t C n=t/ expected time.
g. Conclude that COMPACT-LIST-SEARCH runs in O.pn/ expected time.
h. Why do we assume that all keys are distinct in COMPACT-LIST-SEARCH? Ar- gue that random skips do not necessarily help asymptotically when the list con- tains repeated key values.
Chapter notes
Aho, Hopcroft, and Ullman [6] and Knuth [209] are excellent references for ele- mentary data structures. Many other texts cover both basic data structures and their implementation in a particular programming language. Examples of these types of textbooks include Goodrich and Tamassia [147], Main [241], Shaffer [311], and Weiss [352, 353, 354]. Gonnet [145] provides experimental data on the perfor- mance of many data-structure operations.
The origin of stacks and queues as data structures in computer science is un- clear, since corresponding notions already existed in mathematics and paper-based business practices before the introduction of digital computers. Knuth [209] cites A. M. Turing for the development of stacks for subroutine linkage in 1947.
Pointer-based data structures also seem to be a folk invention. According to Knuth, pointers were apparently used in early computers with drum memories. The A-1 language developed by G. M. Hopper in 1951 represented algebraic formulas as binary trees. Knuth credits the IPL-II language, developed in 1956 by A. Newell, J. C. Shaw, and H. A. Simon, for recognizing the importance and promoting the use of pointers. Their IPL-III language, developed in 1957, included explicit stack operations.

11 Hash Tables
Many applications require a dynamic set that supports only the dictionary opera- tions INSERT, SEARCH, and DELETE. For example, a compiler that translates a programming language maintains a symbol table, in which the keys of elements are arbitrary character strings corresponding to identifiers in the language. A hash table is an effective data structure for implementing dictionaries. Although search- ing for an element in a hash table can take as long as searching for an element in a linked list—‚.n/ time in the worst case—in practice, hashing performs extremely well. Under reasonable assumptions, the average time to search for an element in a hash table is O.1/.
A hash table generalizes the simpler notion of an ordinary array. Directly ad- dressing into an ordinary array makes effective use of our ability to examine an arbitrary position in an array in O.1/ time. Section 11.1 discusses direct address- ing in more detail. We can take advantage of direct addressing when we can afford to allocate an array that has one position for every possible key.
When the number of keys actually stored is small relative to the total number of possible keys, hash tables become an effective alternative to directly addressing an array, since a hash table typically uses an array of size proportional to the number of keys actually stored. Instead of using the key as an array index directly, the array index is computed from the key. Section 11.2 presents the main ideas, focusing on “chaining” as a way to handle “collisions,” in which more than one key maps to the same array index. Section 11.3 describes how we can compute array indices from keys using hash functions. We present and analyze several variations on the basic theme. Section 11.4 looks at “open addressing,” which is another way to deal with collisions. The bottom line is that hashing is an extremely effective and practical technique: the basic dictionary operations require only O.1/ time on the average. Section 11.5 explains how “perfect hashing” can support searches in O.1/ worst- case time, when the set of keys being stored is static (that is, when the set of keys never changes once stored).

254
Chapter 11 Hash Tables
11.1
Direct-address tables
Direct addressing is a simple technique that works well when the universe U of keys is reasonably small. Suppose that an application needs a dynamic set in which each element has a key drawn from the universe U D f0;1;:::;m􏳣1g, where m is not too large. We shall assume that no two elements have the same key.
To represent the dynamic set, we use an array, or direct-address table, denoted by T Œ0 : : m 􏳣 1􏳩, in which each position, or slot, corresponds to a key in the uni- verse U . Figure 11.1 illustrates the approach; slot k points to an element in the set with key k. If the set contains no element with key k, then T Œk􏳩 D NIL.
The dictionary operations are trivial to implement: DIRECT-ADDRESS-SEARCH.T;k/
1 returnTŒk􏳩 DIRECT-ADDRESS-INSERT.T;x/
1 TŒx:key􏳩Dx DIRECT-ADDRESS-DELETE.T;x/
1 TŒx:key􏳩DNIL
Each of these operations takes only O.1/ time.
U
(universe of keys) 06
9
4
T
0 1 2 3 4 5 6 7 8 9
key satellite data
2
3
1
K
(actual keys)
7
2
3
5
8
5
8
How to implement a dynamic set by a direct-address table T . Each key in the universe U D f0;1;:::;9g corresponds to an index in the table. The set K D f2;3;5;8g of actual keys determines the slots in the table that contain pointers to elements. The other slots, heavily shaded, contain NIL.
Figure 11.1

11.1 Direct-address tables 255
For some applications, the direct-address table itself can hold the elements in the dynamic set. That is, rather than storing an element’s key and satellite data in an object external to the direct-address table, with a pointer from a slot in the table to the object, we can store the object in the slot itself, thus saving space. We would use a special key within an object to indicate an empty slot. Moreover, it is often unnecessary to store the key of the object, since if we have the index of an object in the table, we have its key. If keys are not stored, however, we must have some way to tell whether the slot is empty.
Exercises
11.1-1
Suppose that a dynamic set S is represented by a direct-address table T of length m. Describe a procedure that finds the maximum element of S. What is the worst-case performance of your procedure?
11.1-2
A bit vector is simply an array of bits (0s and 1s). A bit vector of length m takes much less space than an array of m pointers. Describe how to use a bit vector to represent a dynamic set of distinct elements with no satellite data. Dictionary operations should run in O.1/ time.
11.1-3
Suggest how to implement a direct-address table in which the keys of stored el- ements do not need to be distinct and the elements can have satellite data. All three dictionary operations (INSERT, DELETE, and SEARCH) should run in O.1/ time. (Don’t forget that DELETE takes as an argument a pointer to an object to be deleted, not a key.)
11.1-4 ?
We wish to implement a dictionary by using direct addressing on a huge array. At the start, the array entries may contain garbage, and initializing the entire array is impractical because of its size. Describe a scheme for implementing a direct- address dictionary on a huge array. Each stored object should use O.1/ space; the operations SEARCH, INSERT, and DELETE should take O.1/ time each; and initializing the data structure should take O.1/ time. (Hint: Use an additional array, treated somewhat like a stack whose size is the number of keys actually stored in the dictionary, to help determine whether a given entry in the huge array is valid or not.)

256
Chapter 11 Hash Tables
11.2
Hash tables
The downside of direct addressing is obvious: if the universe U is large, storing a table T of size jU j may be impractical, or even impossible, given the memory available on a typical computer. Furthermore, the set K of keys actually stored may be so small relative to U that most of the space allocated for T would be wasted.
When the set K of keys stored in a dictionary is much smaller than the uni- verse U of all possible keys, a hash table requires much less storage than a direct- address table. Specifically, we can reduce the storage requirement to ‚.jKj/ while we maintain the benefit that searching for an element in the hash table still requires only O.1/ time. The catch is that this bound is for the average-case time, whereas for direct addressing it holds for the worst-case time.
With direct addressing, an element with key k is stored in slot k. With hashing, this element is stored in slot h.k/; that is, we use a hash function h to compute the slot from the key k. Here, h maps the universe U of keys into the slots of a hash table TŒ0::m􏳣1􏳩:
hWU !f0;1;:::;m􏳣1g ;
where the size m of the hash table is typically much less than jU j. We say that an element with key k hashes to slot h.k/; we also say that h.k/ is the hash value of key k. Figure 11.2 illustrates the basic idea. The hash function reduces the range of array indices and hence the size of the array. Instead of a size of jU j, the array can have size m.
T
0 h(k1)
h(k4)
h(k2) = h(k5) h(k3)
m–1
U
(universe of keys) k1
5
k2
Using a hash function h to map keys to hash-table slots. Because keys k2 and k5 map to the same slot, they collide.
K k4 k
(actual keys)
k3
Figure 11.2

11.2
Hash tables
257
U
(universe of keys) k1
K k4 k5
k1 k4
k6
T
(actual keys)
k8 6
k k k
k7
k2 k k3
5 2
7
k3 k8
Collision resolution by chaining. Each hash-table slot T Œj 􏳩 contains a linked list of all the keys whose hash value is j. For example, h.k1/ D h.k4/ and h.k5/ D h.k7/ D h.k2/. The linked list can be either singly or doubly linked; we show it as doubly linked because deletion is faster that way.
There is one hitch: two keys may hash to the same slot. We call this situation a collision. Fortunately, we have effective techniques for resolving the conflict created by collisions.
Of course, the ideal solution would be to avoid collisions altogether. We might try to achieve this goal by choosing a suitable hash function h. One idea is to make h appear to be “random,” thus avoiding collisions or at least minimizing their number. The very term “to hash,” evoking images of random mixing and chopping, captures the spirit of this approach. (Of course, a hash function h must be deterministic in that a given input k should always produce the same output h.k/.) Because jU j > m, however, there must be at least two keys that have the same hash value; avoiding collisions altogether is therefore impossible. Thus, while a well- designed, “random”-looking hash function can minimize the number of collisions, we still need a method for resolving the collisions that do occur.
The remainder of this section presents the simplest collision resolution tech- nique, called chaining. Section 11.4 introduces an alternative method for resolving collisions, called open addressing.
Collision resolution by chaining
In chaining, we place all the elements that hash to the same slot into the same linked list, as Figure 11.3 shows. Slot j contains a pointer to the head of the list of all stored elements that hash to j ; if there are no such elements, slot j contains NIL.
Figure 11.3

258 Chapter 11 Hash Tables
The dictionary operations on a hash table T are easy to implement when colli- sions are resolved by chaining:
CHAINED-HASH-INSERT.T;x/
1 insert x at the head of list T Œh.x:key/􏳩
CHAINED-HASH-SEARCH.T;k/
1 search for an element with key k in list T Œh.k/􏳩
CHAINED-HASH-DELETE.T;x/
1 delete x from the list T Œh.x:key/􏳩
The worst-case running time for insertion is O.1/. The insertion procedure is fast in part because it assumes that the element x being inserted is not already present in the table; if necessary, we can check this assumption (at additional cost) by search- ing for an element whose key is x:key before we insert. For searching, the worst- case running time is proportional to the length of the list; we shall analyze this operation more closely below. We can delete an element in O.1/ time if the lists are doubly linked, as Figure 11.3 depicts. (Note that CHAINED-HASH-DELETE takes as input an element x and not its key k, so that we don’t have to search for x first. If the hash table supports deletion, then its linked lists should be doubly linked so that we can delete an item quickly. If the lists were only singly linked, then to delete element x, we would first have to find x in the list T Œh.x:key/􏳩 so that we could update the next attribute of x’s predecessor. With singly linked lists, both deletion and searching would have the same asymptotic running times.)
Analysis of hashing with chaining
How well does hashing with chaining perform? In particular, how long does it take to search for an element with a given key?
Given a hash table T with m slots that stores n elements, we define the load factor ̨ for T as n=m, that is, the average number of elements stored in a chain. Our analysis will be in terms of ̨, which can be less than, equal to, or greater than 1.
The worst-case behavior of hashing with chaining is terrible: all n keys hash to the same slot, creating a list of length n. The worst-case time for searching is thus ‚.n/ plus the time to compute the hash function—no better than if we used one linked list for all the elements. Clearly, we do not use hash tables for their worst-case performance. (Perfect hashing, described in Section 11.5, does provide good worst-case performance when the set of keys is static, however.)
The average-case performance of hashing depends on how well the hash func- tion h distributes the set of keys to be stored among the m slots, on the average.

11.2 Hash tables 259
Section 11.3 discusses these issues, but for now we shall assume that any given element is equally likely to hash into any of the m slots, independently of where any other element has hashed to. We call this the assumption of simple uniform hashing.
Forj D0;1;:::;m􏳣1,letusdenotethelengthofthelistTŒj􏳩bynj,sothat
nDn0 Cn1 C􏳵􏳵􏳵Cnm􏳣1 ; (11.1)
andtheexpectedvalueofnj isEŒnj􏳩D ̨Dn=m.
We assume that O.1/ time suffices to compute the hash value h.k/, so that
the time required to search for an element with key k depends linearly on the length nh.k/ of the list T Œh.k/􏳩. Setting aside the O.1/ time required to compute the hash function and to access slot h.k/, let us consider the expected number of elements examined by the search algorithm, that is, the number of elements in the list T Œh.k/􏳩 that the algorithm checks to see whether any have a key equal to k. We shall consider two cases. In the first, the search is unsuccessful: no element in the table has key k. In the second, the search successfully finds an element with key k.
Theorem 11.1
In a hash table in which collisions are resolved by chaining, an unsuccessful search takes average-case time ‚.1C ̨/, under the assumption of simple uniform hashing.
Proof Under the assumption of simple uniform hashing, any key k not already stored in the table is equally likely to hash to any of the m slots. The expected time to search unsuccessfully for a key k is the expected time to search to the end of list T Œh.k/􏳩, which has expected length E Œnh.k/􏳩 D ̨. Thus, the expected number of elements examined in an unsuccessful search is ̨, and the total time required (including the time for computing h.k/) is ‚.1 C ̨/.
The situation for a successful search is slightly different, since each list is not equally likely to be searched. Instead, the probability that a list is searched is pro- portional to the number of elements it contains. Nonetheless, the expected search time still turns out to be ‚.1 C ̨/.
Theorem 11.2
In a hash table in which collisions are resolved by chaining, a successful search takes average-case time ‚.1C ̨/, under the assumption of simple uniform hashing.
Proof We assume that the element being searched for is equally likely to be any of the n elements stored in the table. The number of elements examined during a successful search for an element x is one more than the number of elements that

260 Chapter 11 Hash Tables
appear before x in x’s list. Because new elements are placed at the front of the list, elements before x in the list were all inserted after x was inserted. To find the expected number of elements examined, we take the average, over the n ele- ments x in the table, of 1 plus the expected number of elements added to x’s list after x was added to the list. Let xi denote the ith element inserted into the ta- ble, for i D 1;2;:::;n, and let ki D xi:key. For keys ki and kj, we define the indicatorrandomvariableXij DIfh.ki/Dh.kj/g.Undertheassumptionofsim- ple uniform hashing, we have Pr fh.ki / D h.kj /g D 1=m, and so by Lemma 5.1, E ŒXij 􏳩 D 1=m. Thus, the expected number of elements examined in a successful search is
“Xn Xn !# E1 1C Xij
n iD1 jDiC1 1 Xn
! jDiC1 !
Xn 1Xn Xn1
D n
iD1
1 C
E ŒXij 􏳩
(by linearity of expectation)
Dn1Cm iD1 jDiC1
1 Xn
D 1Cnm .n􏳣i/
iD1
1 Xn Xn
D1Cnm n􏳣 i 􏳧iD1 iD1
!
􏳹
D 1C 1 n2 􏳣 n.nC1/ nm 2
D 1Cn􏳣1 2m
D1C ̨􏳣 ̨: 2 2n
(by equation (A.1))
Thus, the total time required for a successful search (including the time for com- puting the hash function) is ‚.2 C ̨=2 􏳣 ̨=2n/ D ‚.1 C ̨/.
What does this analysis mean? If the number of hash-table slots is at least pro- portional to the number of elements in the table, we have n D O.m/ and, con- sequently, ̨ D n=m D O.m/=m D O.1/. Thus, searching takes constant time on average. Since insertion takes O.1/ worst-case time and deletion takes O.1/ worst-case time when the lists are doubly linked, we can support all dictionary operations in O.1/ time on average.

11.2 Hash tables 261
Exercises
11.2-1
Suppose we use a hash function h to hash n distinct keys into an array T of length m. Assuming simple uniform hashing, what is the expected number of collisions? More precisely, what is the expected cardinality of ffk;lg W k ¤ l and
h.k/ D h.l/g?
11.2-2
Demonstrate what happens when we insert the keys 5; 28; 19; 15; 20; 33; 12; 17; 10 into a hash table with collisions resolved by chaining. Let the table have 9 slots, and let the hash function be h.k/ D k mod 9.
11.2-3
Professor Marley hypothesizes that he can obtain substantial performance gains by modifying the chaining scheme to keep each list in sorted order. How does the pro- fessor’s modification affect the running time for successful searches, unsuccessful searches, insertions, and deletions?
11.2-4
Suggest how to allocate and deallocate storage for elements within the hash table itself by linking all unused slots into a free list. Assume that one slot can store a flag and either one element plus a pointer or two pointers. All dictionary and free-list operations should run in O.1/ expected time. Does the free list need to be doubly linked, or does a singly linked free list suffice?
11.2-5
Suppose that we are storing a set of n keys into a hash table of size m. Show that if the keys are drawn from a universe U with jU j > nm, then U has a subset of size n consisting of keys that all hash to the same slot, so that the worst-case searching time for hashing with chaining is ‚.n/.
11.2-6
Suppose we have stored n keys in a hash table of size m, with collisions resolved by chaining, and that we know the length of each chain, including the length L of the longest chain. Describe a procedure that selects a key uniformly at random from among the keys in the hash table and returns it in expected time O.L 􏳵 .1 C 1= ̨//.

262
Chapter 11 Hash Tables
11.3
Hash functions
In this section, we discuss some issues regarding the design of good hash functions and then present three schemes for their creation. Two of the schemes, hashing by division and hashing by multiplication, are heuristic in nature, whereas the third scheme, universal hashing, uses randomization to provide provably good perfor- mance.
What makes a good hash function?
A good hash function satisfies (approximately) the assumption of simple uniform hashing: each key is equally likely to hash to any of the m slots, independently of where any other key has hashed to. Unfortunately, we typically have no way to check this condition, since we rarely know the probability distribution from which the keys are drawn. Moreover, the keys might not be drawn independently.
Occasionally we do know the distribution. For example, if we know that the keys are random real numbers k independently and uniformly distributed in the range 0 􏳥 k < 1, then the hash function h.k/ D bkmc satisfies the condition of simple uniform hashing. In practice, we can often employ heuristic techniques to create a hash function that performs well. Qualitative information about the distribution of keys may be useful in this design process. For example, consider a compiler’s symbol table, in which the keys are character strings representing identifiers in a program. Closely related symbols, such as pt and pts, often occur in the same program. A good hash function would minimize the chance that such variants hash to the same slot. A good approach derives the hash value in a way that we expect to be indepen- dent of any patterns that might exist in the data. For example, the “division method” (discussed in Section 11.3.1) computes the hash value as the remainder when the key is divided by a specified prime number. This method frequently gives good results, assuming that we choose a prime number that is unrelated to any patterns in the distribution of keys. Finally, we note that some applications of hash functions might require stronger properties than are provided by simple uniform hashing. For example, we might want keys that are “close” in some sense to yield hash values that are far apart. (This property is especially desirable when we are using linear probing, defined in Section 11.4.) Universal hashing, described in Section 11.3.3, often provides the desired properties. 11.3 Hash functions 263 Interpreting keys as natural numbers Most hash functions assume that the universe of keys is the set N D f0; 1; 2; : : :g of natural numbers. Thus, if the keys are not natural numbers, we find a way to interpret them as natural numbers. For example, we can interpret a character string as an integer expressed in suitable radix notation. Thus, we might interpret the identifier pt as the pair of decimal integers .112; 116/, since p D 112 and t D 116 in the ASCII character set; then, expressed as a radix-128 integer, pt becomes .112 􏳵 128/ C 116 D 14452. In the context of a given application, we can usually devise some such method for interpreting each key as a (possibly large) natural number. In what follows, we assume that the keys are natural numbers. 11.3.1 The division method In the division method for creating hash functions, we map a key k into one of m slots by taking the remainder of k divided by m. That is, the hash function is h.k/ D k mod m : For example, if the hash table has size m D 12 and the key is k D 100, then h.k/ D 4. Since it requires only a single division operation, hashing by division is quite fast. When using the division method, we usually avoid certain values of m. For example, m should not be a power of 2, since if m D 2p, then h.k/ is just the p lowest-order bits of k. Unless we know that all low-order p-bit patterns are equally likely, we are better off designing the hash function to depend on all the bits of the key. As Exercise 11.3-3 asks you to show, choosing m D 2p 􏳣 1 when k is a character string interpreted in radix 2p may be a poor choice, because permuting the characters of k does not change its hash value. A prime not too close to an exact power of 2 is often a good choice for m. For example, suppose we wish to allocate a hash table, with collisions resolved by chaining, to hold roughly n D 2000 character strings, where a character has 8 bits. We don’t mind examining an average of 3 elements in an unsuccessful search, and so we allocate a hash table of size m D 701. We could choose m D 701 because it is a prime near 2000=3 but not near any power of 2. Treating each key k as an integer, our hash function would be h.k/Dk mod701: 11.3.2 The multiplication method The multiplication method for creating hash functions operates in two steps. First, we multiply the key k by a constant A in the range 0 < A < 1 and extract the 264 Chapter 11 Hash Tables w bits k × s D A 􏳵 2w r1 h.k/ r0 extract p bits The multiplication method of hashing. The w-bit representation of the key k is multi- plied by the w-bit value s D A 􏳵 2w . The p highest-order bits of the lower w-bit half of the product form the desired hash value h.k/. fractional part of kA. Then, we multiply this value by m and take the floor of the result. In short, the hash function is h.k/Dbm.kAmod1/c ; where “kA mod 1” means the fractional part of kA, that is, kA 􏳣 bkAc. An advantage of the multiplication method is that the value of m is not critical. We typically choose it to be a power of 2 (m D 2p for some integer p), since we can then easily implement the function on most computers as follows. Suppose that the word size of the machine is w bits and that k fits into a single word. We restrict A to be a fraction of the form s=2w , where s is an integer in the range 0 < s < 2w. Referring to Figure 11.4, we first multiply k by the w-bit integer s D A 􏳵 2w . The result is a 2w-bit value r12w C r0, where r1 is the high-order word of the product and r0 is the low-order word of the product. The desired p-bit hash value consists of the p most significant bits of r0. Although this method works with any value of the constant A, it works better with some values than with others. The optimal choice depends on the character- istics of the data being hashed. Knuth [211] suggests that p A􏳬. 5􏳣1/=2D0:6180339887::: (11.2) is likely to work reasonably well. As an example, suppose we have k D 123456, p D 14, m D 214 D 16384, and w D 32. Adapting Knuth’s suggestion, we choose A to be the fraction of the form s=232 that is closest to .p5 􏳣 1/=2, so that A D 2654435769=232 . Then k 􏳵 s D 327706022297664 D .76300 􏳵 232/ C 17612864, and so r1 D 76300 and r0 D 17612864. The 14 most significant bits of r0 yield the value h.k/ D 67. Figure 11.4 11.3 Hash functions 265 ? 11.3.3 Universal hashing If a malicious adversary chooses the keys to be hashed by some fixed hash function, then the adversary can choose n keys that all hash to the same slot, yielding an av- erage retrieval time of ‚.n/. Any fixed hash function is vulnerable to such terrible worst-case behavior; the only effective way to improve the situation is to choose the hash function randomly in a way that is independent of the keys that are actually going to be stored. This approach, called universal hashing, can yield provably good performance on average, no matter which keys the adversary chooses. In universal hashing, at the beginning of execution we select the hash function at random from a carefully designed class of functions. As in the case of quick- sort, randomization guarantees that no single input will always evoke worst-case behavior. Because we randomly select the hash function, the algorithm can be- have differently on each execution, even for the same input, guaranteeing good average-case performance for any input. Returning to the example of a compiler’s symbol table, we find that the programmer’s choice of identifiers cannot now cause consistently poor hashing performance. Poor performance occurs only when the compiler chooses a random hash function that causes the set of identifiers to hash poorly, but the probability of this situation occurring is small and is the same for any set of identifiers of the same size. Let H be a finite collection of hash functions that map a given universe U of keys into the range f0; 1; : : : ; m 􏳣 1g. Such a collection is said to be universal if for each pair of distinct keys k;l 2 U, the number of hash functions h 2 H for which h.k/ D h.l/ is at most jHj=m. In other words, with a hash function randomly chosen from H , the chance of a collision between distinct keys k and l is no more than the chance 1=m of a collision if h.k/ and h.l/ were randomly and independently chosen from the set f0; 1; : : : ; m 􏳣 1g. The following theorem shows that a universal class of hash functions gives good average-case behavior. Recall that ni denotes the length of list T Œi 􏳩. Theorem 11.3 Suppose that a hash function h is chosen randomly from a universal collection of hash functions and has been used to hash n keys into a table T of size m, us- ing chaining to resolve collisions. If key k is not in the table, then the expected length E Œnh.k/􏳩 of the list that key k hashes to is at most the load factor ̨ D n=m. If key k is in the table, then the expected length E Œnh.k/􏳩 of the list containing key k is at most 1 C ̨. Proof We note that the expectations here are over the choice of the hash func- tion and do not depend on any assumptions about the distribution of the keys. For each pair k and l of distinct keys, define the indicator random variable 266 Chapter 11 Hash Tables Xkl D I fh.k/ D h.l/g. Since by the definition of a universal collection of hash functions, a single pair of keys collides with probability at most 1=m, we have Pr fh.k/ D h.l/g 􏳥 1=m. By Lemma 5.1, therefore, we have E ŒXkl 􏳩 􏳥 1=m. Next we define, for each key k, the random variable Yk that equals the number of keys other than k that hash to the same slot as k, so that X Yk D Thus we have 2X 3 EŒYk􏳩 D E4 Xkl5 l2T l2T l¤k Xkl : Xl¤k E ŒXkl 􏳩 l2T l¤k X1 􏳥m: l2T l¤k D (by linearity of expectation) The remainder of the proof depends on whether key k is in table T . Ifk62T,thennh.k/ DYk andjflWl2Tandl¤kgjDn.ThusEŒnh.k/􏳩D EŒYk􏳩 􏳥 n=m D ̨. If k 2 T , then because key k appears in list T Œh.k/􏳩 and the count Yk does not includekeyk,wehavenh.k/ DYk C1andjflWl2T andl¤kgjDn􏳣1. Thus E Œnh.k/􏳩 D E ŒYk 􏳩 C 1 􏳥 .n 􏳣 1/=m C 1 D 1 C ̨ 􏳣 1=m < 1 C ̨. The following corollary says universal hashing provides the desired payoff: it has now become impossible for an adversary to pick a sequence of operations that forces the worst-case running time. By cleverly randomizing the choice of hash function at run time, we guarantee that we can process every sequence of operations with a good average-case running time. Corollary 11.4 Using universal hashing and collision resolution by chaining in an initially empty table with m slots, it takes expected time ‚.n/ to handle any sequence of n INSERT, SEARCH, and DELETE operations containing O.m/ INSERT operations. Proof Since the number of insertions is O.m/, we have n D O.m/ and so ̨ D O.1/. The INSERT and DELETE operations take constant time and, by The- orem 11.3, the expected time for each SEARCH operation is O.1/. By linearity of 􏳮 􏳮 11.3 Hash functions 267 expectation, therefore, the expected time for the entire sequence of n operations is O.n/. Since each operation takes 􏳫.1/ time, the ‚.n/ bound follows. Designing a universal class of hash functions It is quite easy to design a universal class of hash functions, as a little number theory will help us prove. You may wish to consult Chapter 31 first if you are unfamiliar with number theory. We begin by choosing a prime number p large enough so that every possible keykisintherange0top􏳣1,inclusive.LetZp denotethesetf0;1;:::;p􏳣1g, andletZp􏳤 denotethesetf1;2;:::;p􏳣1g. Sincepisprime,wecansolveequa- tions modulo p with the methods given in Chapter 31. Because we assume that the size of the universe of keys is greater than the number of slots in the hash table, we have p > m.
We now define the hash function hab for any a 2 Zp􏳤 and any b 2 Zp using a linear transformation followed by reductions modulo p and then modulo m:
hab.k/ D ..ak C b/ mod p/ mod m : (11.3) For example, with p D 17 and m D 6, we have h3;4.8/ D 5. The family of all
such hash functions is
H D ̊h Wa2Z􏳤 andb2Z 􏳻 : (11.4)
pm ab p p
Each hash function hab maps Zp to Zm. This class of hash functions has the nice property that the size m of the output range is arbitrary—not necessarily prime—a feature which we shall use in Section 11.5. Since we have p 􏳣 1 choices for a and p choices for b, the collection Hpm contains p.p 􏳣 1/ hash functions.
Theorem 11.5
The class Hpm of hash functions defined by equations (11.3) and (11.4) is universal. Proof Consider two distinct keys k and l from Zp, so that k ¤ l. For a given
hash function hab we let
r D .akCb/modp;
s D .alCb/modp:
We first note that r ¤ s. Why? Observe that r􏳣s􏳳a.k􏳣l/ .modp/:
It follows that r ¤ s because p is prime and both a and .k 􏳣 l/ are nonzero modulo p, and so their product must also be nonzero modulo p by Theorem 31.6. Therefore, when computing any hab 2 Hpm, distinct inputs k and l map to distinct

268 Chapter 11 Hash Tables
values r and s modulo p; there are no collisions yet at the “mod p level.” Moreover, each of the possible p.p􏳣1/ choices for the pair .a; b/ with a ¤ 0 yields a different resulting pair .r; s/ with r ¤ s, since we can solve for a and b given r and s:
a D 􏳣.r􏳣s/..k􏳣l/􏳣1 modp/􏳵modp; b D .r􏳣ak/modp;
where ..k 􏳣 l/􏳣1 mod p/ denotes the unique multiplicative inverse, modulo p, of k 􏳣 l. Since there are only p.p 􏳣 1/ possible pairs .r;s/ with r ¤ s, there is a one-to-one correspondence between pairs .a;b/ with a ¤ 0 and pairs .r;s/ with r ¤ s. Thus, for any given pair of inputs k and l, if we pick .a;b/ uniformly at random from Zp􏳤 􏳨 Zp , the resulting pair .r; s/ is equally likely to be any pair of distinct values modulo p.
Therefore, the probability that distinct keys k and l collide is equal to the prob- ability that r 􏳳 s .mod m/ when r and s are randomly chosen as distinct values modulo p. For a given value of r, of the p 􏳣 1 possible remaining values for s, the numberofvaluesssuchthats¤rands􏳳r .modm/isatmost
dp=me 􏳣 1 􏳥 ..p C m 􏳣 1/=m/ 􏳣 1 (by inequality (3.6)) D .p􏳣1/=m:
The probability that s collides with r when reduced modulo m is at most ..p 􏳣 1/=m/=.p 􏳣 1/ D 1=m.
Therefore, for any pair of distinct values k; l 2 Zp , Prfhab.k/ D hab.l/g 􏳥 1=m ;
so that Hpm is indeed universal.
Exercises
11.3-1
Suppose we wish to search a linked list of length n, where each element contains a key k along with a hash value h.k/. Each key is a long character string. How might we take advantage of the hash values when searching the list for an element with a given key?
11.3-2
Suppose that we hash a string of r characters into m slots by treating it as a radix-128 number and then using the division method. We can easily represent the number m as a 32-bit computer word, but the string of r characters, treated as a radix-128 number, takes many words. How can we apply the division method to compute the hash value of the character string without using more than a constant number of words of storage outside the string itself?

11.4 Open addressing 269
11.3-3
Consider a version of the division method in which h.k/ D k mod m, where m D 2p 􏳣 1 and k is a character string interpreted in radix 2p . Show that if we can derive string x from string y by permuting its characters, then x and y hash to the same value. Give an example of an application in which this property would be undesirable in a hash function.
11.3-4
Consider a hash table of size m D 1000 and a corresponding hash function h.k/ D p
bm .kA mod 1/c for A D . 5 􏳣 1/=2. Compute the locations to which the keys 61, 62, 63, 64, and 65 are mapped.
11.3-5 ?
Define a family H of hash functions from a finite set U to a finite set B to be 􏳮-universal if for all pairs of distinct elements k and l in U ,
Prfh.k/ D h.l/g 􏳥 􏳮 ;
where the probability is over the choice of the hash function h drawn at random
from the family H. Show that an 􏳮-universal family of hash functions must have 􏳮􏳦1􏳣1:
jBj jUj
11.3-6 ?
Let U be the set of n-tuples of values drawn from Zp, and let B D Zp, where p is prime. Define the hash function hb W U ! B for b 2 Zp on an input n-tuple ha0;a1;:::;an􏳣1i from U as
!
n􏳣1 Xj
hb .ha0 ; a1 ; : : : ; an􏳣1 i/ D
and let H D fhb W b 2 Zpg. Argue that H is ..n 􏳣 1/=p/-universal according to
the definition of 􏳮-universal in Exercise 11.3-5. (Hint: See Exercise 31.4-4.)
11.4 Open addressing
In open addressing, all elements occupy the hash table itself. That is, each table entry contains either an element of the dynamic set or NIL. When searching for an element, we systematically examine table slots until either we find the desired element or we have ascertained that the element is not in the table. No lists and
jD0
aj b
mod p ;

270 Chapter 11 Hash Tables
no elements are stored outside the table, unlike in chaining. Thus, in open ad- dressing, the hash table can “fill up” so that no further insertions can be made; one consequence is that the load factor ̨ can never exceed 1.
Of course, we could store the linked lists for chaining inside the hash table, in the otherwise unused hash-table slots (see Exercise 11.2-4), but the advantage of open addressing is that it avoids pointers altogether. Instead of following pointers, we compute the sequence of slots to be examined. The extra memory freed by not storing pointers provides the hash table with a larger number of slots for the same amount of memory, potentially yielding fewer collisions and faster retrieval.
To perform insertion using open addressing, we successively examine, or probe, the hash table until we find an empty slot in which to put the key. Instead of being fixed in the order 0; 1; : : : ; m 􏳣 1 (which requires ‚.n/ search time), the sequence of positions probed depends upon the key being inserted. To determine which slots to probe, we extend the hash function to include the probe number (starting from 0) as a second input. Thus, the hash function becomes
hWU 􏳨f0;1;:::;m􏳣1g!f0;1;:::;m􏳣1g :
With open addressing, we require that for every key k, the probe sequence hh.k; 0/; h.k; 1/; : : : ; h.k; m 􏳣 1/i
be a permutation of h0; 1; : : : ; m 􏳣 1i, so that every hash-table position is eventually considered as a slot for a new key as the table fills up. In the following pseudocode, we assume that the elements in the hash table T are keys with no satellite infor- mation; the key k is identical to the element containing key k. Each slot contains either a key or NIL (if the slot is empty). The HASH-INSERT procedure takes as input a hash table T and a key k. It either returns the slot number where it stores key k or flags an error because the hash table is already full.
HASH-INSERT.T;k/ 1iD0
2 3 4 5 6 7 8 9
repeat
j D h.k;i/
if T Œj 􏳩 == NIL TŒj􏳩 D k
return j else i D i C 1
untili==m
error “hash table overflow”
The algorithm for searching for key k probes the same sequence of slots that the insertion algorithm examined when key k was inserted. Therefore, the search can

11.4 Open addressing 271
terminate (unsuccessfully) when it finds an empty slot, since k would have been inserted there and not later in its probe sequence. (This argument assumes that keys are not deleted from the hash table.) The procedure HASH-SEARCH takes as input a hash table T and a key k, returning j if it finds that slot j contains key k, or NIL if key k is not present in table T .
HASH-SEARCH.T; k/ 1iD0
2 3 4 5 6 7 8
repeat
j D h.k;i/ if T Œj 􏳩 == k
return j iDiC1
untilTŒj􏳩==NILori==m return N I L
Deletion from an open-address hash table is difficult. When we delete a key from slot i, we cannot simply mark that slot as empty by storing NIL in it. If we did, we might be unable to retrieve any key k during whose insertion we had probed slot i and found it occupied. We can solve this problem by marking the slot, storing in it the special value DELETED instead of NIL. We would then modify the procedure HASH-INSERT to treat such a slot as if it were empty so that we can insert a new key there. We do not need to modify HASH-SEARCH, since it will pass over DELETED values while searching. When we use the special value DELETED, however, search times no longer depend on the load factor ̨, and for this reason chaining is more commonly selected as a collision resolution technique when keys must be deleted.
In our analysis, we assume uniform hashing: the probe sequence of each key is equally likely to be any of the mŠ permutations of h0; 1; :::; m 􏳣 1i. Uni- form hashing generalizes the notion of simple uniform hashing defined earlier to a hash function that produces not just a single number, but a whole probe sequence. True uniform hashing is difficult to implement, however, and in practice suitable approximations (such as double hashing, defined below) are used.
We will examine three commonly used techniques to compute the probe se- quences required for open addressing: linear probing, quadratic probing, and dou- ble hashing. These techniques all guarantee that hh.k; 0/; h.k; 1/; : : : ; h.k; m 􏳣 1/i is a permutation of h0; 1; : : : ; m 􏳣 1i for each key k. None of these techniques ful- fills the assumption of uniform hashing, however, since none of them is capable of generating more than m2 different probe sequences (instead of the mŠ that uniform hashing requires). Double hashing has the greatest number of probe sequences and, as one might expect, seems to give the best results.

272 Chapter 11 Hash Tables
Linear probing
Givenanordinaryhashfunctionh0 WU !f0;1;:::;m􏳣1g,whichwerefertoas an auxiliary hash function, the method of linear probing uses the hash function
h.k; i/ D .h0.k/ C i/ mod m
for i D 0;1;:::;m 􏳣 1. Given key k, we first probe TŒh0.k/􏳩, i.e., the slot given by the auxiliary hash function. We next probe slot T Œh0.k/ C 1􏳩, and so on up to slot T Œm 􏳣 1􏳩. Then we wrap around to slots T Œ0􏳩; T Œ1􏳩; : : : until we finally probe slot T Œh0.k/ 􏳣 1􏳩. Because the initial probe determines the entire probe sequence, there are only m distinct probe sequences.
Linear probing is easy to implement, but it suffers from a problem known as primary clustering. Long runs of occupied slots build up, increasing the average search time. Clusters arise because an empty slot preceded by i full slots gets filled next with probability .i C 1/=m. Long runs of occupied slots tend to get longer, and the average search time increases.
Quadratic probing
Quadratic probing uses a hash function of the form
h.k; i/ D .h0.k/ C c1i C c2i2/ mod m ; (11.5)
where h0 is an auxiliary hash function, c1 and c2 are positive auxiliary constants, and i D 0; 1; : : : ; m 􏳣 1. The initial position probed is T Œh0.k/􏳩; later positions probed are offset by amounts that depend in a quadratic manner on the probe num- ber i. This method works much better than linear probing, but to make full use of the hash table, the values of c1, c2, and m are constrained. Problem 11-3 shows one way to select these parameters. Also, if two keys have the same initial probe position, then their probe sequences are the same, since h.k1;0/ D h.k2;0/ im- plies h.k1;i/ D h.k2;i/. This property leads to a milder form of clustering, called secondary clustering. As in linear probing, the initial probe determines the entire sequence, and so only m distinct probe sequences are used.
Double hashing
Double hashing offers one of the best methods available for open addressing be- cause the permutations produced have many of the characteristics of randomly chosen permutations. Double hashing uses a hash function of the form
h.k; i/ D .h1.k/ C ih2.k// mod m ;
where both h1 and h2 are auxiliary hash functions. The initial probe goes to posi- tion T Œh1.k/􏳩; successive probe positions are offset from previous positions by the

11.4 Open addressing 273
79
69
98
72
14
50
0
1
2
3
4
5
6
7
8
9
10
11
12
Insertion by double hashing. Here we have a hash table of size 13 with h1.k/ D kmod13andh2.k/D1C.kmod11/.Since14􏳳1 .mod13/and14􏳳3 .mod11/,weinsert the key 14 into empty slot 9, after examining slots 1 and 5 and finding them to be occupied.
amount h2.k/, modulo m. Thus, unlike the case of linear or quadratic probing, the probe sequence here depends in two ways upon the key k, since the initial probe position, the offset, or both, may vary. Figure 11.5 gives an example of insertion by double hashing.
The value h2.k/ must be relatively prime to the hash-table size m for the entire hash table to be searched. (See Exercise 11.4-4.) A convenient way to ensure this condition is to let m be a power of 2 and to design h2 so that it always produces an odd number. Another way is to let m be prime and to design h2 so that it always returns a positive integer less than m. For example, we could choose m prime and let
h1.k/ D kmodm;
h2.k/ D 1C.kmodm0/;
where m0 is chosen to be slightly less than m (say, m 􏳣 1). For example, if kD123456,mD701,andm0 D700,wehaveh1.k/D80andh2.k/D257,so that we first probe position 80, and then we examine every 257th slot (modulo m) until we find the key or have examined every slot.
When m is prime or a power of 2, double hashing improves over linear or qua- dratic probing in that ‚.m2/ probe sequences are used, rather than ‚.m/, since each possible .h1.k/;h2.k// pair yields a distinct probe sequence. As a result, for
Figure 11.5

274 Chapter 11 Hash Tables
such values of m, the performance of double hashing appears to be very close to the performance of the “ideal” scheme of uniform hashing.
Although values of m other than primes or powers of 2 could in principle be used with double hashing, in practice it becomes more difficult to efficiently gen- erate h2.k/ in a way that ensures that it is relatively prime to m, in part because the relative density 􏳭.m/=m of such numbers may be small (see equation (31.24)).
Analysis of open-address hashing
As in our analysis of chaining, we express our analysis of open addressing in terms of the load factor ̨ D n=m of the hash table. Of course, with open addressing, at most one element occupies each slot, and thus n 􏳥 m, which implies ̨ 􏳥 1.
We assume that we are using uniform hashing. In this idealized scheme, the probe sequence hh.k; 0/; h.k; 1/; : : : ; h.k; m 􏳣 1/i used to insert or search for each key k is equally likely to be any permutation of h0; 1; : : : ; m 􏳣 1i. Of course, a given key has a unique fixed probe sequence associated with it; what we mean here is that, considering the probability distribution on the space of keys and the operation of the hash function on the keys, each possible probe sequence is equally likely.
We now analyze the expected number of probes for hashing with open address- ing under the assumption of uniform hashing, beginning with an analysis of the number of probes made in an unsuccessful search.
Theorem 11.6
Given an open-address hash table with load factor ̨ D n=m < 1, the expected number of probes in an unsuccessful search is at most 1=.1􏳣 ̨/, assuming uniform hashing. Proof In an unsuccessful search, every probe but the last accesses an occupied slot that does not contain the desired key, and the last slot probed is empty. Let us define the random variable X to be the number of probes made in an unsuccessful search, and let us also define the event Ai, for i D 1;2;:::, to be the event that an ith probe occurs and it is to an occupied slot. Then the event fX 􏳦 ig is the intersectionofeventsA1\A2\􏳵􏳵􏳵\Ai􏳣1. WewillboundPrfX 􏳦igbybounding PrfA1 \A2 \􏳵􏳵􏳵\Ai􏳣1g.ByExerciseC.2-5, PrfA1 \A2 \􏳵􏳵􏳵\Ai􏳣1gDPrfA1g􏳵PrfA2 jA1g􏳵PrfA3 jA1 \A2g􏳵􏳵􏳵 PrfAi􏳣1 jA1 \A2 \􏳵􏳵􏳵\Ai􏳣2g : Since there are n elements and m slots, Pr fA1g D n=m. For j > 1, the probability that there is a j th probe and it is to an occupied slot, given that the first j 􏳣 1 probes were to occupied slots, is .n 􏳣 j C 1/=.m 􏳣 j C 1/. This probability follows

11.4 Open addressing 275
because we would be finding one of the remaining .n 􏳣 .j 􏳣 1// elements in one of the .m 􏳣 .j 􏳣 1// unexamined slots, and by the assumption of uniform hashing, the probability is the ratio of these quantities. Observing that n < m implies that .n􏳣j/=.m􏳣j/􏳥n=mforallj suchthat0􏳥j 2lgngDO.1=n2/.Lettherandom variable X D max1􏳥i􏳥n Xi denote the maximum number of probes required by any of the n insertions.
c. Show that PrfX > 2lgng D O.1=n/.
d. Show that the expected length E ŒX􏳩 of the longest probe sequence is O.lg n/.
2n 4n

Problems for Chapter 11 283
11-2 Slot-size bound for chaining
Suppose that we have a hash table with n slots, with collisions resolved by chain- ing, and suppose that n keys are inserted into the table. Each key is equally likely to be hashed to each slot. Let M be the maximum number of keys in any slot after all the keys have been inserted. Your mission is to prove an O.lg n= lg lg n/ upper bound on E ŒM 􏳩, the expected value of M .
a. Argue that the probability Qk that exactly k keys hash to a particular slot is given by
􏳧􏳹k􏳧 􏳹n􏳣k ! QkD11􏳣1 n:
nnk
b. Let Pk be the probability that M D k, that is, the probability that the slot
containing the most keys contains k keys. Show that Pk 􏳥 nQk .
c. Use Stirling’s approximation, equation (3.18), to show that Qk < ek=kk. d. Show that there exists a constant c > 1 such that Qk0 < 1=n3 for k0 D clgn=lglgn.ConcludethatPk <1=n2 fork􏳦k0 Dclgn=lglgn. e. Argue that EŒM􏳩􏳥Pr M>lglgn 􏳵nCPr M􏳥lglgn 􏳵lglgn: Conclude that E ŒM 􏳩 D O.lg n= lg lg n/.
11-3 Quadratic probing
Suppose that we are given a key k to search for in a hash table with positions 0;1;:::;m􏳣1, and suppose that we have a hash function h mapping the key space into the set f0; 1; : : : ; m 􏳣 1g. The search scheme is as follows:
1. Compute the value j D h.k/, and set i D 0.
2. Probe in position j for the desired key k. If you find it, or if this position is
empty, terminate the search.
3. Set i D i C 1. If i now equals m, the table is full, so terminate the search.
Otherwise, set j D .i C j/ mod m, and return to step 2.
Assume that m is a power of 2.
a. Showthatthisschemeisaninstanceofthegeneral“quadraticprobing”scheme by exhibiting the appropriate constants c1 and c2 for equation (11.5).
􏳴 clgn􏳯 􏳴 clgn􏳯 clgn
b. Prove that this algorithm examines every table position in the worst case.

284 Chapter 11 Hash Tables
11-4 Hashing and authentication
Let H be a class of hash functions in which each hash function h 2 H maps the universe U of keys to f0; 1; : : : ; m 􏳣 1g. We say that H is k-universal if, for every fixed sequence of k distinct keys hx.1/; x.2/; : : : ; x.k/i and for any h chosen at random from H, the sequence hh.x.1//;h.x.2//;:::;h.x.k//i is equally likely to be anyofthemk sequencesoflengthkwithelementsdrawnfromf0;1;:::;m􏳣1g.
a. Show that if the family H of hash functions is 2-universal, then it is universal.
b. Suppose that the universe U is the set of n-tuples of values drawn from Zp D f0;1;:::;p􏳣1g, where p is prime. Consider an element x D hx0;x1;:::;xn􏳣1i 2 U. For any n-tuple a D ha0; a1; :::; an􏳣1i 2 U, de- fine the hash function ha by
!
b 2 Zp, define
n􏳣1 0X
hab.x/D
n􏳣1 X
ha.x/ D
Let H D fhag. Show that H is universal, but not 2-universal. (Hint: Find a key
for which all hash functions in H produce the same value.)
c. Suppose that we modify H slightly from part (b): for any a 2 U and for any
jD0
aj xj
mod p :
!
ajxj Cb modp
and H0 D fh0abg. Argue that H0 is 2-universal. (Hint: Consider fixed n-tuples x2Uandy2U,withxi ¤yi forsomei. Whathappenstoh0ab.x/ and h0ab.y/ as ai and b range over Zp?)
d. Suppose that Alice and Bob secretly agree on a hash function h from a 2-universal family H of hash functions. Each h 2 H maps from a universe of keys U to Zp , where p is prime. Later, Alice sends a message m to Bob over the Internet, where m 2 U . She authenticates this message to Bob by also sending an authentication tag t D h.m/, and Bob checks that the pair .m;t/ he receives indeed satisfies t D h.m/. Suppose that an adversary intercepts .m;t/ en route and tries to fool Bob by replacing the pair .m;t/ with a different pair .m0;t0/. Argue that the probability that the adversary succeeds in fooling Bob into ac- cepting .m0;t0/ is at most 1=p, no matter how much computing power the ad- versary has, and even if the adversary knows the family H of hash functions used.
jD0

Notes for Chapter 11 285
Chapter notes
Knuth [211] and Gonnet [145] are excellent references for the analysis of hash- ing algorithms. Knuth credits H. P. Luhn (1953) for inventing hash tables, along with the chaining method for resolving collisions. At about the same time, G. M. Amdahl originated the idea of open addressing.
Carter and Wegman introduced the notion of universal classes of hash functions in 1979 [58].
Fredman, Komlo ́s, and Szemere ́di [112] developed the perfect hashing scheme for static sets presented in Section 11.5. An extension of their method to dynamic sets, handling insertions and deletions in amortized expected time O.1/, has been given by Dietzfelbinger et al. [86].

12 Binary Search Trees
The search tree data structure supports many dynamic-set operations, including SEARCH, MINIMUM, MAXIMUM, PREDECESSOR, SUCCESSOR, INSERT, and DELETE. Thus, we can use a search tree both as a dictionary and as a priority queue.
Basic operations on a binary search tree take time proportional to the height of the tree. For a complete binary tree with n nodes, such operations run in ‚.lg n/ worst-case time. If the tree is a linear chain of n nodes, however, the same oper- ations take ‚.n/ worst-case time. We shall see in Section 12.4 that the expected height of a randomly built binary search tree is O.lg n/, so that basic dynamic-set operations on such a tree take ‚.lg n/ time on average.
In practice, we can’t always guarantee that binary search trees are built ran- domly, but we can design variations of binary search trees with good guaranteed worst-case performance on basic operations. Chapter 13 presents one such vari- ation, red-black trees, which have height O.lg n/. Chapter 18 introduces B-trees, which are particularly good for maintaining databases on secondary (disk) storage.
After presenting the basic properties of binary search trees, the following sec- tions show how to walk a binary search tree to print its values in sorted order, how to search for a value in a binary search tree, how to find the minimum or maximum element, how to find the predecessor or successor of an element, and how to insert into or delete from a binary search tree. The basic mathematical properties of trees appear in Appendix B.
12.1 What is a binary search tree?
A binary search tree is organized, as the name suggests, in a binary tree, as shown in Figure 12.1. We can represent such a tree by a linked data structure in which each node is an object. In addition to a key and satellite data, each node contains attributes left, right, and p that point to the nodes corresponding to its left child,

12.1 What is a binary search tree? 287
62 575 2587
68
Figure 12.1 Binary search trees. For any node x, the keys in the left subtree of x are at most x:key, and the keys in the right subtree of x are at least x:key. Different binary search trees can represent the same set of values. The worst-case running time for most search-tree operations is proportional to the height of the tree. (a) A binary search tree on 6 nodes with height 2. (b) A less efficient binary search tree with height 4 that contains the same keys.
its right child, and its parent, respectively. If a child or the parent is missing, the appropriate attribute contains the value NIL. The root node is the only node in the tree whose parent is NIL.
The keys in a binary search tree are always stored in such a way as to satisfy the binary-search-tree property:
Let x be a node in a binary search tree. If y is a node in the left subtree of x, then y:key 􏳥 x:key. If y is a node in the right subtree of x, then y:key 􏳦 x:key.
Thus, in Figure 12.1(a), the key of the root is 6, the keys 2, 5, and 5 in its left subtree are no larger than 6, and the keys 7 and 8 in its right subtree are no smaller than 6. The same property holds for every node in the tree. For example, the key 5 in the root’s left child is no smaller than the key 2 in that node’s left subtree and no larger than the key 5 in the right subtree.
The binary-search-tree property allows us to print out all the keys in a binary search tree in sorted order by a simple recursive algorithm, called an inorder tree walk. This algorithm is so named because it prints the key of the root of a subtree between printing the values in its left subtree and printing those in its right subtree. (Similarly, a preorder tree walk prints the root before the values in either subtree, and a postorder tree walk prints the root after the values in its subtrees.) To use the following procedure to print all the elements in a binary search tree T , we call INORDER-TREE-WALK.T:root/.
5 (a) (b)

288 Chapter 12 Binary Search Trees
INORDER-TREE-WALK.x/
1 ifx¤NIL
2 INORDER-TREE-WALK.x:left/ 3 print x:key
4 INORDER-TREE-WALK.x:right/
As an example, the inorder tree walk prints the keys in each of the two binary search trees from Figure 12.1 in the order 2; 5; 5; 6; 7; 8. The correctness of the algorithm follows by induction directly from the binary-search-tree property.
It takes ‚.n/ time to walk an n-node binary search tree, since after the ini- tial call, the procedure calls itself recursively exactly twice for each node in the tree—once for its left child and once for its right child. The following theorem gives a formal proof that it takes linear time to perform an inorder tree walk.
Theorem 12.1
If x is the root of an n-node subtree, then the call INORDER-TREE-WALK.x/ takes ‚.n/ time.
Proof Let T.n/ denote the time taken by INORDER-TREE-WALK when it is called on the root of an n-node subtree. Since INORDER-TREE-WALK visits all n nodes of the subtree, we have T .n/ D 􏳫.n/. It remains to show that T .n/ D O.n/.
Since INORDER-TREE-WALK takes a small, constant amount of time on an empty subtree (for the test x ¤ NIL), we have T.0/ D c for some constant c > 0.
For n > 0, suppose that INORDER-TREE-WALK is called on a node x whose left subtree has k nodes and whose right subtree has n 􏳣 k 􏳣 1 nodes. The time to perform INORDER-TREE-WALK.x/ is bounded by T.n/ 􏳥 T.k/CT.n􏳣k􏳣1/Cd for some constant d > 0 that reflects an upper bound on the time to execute the body of INORDER-TREE-WALK.x/, exclusive of the time spent in recursive calls.
We use the substitution method to show that T.n/ D O.n/ by proving that T .n/ 􏳥 .c C d /n C c. For n D 0, we have .c C d / 􏳵 0 C c D c D T .0/. For n > 0, we have
T.n/ 􏳥 T.k/CT.n􏳣k􏳣1/Cd
D ..cCd/kCc/C..cCd/.n􏳣k􏳣1/Cc/Cd D .cCd/nCc􏳣.cCd/CcCd
D .cCd/nCc;
which completes the proof.

12.2 Querying a binary search tree 289
Exercises
12.1-1
For the set of f1; 4; 5; 10; 16; 17; 21g of keys, draw binary search trees of heights 2, 3, 4, 5, and 6.
12.1-2
What is the difference between the binary-search-tree property and the min-heap property (see page 153)? Can the min-heap property be used to print out the keys of an n-node tree in sorted order in O.n/ time? Show how, or explain why not.
12.1-3
Give a nonrecursive algorithm that performs an inorder tree walk. (Hint: An easy solution uses a stack as an auxiliary data structure. A more complicated, but ele- gant, solution uses no stack but assumes that we can test two pointers for equality.)
12.1-4
Give recursive algorithms that perform preorder and postorder tree walks in ‚.n/ time on a tree of n nodes.
12.1-5
Argue that since sorting n elements takes 􏳫.nlgn/ time in the worst case in the comparison model, any comparison-based algorithm for constructing a binary search tree from an arbitrary list of n elements takes 􏳫.n lg n/ time in the worst case.
12.2 Querying a binary search tree
We often need to search for a key stored in a binary search tree. Besides the SEARCH operation, binary search trees can support such queries as MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR. In this section, we shall examine these operations and show how to support each one in time O.h/ on any binary search tree of height h.
Searching
We use the following procedure to search for a node with a given key in a binary search tree. Given a pointer to the root of the tree and a key k, TREE-SEARCH returns a pointer to a node with key k if one exists; otherwise, it returns NIL.

290 Chapter 12 Binary Search Trees
15
6 18
3 7 17 20
24 13 9
Figure 12.2 Queries on a binary search tree. To search for the key 13 in the tree, we follow the path 15 ! 6 ! 7 ! 13 from the root. The minimum key in the tree is 2, which is found by following left pointers from the root. The maximum key 20 is found by following right pointers from the root. The successor of the node with key 15 is the node with key 17, since it is the minimum key in the right subtree of 15. The node with key 13 has no right subtree, and thus its successor is its lowest ancestor whose left child is also an ancestor. In this case, the node with key 15 is its successor.
TREE-SEARCH.x; k/
1 2 3 4 5
ifx==NILork==x:key return x
ifk 0, all but O.1=nk/ of the nŠ input permutations yield an O.n lg n/ running time.
12-1 Binary search trees with equal keys
Equal keys pose a problem for the implementation of binary search trees.
a. What is the asymptotic performance of TREE-INSERT when used to insert n items with identical keys into an initially empty binary search tree?
We propose to improve TREE-INSERT by testing before line 5 to determine whether ́:key D x:key and by testing before line 11 to determine whether ́:key D y:key.
Problems for Chapter 12 303

304 Chapter 12 Binary Search Trees
If equality holds, we implement one of the following strategies. For each strategy, find the asymptotic performance of inserting n items with identical keys into an initially empty binary search tree. (The strategies are described for line 5, in which we compare the keys of ́ and x. Substitute y for x to arrive at the strategies for line 11.)
b. Keep a boolean flag x:b at node x, and set x to either x:left or x:right based on the value of x:b, which alternates between FALSE and TRUE each time we visit x while inserting a node with the same key as x.
c. Keep a list of nodes with equal keys at x, and insert ́ into the list.
d. Randomly set x to either x:left or x:right. (Give the worst-case performance
and informally derive the expected running time.)
12-2 Radix trees
Given two strings a D a0a1 :::ap and b D b0b1 :::bq, where each ai and each bj is in some ordered set of characters, we say that string a is lexicographically less than string b if either
1. there exists an integer j, where 0 􏳥 j 􏳥 min.p;q/, such that ai D bi for all i D0;1;:::;j 􏳣1andaj 1, the tree has at least one red node.
13.3-6
Suggest how to implement RB-INSERT efficiently if the representation for red- black trees includes no storage for parent pointers.

13.4 Deletion 323
13.4 Deletion
Like the other basic operations on an n-node red-black tree, deletion of a node takes time O.lg n/. Deleting a node from a red-black tree is a bit more complicated than inserting a node.
The procedure for deleting a node from a red-black tree is based on the TREE- DELETE procedure (Section 12.3). First, we need to customize the TRANSPLANT subroutine that TREE-DELETE calls so that it applies to a red-black tree:
RB-TRANSPLANT.T; u; 􏳪/
1 2 3 4 5 6
if u:p == T:nil T:root D 􏳪
elseif u == u:p:left u:p:left D 􏳪
else u:p:right D 􏳪 􏳪:p D u:p
The procedure RB-TRANSPLANT differs from TRANSPLANT in two ways. First, line 1 references the sentinel T:nil instead of NIL. Second, the assignment to 􏳪:p in line 6 occurs unconditionally: we can assign to 􏳪:p even if 􏳪 points to the sentinel. In fact, we shall exploit the ability to assign to 􏳪:p when 􏳪 D T:nil.
The procedure RB-DELETE is like the TREE-DELETE procedure, but with ad- ditional lines of pseudocode. Some of the additional lines keep track of a node y that might cause violations of the red-black properties. When we want to delete node ́ and ́ has fewer than two children, then ́ is removed from the tree, and we want y to be ́. When ́ has two children, then y should be ́’s successor, and y moves into ́’s position in the tree. We also remember y’s color before it is re- moved from or moved within the tree, and we keep track of the node x that moves into y’s original position in the tree, because node x might also cause violations of the red-black properties. After deleting node ́, RB-DELETE calls an auxiliary procedure RB-DELETE-FIXUP, which changes colors and performs rotations to restore the red-black properties.

324 Chapter 13 Red-Black Trees
RB-DELETE.T; ́/
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
yD ́
y-original-color D y:color if ́:left == T:nil
x D ́:right
RB-TRANSPLANT.T; ́; ́:right/ elseif ́:right == T:nil
x D ́:left
RB-TRANSPLANT.T; ́; ́:left/ else y D TREE-MINIMUM. ́:right/
y-original-color D y:color x D y:right
if y:p == ́
x:p D y
else RB-TRANSPLANT.T; y; y:right/
y:right D ́:right
y:right:p D y RB-TRANSPLANT.T; ́; y/ y:left D ́:left
y:left:p D y
y:color D ́:color
if y-original-color == BLACK RB-DELETE-FIXUP .T; x/
Although RB-DELETE contains almost twice as many lines of pseudocode as TREE-DELETE, the two procedures have the same basic structure. You can find each line of TREE-DELETE within RB-DELETE (with the changes of replacing NIL by T:nil and replacing calls to TRANSPLANT by calls to RB-TRANSPLANT), executed under the same conditions.
Here are the other differences between the two procedures:
We maintain node y as the node either removed from the tree or moved within the tree. Line 1 sets y to point to node ́ when ́ has fewer than two children and is therefore removed. When ́ has two children, line 9 sets y to point to ́’s successor, just as in TREE-DELETE, and y will move into ́’s position in the tree.
Because node y’s color might change, the variable y-original-color stores y’s color before any changes occur. Lines 2 and 10 set this variable immediately after assignments to y. When ́ has two children, then y ¤ ́ and node y moves into node ́’s original position in the red-black tree; line 20 gives y the same color as ́. We need to save y’s original color in order to test it at the
􏳮
􏳮

13.4 Deletion 325
end of RB-DELETE; if it was black, then removing or moving y could cause violations of the red-black properties.
As discussed, we keep track of the node x that moves into node y’s original position. The assignments in lines 4, 7, and 11 set x to point to either y’s only child or, if y has no children, the sentinel T:nil. (Recall from Section 12.3 that y has no left child.)
Since node x moves into node y’s original position, the attribute x:p is always set to point to the original position in the tree of y’s parent, even if x is, in fact, the sentinel T:nil. Unless ́ is y’s original parent (which occurs only when ́ has two children and its successor y is ́’s right child), the assignment to x:p takes place in line 6 of RB-TRANSPLANT. (Observe that when RB-TRANSPLANT is called in lines 5, 8, or 14, the second parameter passed is the same as x.)
When y’s original parent is ́, however, we do not want x:p to point to y’s orig- inal parent, since we are removing that node from the tree. Because node y will move up to take ́’s position in the tree, setting x:p to y in line 13 causes x:p to point to the original position of y’s parent, even if x D T:nil.
Finally, if node y was black, we might have introduced one or more violations of the red-black properties, and so we call RB-DELETE-FIXUP in line 22 to restore the red-black properties. If y was red, the red-black properties still hold when y is removed or moved, for the following reasons:
1. No black-heights in the tree have changed.
2. No red nodes have been made adjacent. Because y takes ́’s place in the tree, along with ́’s color, we cannot have two adjacent red nodes at y’s new position in the tree. In addition, if y was not ́’s right child, then y’s original right child x replaces y in the tree. If y is red, then x must be black, and so replacing y by x cannot cause two red nodes to become adjacent.
3. Since y could not have been the root if it was red, the root remains black.
If node y was black, three problems may arise, which the call of RB-DELETE- FIXUP will remedy. First, if y had been the root and a red child of y becomes the new root, we have violated property 2. Second, if both x and x:p are red, then we have violated property 4. Third, moving y within the tree causes any simple path that previously contained y to have one fewer black node. Thus, property 5 is now violated by any ancestor of y in the tree. We can correct the violation of property 5 by saying that node x, now occupying y’s original position, has an “extra” black. That is, if we add 1 to the count of black nodes on any simple path that contains x, then under this interpretation, property 5 holds. When we remove or move the black node y, we “push” its blackness onto node x. The problem is that now node x is neither red nor black, thereby violating property 1. Instead,
􏳮
􏳮
􏳮

326 Chapter 13 Red-Black Trees
node x is either “doubly black” or “red-and-black,” and it contributes either 2 or 1, respectively, to the count of black nodes on simple paths containing x. The color attribute of x will still be either RED (if x is red-and-black) or BLACK (if x is doubly black). In other words, the extra black on a node is reflected in x’s pointing to the node rather than in the color attribute.
We can now see the procedure RB-DELETE-FIXUP and examine how it restores the red-black properties to the search tree.
RB-DELETE-FIXUP .T; x/
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
while x ¤ T:root and x:color == BLACK if x == x:p:left
w D x:p:right
if w:color == RED
w:color D BLACK x:p:color D RED LEFT-ROTATE.T;x:p/ w D x:p:right
if w:left:color == BLACK and w:right:color == BLACK w:color D RED
x D x:p
else if w:right:color == BLACK
w:left:color D BLACK w:color D RED RIGHT-ROTATE.T;w/ w D x:p:right
w:color D x:p:color x:p:color D BLACK w:right:color D BLACK LEFT-ROTATE.T;x:p/ xDT:root
else (same as then clause with “right” and “left” exchanged) x:color D BLACK
//case1 //case1 //case1 //case1
//case2 //case2
//case3 //case3 //case3 //case3 //case4 //case4 //case4 //case4 //case4
The procedure RB-DELETE-FIXUP restores properties 1, 2, and 4. Exercises 13.4-1 and 13.4-2 ask you to show that the procedure restores properties 2 and 4, and so in the remainder of this section, we shall focus on property 1. The goal of the while loop in lines 1–22 is to move the extra black up the tree until
1. x points to a red-and-black node, in which case we color x (singly) black in line 23;
2. xpointstotheroot,inwhichcasewesimply“remove”theextrablack;or 3. having performed suitable rotations and recolorings, we exit the loop.

13.4 Deletion 327
Within the while loop, x always points to a nonroot doubly black node. We determine in line 2 whether x is a left child or a right child of its parent x:p. (We have given the code for the situation in which x is a left child; the situation in which x is a right child—line 22—is symmetric.) We maintain a pointer w to the sibling of x. Since node x is doubly black, node w cannot be T:nil, because otherwise, the number of blacks on the simple path from x:p to the (singly black) leaf w would be smaller than the number on the simple path from x:p to x.
The four cases2 in the code appear in Figure 13.7. Before examining each case in detail, let’s look more generally at how we can verify that the transformation in each of the cases preserves property 5. The key idea is that in each case, the transformation applied preserves the number of black nodes (including x’s extra black) from (and including) the root of the subtree shown to each of the subtrees ̨; ˇ; : : : ; 􏳰. Thus, if property 5 holds prior to the transformation, it continues to hold afterward. For example, in Figure 13.7(a), which illustrates case 1, the num- ber of black nodes from the root to either subtree ̨ or ˇ is 3, both before and after the transformation. (Again, remember that node x adds an extra black.) Similarly, the number of black nodes from the root to any of 􏳢, ı, “, and 􏳰 is 2, both be- fore and after the transformation. In Figure 13.7(b), the counting must involve the value c of the color attribute of the root of the subtree shown, which can be either RED or BLACK. If we define count.RED/ D 0 and count.BLACK/ D 1, then the number of black nodes from the root to ̨ is 2 C count.c/, both before and after the transformation. In this case, after the transformation, the new node x has color attribute c, but this node is really either red-and-black (if c D RED) or doubly black (if c D BLACK). You can verify the other cases similarly (see Exercise 13.4-5).
Case 1: x’s sibling w is red
Case 1 (lines 5–8 of RB-DELETE-FIXUP and Figure 13.7(a)) occurs when node w, the sibling of node x, is red. Since w must have black children, we can switch the colors of w and x:p and then perform a left-rotation on x:p without violating any of the red-black properties. The new sibling of x, which is one of w’s children prior to the rotation, is now black, and thus we have converted case 1 into case 2, 3, or 4.
Cases 2, 3, and 4 occur when node w is black; they are distinguished by the colors of w’s children.
2As in RB-INSERT-FIXUP, the cases in RB-DELETE-FIXUP are not mutually exclusive.

328 Chapter 13 Red-Black Trees
Case 2: x’s sibling w is black, and both of w’s children are black
In case 2 (lines 10–11 of RB-DELETE-FIXUP and Figure 13.7(b)), both of w’s children are black. Since w is also black, we take one black off both x and w, leaving x with only one black and leaving w red. To compensate for removing one black from x and w, we would like to add an extra black to x:p, which was originally either red or black. We do so by repeating the while loop with x:p as the new node x. Observe that if we enter case 2 through case 1, the new node x is red-and-black, since the original x:p was red. Hence, the value c of the color attribute of the new node x is RED, and the loop terminates when it tests the loop condition. We then color the new node x (singly) black in line 23.
Case 3: x’s sibling w is black, w’s left child is red, and w’s right child is black Case 3 (lines 13–16 and Figure 13.7(c)) occurs when w is black, its left child is red, and its right child is black. We can switch the colors of w and its left child w:left and then perform a right rotation on w without violating any of the red-black properties. The new sibling w of x is now a black node with a red right child, and thus we have transformed case 3 into case 4.
Case 4: x’s sibling w is black, and w’s right child is red
Case 4 (lines 17–21 and Figure 13.7(d)) occurs when node x’s sibling w is black and w’s right child is red. By making some color changes and performing a left ro- tation on x:p, we can remove the extra black on x, making it singly black, without violating any of the red-black properties. Setting x to be the root causes the while loop to terminate when it tests the loop condition.
Analysis
What is the running time of RB-DELETE? Since the height of a red-black tree of n nodes is O.lg n/, the total cost of the procedure without the call to RB-DELETE- FIXUP takes O.lg n/ time. Within RB-DELETE-FIXUP, each of cases 1, 3, and 4 lead to termination after performing a constant number of color changes and at most three rotations. Case 2 is the only case in which the while loop can be re- peated, and then the pointer x moves up the tree at most O.lg n/ times, performing no rotations. Thus, the procedure RB-DELETE-FIXUP takes O.lg n/ time and per- forms at most three rotations, and the overall time for RB-DELETE is therefore also O.lg n/.

13.4 Deletion
329
Case 1
BD (a)xADw BE
αβCE xAnewwCεζ γδεζ αβγδ
Case 2
B c
(b)xADw AD
αβCEαβCE γδεζ γδεζ
Case 3
Bc Bc
(c) xA Dw xA Cneww
αβCE αβγD γδεζ δE
newx B c
εζ
Case 4
Bc Dc (d)xADw BE
αβCc′E ACc′εζ
γ δε ζ α βγ δ newxDT:root
Figure 13.7 The cases in the while loop of the procedure RB-DELETE-FIXUP. Darkened nodes have color attributes BLACK, heavily shaded nodes have color attributes RED, and lightly shaded nodes have color attributes represented by c and c0, which may be either RED or BLACK. The letters ̨; ˇ; : : : ; 􏳰 represent arbitrary subtrees. Each case transforms the configuration on the left into the configuration on the right by changing some colors and/or performing a rotation. Any node pointed to by x has an extra black and is either doubly black or red-and-black. Only case 2 causes the loop to repeat. (a) Case 1 is transformed to case 2, 3, or 4 by exchanging the colors of nodes B and D and performing a left rotation. (b) In case 2, the extra black represented by the pointer x moves up the tree by coloring node D red and setting x to point to node B. If we enter case 2 through case 1, the while loop terminates because the new node x is red-and-black, and therefore the value c of its color attribute is RED. (c) Case 3 is transformed to case 4 by exchanging the colors of nodes C and D and performing a right rotation. (d) Case 4 removes the extra black represented by x by changing some colors and performing a left rotation (without violating the red-black properties), and then the loop terminates.

330 Chapter 13 Red-Black Trees
Exercises
13.4-1
Argue that after executing RB-DELETE-FIXUP, the root of the tree must be black.
13.4-2
Argue that if in RB-DELETE both x and x:p are red, then property 4 is restored by the call to RB-DELETE-FIXUP .T; x/.
13.4-3
In Exercise 13.3-2, you found the red-black tree that results from successively inserting the keys 41; 38; 31; 12; 19; 8 into an initially empty tree. Now show the red-black trees that result from the successive deletion of the keys in the order 8; 12; 19; 31; 38; 41.
13.4-4
In which lines of the code for RB-DELETE-FIXUP might we examine or modify the sentinel T:nil?
13.4-5
In each of the cases of Figure 13.7, give the count of black nodes from the root of the subtree shown to each of the subtrees ̨;ˇ;:::;􏳰, and verify that each count remains the same after the transformation. When a node has a color attribute c or c0, use the notation count.c/ or count.c0/ symbolically in your count.
13.4-6
Professors Skelton and Baron are concerned that at the start of case 1 of RB- DELETE-FIXUP, the node x:p might not be black. If the professors are correct, then lines 5–6 are wrong. Show that x:p must be black at the start of case 1, so that the professors have nothing to worry about.
13.4-7
Suppose that a node x is inserted into a red-black tree with RB-INSERT and then is immediately deleted with RB-DELETE. Is the resulting red-black tree the same as the initial red-black tree? Justify your answer.

Problems
Problems for Chapter 13 331
13-1 Persistent dynamic sets
During the course of an algorithm, we sometimes find that we need to maintain past versions of a dynamic set as it is updated. We call such a set persistent. One way to implement a persistent set is to copy the entire set whenever it is modified, but this approach can slow down a program and also consume much space. Sometimes, we can do much better.
Consider a persistent set S with the operations INSERT, DELETE, and SEARCH, which we implement using binary search trees as shown in Figure 13.8(a). We maintain a separate root for every version of the set. In order to insert the key 5 into the set, we create a new node with key 5. This node becomes the left child of a new node with key 7, since we cannot modify the existing node with key 7. Similarly, the new node with key 7 becomes the left child of a new node with key 8 whose right child is the existing node with key 10. The new node with key 8 becomes, in turn, the right child of a new root r0 with key 4 whose left child is the existing node with key 3. We thus copy only part of the tree and share some of the nodes with the original tree, as shown in Figure 13.8(b).
Assume that each tree node has the attributes key, left, and right but no parent. (See also Exercise 13.3-6.)
4 r r 4 4 r′
38388
2 7102 7710
5 (a) (b)
Figure 13.8 (a) A binary search tree with keys 2; 3; 4; 7; 8; 10. (b) The persistent binary search tree that results from the insertion of key 5. The most recent version of the set consists of the nodes reachable from the root r0, and the previous version consists of the nodes reachable from r. Heavily shaded nodes are added when key 5 is inserted.

332 Chapter 13 Red-Black Trees
a. For a general persistent binary search tree, identify the nodes that we need to change to insert a key k or delete a node y.
b. Write a procedure PERSISTENT-TREE-INSERT that, given a persistent tree T and a key k to insert, returns a new persistent tree T 0 that is the result of insert- ing k into T.
c. If the height of the persistent binary search tree T is h, what are the time and space requirements of your implementation of PERSISTENT-TREE-INSERT? (The space requirement is proportional to the number of new nodes allocated.)
d. Suppose that we had included the parent attribute in each node. In this case, PERSISTENT-TREE-INSERT would need to perform additional copying. Prove that PERSISTENT-TREE-INSERT would then require 􏳫.n/ time and space, where n is the number of nodes in the tree.
e. Show how to use red-black trees to guarantee that the worst-case running time and space are O.lg n/ per insertion or deletion.
13-2 Join operation on red-black trees
The join operation takes two dynamic sets S1 and S2 and an element x such that for any x1 2 S1 and x2 2 S2, we have x1:key 􏳥 x:key 􏳥 x2:key. It returns a set S D S1 [ fxg [ S2. In this problem, we investigate how to implement the join operation on red-black trees.
a. Given a red-black tree T , let us store its black-height as the new attribute T: bh. Argue that RB-INSERT and RB-DELETE can maintain the bh attribute with- out requiring extra storage in the nodes of the tree and without increasing the asymptotic running times. Show that while descending through T , we can de- termine the black-height of each node we visit in O.1/ time per node visited.
We wish to implement the operation RB-JOIN.T1; x; T2/, which destroys T1 and T2 and returns a red-black tree T D T1 [fxg[T2. Let n be the total number of nodes in T1 and T2.
b. Assume that T1:bh 􏳦 T2:bh. Describe an O.lg n/-time algorithm that finds a black node y in T1 with the largest key from among those nodes whose black- height is T2:bh.
c. Let Ty be the subtree rooted at y. Describe how Ty [ fxg [ T2 can replace Ty in O.1/ time without destroying the binary-search-tree property.
d. What color should we make x so that red-black properties 1, 3, and 5 are main- tained? Describe how to enforce properties 2 and 4 in O.lg n/ time.

Problems for Chapter 13 333
e. Argue that no generality is lost by making the assumption in part (b). Describe the symmetric situation that arises when T1:bh 􏳥 T2:bh.
f. Argue that the running time of RB-JOIN is O.lg n/.
13-3 AVL trees
An AVL tree is a binary search tree that is height balanced: for each node x, the heights of the left and right subtrees of x differ by at most 1. To implement an AVL tree, we maintain an extra attribute in each node: x:h is the height of node x. As for any other binary search tree T , we assume that T: root points to the root node.
a. Prove that an AVL tree with n nodes has height O.lgn/. (Hint: Prove that an AVL tree of height h has at least Fh nodes, where Fh is the hth Fibonacci number.)
b. To insert into an AVL tree, we first place a node into the appropriate place in bi- nary search tree order. Afterward, the tree might no longer be height balanced. Specifically, the heights of the left and right children of some node might differ by 2. Describe a procedure BALANCE.x/, which takes a subtree rooted at x whose left and right children are height balanced and have heights that differ by at most 2, i.e., jx:right:h 􏳣 x:left:hj 􏳥 2, and alters the subtree rooted at x to be height balanced. (Hint: Use rotations.)
c. Using part (b), describe a recursive procedure AVL-INSERT.x; ́/ that takes a node x within an AVL tree and a newly created node ́ (whose key has al- ready been filled in), and adds ́ to the subtree rooted at x, maintaining the property that x is the root of an AVL tree. As in TREE-INSERT from Sec- tion 12.3, assume that ́:key has already been filled in and that ́:left D NIL and ́:right D NIL; also assume that ́:h D 0. Thus, to insert the node ́ into the AVL tree T , we call AVL-INSERT.T:root; ́/.
d. Show that AVL-INSERT, run on an n-node AVL tree, takes O.lg n/ time and performs O.1/ rotations.
13-4 Treaps
If we insert a set of n items into a binary search tree, the resulting tree may be horribly unbalanced, leading to long search times. As we saw in Section 12.4, however, randomly built binary search trees tend to be balanced. Therefore, one strategy that, on average, builds a balanced tree for a fixed set of items would be to randomly permute the items and then insert them in that order into the tree.
What if we do not have all the items at once? If we receive the items one at a time, can we still randomly build a binary search tree out of them?

334 Chapter 13
Red-Black Trees
G: 4
H: 5
E: 23 K: 65
I: 73
A treap. Each node x is labeled with x:key: x:priority. For example, the root has key G and priority 4.
We will examine a data structure that answers this question in the affirmative. A treap is a binary search tree with a modified way of ordering the nodes. Figure 13.9 shows an example. As usual, each node x in the tree has a key value x:key. In addition, we assign x:priority, which is a random number chosen independently for each node. We assume that all priorities are distinct and also that all keys are distinct. The nodes of the treap are ordered so that the keys obey the binary-search- tree property and the priorities obey the min-heap order property:
If 􏳪 is a left child of u, then 􏳪:key < u:key. If 􏳪 is a right child of u, then 􏳪:key > u:key.
If 􏳪 is a child of u, then 􏳪:priority > u:priority.
(This combination of properties is why the tree is called a “treap”: it has features of both a binary search tree and a heap.)
It helps to think of treaps in the following way. Suppose that we insert nodes x1;x2;:::;xn, with associated keys, into a treap. Then the resulting treap is the tree that would have been formed if the nodes had been inserted into a normal binary search tree in the order given by their (randomly chosen) priorities, i.e., xi:priority x:priority, y:key < x:key, and, for every ́ such that y:key < ́:key < x:key, we have y:priority < ́:priority. g. Showthat h. Show that EŒC􏳩 D X 1 k􏳣1 .k 􏳣 i 􏳣 1/Š .k 􏳣 i C 1/Š PrfXikD1g D D1: .k 􏳣 i C 1/.k 􏳣 i/ jD1 j.j C1/ D1􏳣1: k i. Use a symmetry argument to show that E ŒD􏳩 D 1 􏳣 1 : node into a treap is less than 2. Chapter notes The idea of balancing a search tree is due to Adel’son-Vel’ski ̆ı and Landis [2], who introduced a class of balanced search trees called “AVL trees” in 1962, described in Problem 13-3. Another class of search trees, called “2-3 trees,” was introduced by J. E. Hopcroft (unpublished) in 1970. A 2-3 tree maintains balance by manipulating the degrees of nodes in the tree. Chapter 18 covers a generalization of 2-3 trees introduced by Bayer and McCreight [35], called “B-trees.” Red-black trees were invented by Bayer [34] under the name “symmetric binary B-trees.” Guibas and Sedgewick [155] studied their properties at length and in- troduced the red/black color convention. Andersson [15] gives a simpler-to-code n􏳣kC1 j. Conclude that the expected number of rotations performed when inserting a 338 Chapter 13 Red-Black Trees variant of red-black trees. Weiss [351] calls this variant AA-trees. An AA-tree is similar to a red-black tree except that left children may never be red. Treaps, the subject of Problem 13-4, were proposed by Seidel and Aragon [309]. They are the default implementation of a dictionary in LEDA [253], which is a well-implemented collection of data structures and algorithms. There are many other variations on balanced binary trees, including weight- balanced trees [264], k-neighbor trees [245], and scapegoat trees [127]. Perhaps the most intriguing are the “splay trees” introduced by Sleator and Tarjan [320], which are “self-adjusting.” (See Tarjan [330] for a good description of splay trees.) Splay trees maintain balance without any explicit balance condition such as color. Instead, “splay operations” (which involve rotations) are performed within the tree every time an access is made. The amortized cost (see Chapter 17) of each opera- tion on an n-node tree is O.lg n/. Skip lists [286] provide an alternative to balanced binary trees. A skip list is a linked list that is augmented with a number of additional pointers. Each dictionary operation runs in expected time O.lg n/ on a skip list of n items. 14 Augmenting Data Structures Some engineering situations require no more than a “textbook” data struc- ture—such as a doubly linked list, a hash table, or a binary search tree—but many others require a dash of creativity. Only in rare situations will you need to cre- ate an entirely new type of data structure, though. More often, it will suffice to augment a textbook data structure by storing additional information in it. You can then program new operations for the data structure to support the desired applica- tion. Augmenting a data structure is not always straightforward, however, since the added information must be updated and maintained by the ordinary operations on the data structure. This chapter discusses two data structures that we construct by augmenting red- black trees. Section 14.1 describes a data structure that supports general order- statistic operations on a dynamic set. We can then quickly find the ith smallest number in a set or the rank of a given element in the total ordering of the set. Section 14.2 abstracts the process of augmenting a data structure and provides a theorem that can simplify the process of augmenting red-black trees. Section 14.3 uses this theorem to help design a data structure for maintaining a dynamic set of intervals, such as time intervals. Given a query interval, we can then quickly find an interval in the set that overlaps it. 14.1 Dynamic order statistics Chapter 9 introduced the notion of an order statistic. Specifically, the ith order statistic of a set of n elements, where i 2 f1; 2; : : : ; ng, is simply the element in the set with the ith smallest key. We saw how to determine any order statistic in O.n/ time from an unordered set. In this section, we shall see how to modify red-black trees so that we can determine any order statistic for a dynamic set in O.lg n/ time. We shall also see how to compute the rank of an element—its position in the linear order of the set—in O.lg n/ time. 340 Chapter 14 Augmenting Data Structures 26 20 17 12 7 14 21 30 47 7451 41 10 422113 16 19 21 28 38 3 1 7 12 14 20 key 35 39 211111 size Figure 14.1 An order-statistic tree, which is an augmented red-black tree. Shaded nodes are red, and darkened nodes are black. In addition to its usual attributes, each node x has an attribute x:size, which is the number of nodes, other than the sentinel, in the subtree rooted at x. Figure 14.1 shows a data structure that can support fast order-statistic operations. An order-statistic tree T is simply a red-black tree with additional information stored in each node. Besides the usual red-black tree attributes x:key, x:color, x:p, x:left, and x:right in a node x, we have another attribute, x:size. This attribute contains the number of (internal) nodes in the subtree rooted at x (including x itself), that is, the size of the subtree. If we define the sentinel’s size to be 0—that is, we set T:nil:size to be 0—then we have the identity x:size D x:left:size C x:right:size C 1 : We do not require keys to be distinct in an order-statistic tree. (For example, the tree in Figure 14.1 has two keys with value 14 and two keys with value 21.) In the presence of equal keys, the above notion of rank is not well defined. We remove this ambiguity for an order-statistic tree by defining the rank of an element as the position at which it would be printed in an inorder walk of the tree. In Figure 14.1, for example, the key 14 stored in a black node has rank 5, and the key 14 stored in a red node has rank 6. Retrieving an element with a given rank Before we show how to maintain this size information during insertion and dele- tion, let us examine the implementation of two order-statistic queries that use this additional information. We begin with an operation that retrieves an element with a given rank. The procedure OS-SELECT.x;i/ returns a pointer to the node con- taining the ith smallest key in the subtree rooted at x. To find the node with the ith smallest key in an order-statistic tree T , we call OS-SELECT.T:root; i/. 14.1 Dynamic order statistics 341 OS-SELECT.x;i/ 1 2 3 4 5 6 rDx:left:sizeC1 ifi==r return x elseifi r, then the ith smallest element resides in x’s right subtree. Since the subtree rooted at x contains r elements that come before x’s right subtree in an inorder tree walk, the ith smallest element in the subtree rooted at x is the .i 􏳣 r/th smallest element in the subtree rooted at x:right. Line 6 determines this element recursively.
To see how OS-SELECT operates, consider a search for the 17th smallest ele- ment in the order-statistic tree of Figure 14.1. We begin with x as the root, whose key is 26, and with i D 17. Since the size of 26’s left subtree is 12, its rank is 13. Thus, we know that the node with rank 17 is the 17 􏳣 13 D 4th smallest element in 26’s right subtree. After the recursive call, x is the node with key 41, and i D 4. Since the size of 41’s left subtree is 5, its rank within its subtree is 6. Thus, we know that the node with rank 4 is the 4th smallest element in 41’s left subtree. Af- ter the recursive call, x is the node with key 30, and its rank within its subtree is 2. Thus, we recurse once again to find the 4􏳣2 D 2nd smallest element in the subtree rooted at the node with key 38. We now find that its left subtree has size 1, which means it is the second smallest element. Thus, the procedure returns a pointer to the node with key 38.
Because each recursive call goes down one level in the order-statistic tree, the total time for OS-SELECT is at worst proportional to the height of the tree. Since the tree is a red-black tree, its height is O.lg n/, where n is the number of nodes. Thus, the running time of OS-SELECT is O.lg n/ for a dynamic set of n elements.
Determining the rank of an element
Given a pointer to a node x in an order-statistic tree T , the procedure OS-RANK returns the position of x in the linear order determined by an inorder tree walk of T .

342 Chapter 14 Augmenting Data Structures
OS-RANK.T;x/
1 2 3 4 5 6 7
rDx:left:sizeC1 yDx whiley¤T:root
if y == y:p:right
r D r C y:p:left:size C 1
y D y:p return r
The procedure works as follows. We can think of node x’s rank as the number of nodes preceding x in an inorder tree walk, plus 1 for x itself. OS-RANK maintains the following loop invariant:
At the start of each iteration of the while loop of lines 3–6, r is the rank of x:key in the subtree rooted at node y.
We use this loop invariant to show that OS-RANK works correctly as follows:
Initialization: Priortothefirstiteration,line1setsrtobetherankofx:keywithin the subtree rooted at x. Setting y D x in line 2 makes the invariant true the first time the test in line 3 executes.
Maintenance: At the end of each iteration of the while loop, we set y D y:p. Thus we must show that if r is the rank of x:key in the subtree rooted at y at the start of the loop body, then r is the rank of x:key in the subtree rooted at y:p at the end of the loop body. In each iteration of the while loop, we consider the subtree rooted at y:p. We have already counted the number of nodes in the subtree rooted at node y that precede x in an inorder walk, and so we must add the nodes in the subtree rooted at y’s sibling that precede x in an inorder walk, plus 1 for y:p if it, too, precedes x. If y is a left child, then neither y:p nor any node in y:p’s right subtree precedes x, and so we leave r alone. Otherwise, y is a right child and all the nodes in y:p’s left subtree precede x, as does y:p itself. Thus, in line 5, we add y:p:left:size C 1 to the current value of r.
Termination: The loop terminates when y D T:root, so that the subtree rooted at y is the entire tree. Thus, the value of r is the rank of x:key in the entire tree.
As an example, when we run OS-RANK on the order-statistic tree of Figure 14.1 to find the rank of the node with key 38, we get the following sequence of values of y:key and r at the top of the while loop:
iteration y:key r 1 38 2 2 30 4 3 41 4 4 26 17

14.1 Dynamic order statistics 343
The procedure returns the rank 17.
Since each iteration of the while loop takes O.1/ time, and y goes up one level in
the tree with each iteration, the running time of OS-RANK is at worst proportional to the height of the tree: O.lg n/ on an n-node order-statistic tree.
Maintaining subtree sizes
Given the size attribute in each node, OS-SELECT and OS-RANK can quickly compute order-statistic information. But unless we can efficiently maintain these attributes within the basic modifying operations on red-black trees, our work will have been for naught. We shall now show how to maintain subtree sizes for both insertion and deletion without affecting the asymptotic running time of either op- eration.
We noted in Section 13.3 that insertion into a red-black tree consists of two phases. The first phase goes down the tree from the root, inserting the new node as a child of an existing node. The second phase goes up the tree, changing colors and performing rotations to maintain the red-black properties.
To maintain the subtree sizes in the first phase, we simply increment x:size for each node x on the simple path traversed from the root down toward the leaves. The new node added gets a size of 1. Since there are O.lg n/ nodes on the traversed path, the additional cost of maintaining the size attributes is O.lg n/.
In the second phase, the only structural changes to the underlying red-black tree are caused by rotations, of which there are at most two. Moreover, a rotation is a local operation: only two nodes have their size attributes invalidated. The link around which the rotation is performed is incident on these two nodes. Referring to the code for LEFT-ROTATE.T;x/ in Section 13.2, we add the following lines:
13 y:size D x:size
14 x:size D x:left:size C x:right:size C 1
Figure 14.2 illustrates how the attributes are updated. The change to RIGHT- ROTATE is symmetric.
Since at most two rotations are performed during insertion into a red-black tree, we spend only O.1/ additional time updating size attributes in the second phase. Thus, the total time for insertion into an n-node order-statistic tree is O.lgn/, which is asymptotically the same as for an ordinary red-black tree.
Deletion from a red-black tree also consists of two phases: the first operates on the underlying search tree, and the second causes at most three rotations and otherwise performs no structural changes. (See Section 13.4.) The first phase either removes one node y from the tree or moves upward it within the tree. To update the subtree sizes, we simply traverse a simple path from node y (starting from its original position within the tree) up to the root, decrementing the size

344 Chapter 14
Augmenting Data Structures
42 x 11
93 y 12
93
19 y
LEFT-ROTATE(T, x)
RIGHT-ROTATE(T, y) 76
42
19 x
64 47
Figure 14.2 Updating subtree sizes during rotations. The link around which we rotate is incident on the two nodes whose size attributes need to be updated. The updates are local, requiring only the size information stored in x, y, and the roots of the subtrees shown as triangles.
attribute of each node on the path. Since this path has length O.lgn/ in an n- node red-black tree, the additional time spent maintaining size attributes in the first phase is O.lg n/. We handle the O.1/ rotations in the second phase of deletion in the same manner as for insertion. Thus, both insertion and deletion, including maintaining the size attributes, take O.lg n/ time for an n-node order-statistic tree.
Exercises
14.1-1
Show how OS-SELECT.T:root;10/ operates on the red-black tree T of Fig- ure 14.1.
14.1-2
Show how OS-RANK.T;x/ operates on the red-black tree T of Figure 14.1 and the node x with x:key D 35.
14.1-3
Write a nonrecursive version of OS-SELECT.
14.1-4
Write a recursive procedure OS-KEY-RANK.T;k/ that takes as input an order- statistic tree T and a key k and returns the rank of k in the dynamic set represented by T . Assume that the keys of T are distinct.
14.1-5
Given an element x in an n-node order-statistic tree and a natural number i, how can we determine the ith successor of x in the linear order of the tree in O.lgn/ time?

14.2 How to augment a data structure 345
14.1-6
Observe that whenever we reference the size attribute of a node in either OS- SELECT or OS-RANK, we use it only to compute a rank. Accordingly, suppose we store in each node its rank in the subtree of which it is the root. Show how to maintain this information during insertion and deletion. (Remember that these two operations can cause rotations.)
14.1-7
Show how to use an order-statistic tree to count the number of inversions (see Problem 2-4) in an array of size n in time O.n lg n/.
14.1-8 ?
Consider n chords on a circle, each defined by its endpoints. Describe an O.n lg n/-
time algorithm to determine the number of pairs of chords that intersect inside the
circle. (For example, if the n chords are all diameters that meet at the center, then
the correct answer is 􏳣n􏳵.) Assume that no two chords share an endpoint. 2
14.2 How to augment a data structure
The process of augmenting a basic data structure to support additional functionality occurs quite frequently in algorithm design. We shall use it again in the next section to design a data structure that supports operations on intervals. In this section, we examine the steps involved in such augmentation. We shall also prove a theorem that allows us to augment red-black trees easily in many cases.
We can break the process of augmenting a data structure into four steps:
1. Chooseanunderlyingdatastructure.
2. Determineadditionalinformationtomaintainintheunderlyingdatastructure.
3. Verify that we can maintain the additional information for the basic modifying operations on the underlying data structure.
4. Developnewoperations.
As with any prescriptive design method, you should not blindly follow the steps in the order given. Most design work contains an element of trial and error, and progress on all steps usually proceeds in parallel. There is no point, for example, in determining additional information and developing new operations (steps 2 and 4) if we will not be able to maintain the additional information efficiently. Neverthe- less, this four-step method provides a good focus for your efforts in augmenting a data structure, and it is also a good way to organize the documentation of an augmented data structure.

346 Chapter 14 Augmenting Data Structures
We followed these steps in Section 14.1 to design our order-statistic trees. For step 1, we chose red-black trees as the underlying data structure. A clue to the suitability of red-black trees comes from their efficient support of other dynamic- set operations on a total order, such as MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR.
For step 2, we added the size attribute, in which each node x stores the size of the subtree rooted at x. Generally, the additional information makes operations more efficient. For example, we could have implemented OS-SELECT and OS-RANK using just the keys stored in the tree, but they would not have run in O.lg n/ time. Sometimes, the additional information is pointer information rather than data, as in Exercise 14.2-1.
For step 3, we ensured that insertion and deletion could maintain the size at- tributes while still running in O.lg n/ time. Ideally, we should need to update only a few elements of the data structure in order to maintain the additional information. For example, if we simply stored in each node its rank in the tree, the OS-SELECT and OS-RANK procedures would run quickly, but inserting a new minimum ele- ment would cause a change to this information in every node of the tree. When we store subtree sizes instead, inserting a new element causes information to change in only O.lg n/ nodes.
For step 4, we developed the operations OS-SELECT and OS-RANK. After all, the need for new operations is why we bother to augment a data structure in the first place. Occasionally, rather than developing new operations, we use the additional information to expedite existing ones, as in Exercise 14.2-1.
Augmenting red-black trees
When red-black trees underlie an augmented data structure, we can prove that in- sertion and deletion can always efficiently maintain certain kinds of additional in- formation, thereby making step 3 very easy. The proof of the following theorem is similar to the argument from Section 14.1 that we can maintain the size attribute for order-statistic trees.
Theorem 14.1 (Augmenting a red-black tree)
Let f be an attribute that augments a red-black tree T of n nodes, and suppose that the value of f for each node x depends on only the information in nodes x, x:left, and x:right, possibly including x:left:f and x:right:f. Then, we can maintain the values of f in all nodes of T during insertion and deletion without asymptotically affecting the O.lg n/ performance of these operations.
Proof The main idea of the proof is that a change to an f attribute in a node x propagates only to ancestors of x in the tree. That is, changing x:f may re-

14.2 How to augment a data structure 347
quire x:p:f to be updated, but nothing else; updating x:p:f may require x:p:p:f to be updated, but nothing else; and so on up the tree. Once we have updated T:root:f, no other node will depend on the new value, and so the process termi- nates. Since the height of a red-black tree is O.lg n/, changing an f attribute in a node costs O.lg n/ time in updating all nodes that depend on the change.
Insertion of a node x into T consists of two phases. (See Section 13.3.) The first phase inserts x as a child of an existing node x:p. We can compute the value of x:f in O.1/ time since, by supposition, it depends only on information in the other attributes of x itself and the information in x’s children, but x’s children are both the sentinel T:nil. Once we have computed x:f, the change propagates up the tree. Thus, the total time for the first phase of insertion is O.lg n/. During the second phase, the only structural changes to the tree come from rotations. Since only two nodes change in a rotation, the total time for updating the f attributes is O.lg n/ per rotation. Since the number of rotations during insertion is at most two, the total time for insertion is O.lg n/.
Like insertion, deletion has two phases. (See Section 13.4.) In the first phase, changes to the tree occur when the deleted node is removed from the tree. If the deleted node had two children at the time, then its successor moves into the position of the deleted node. Propagating the updates to f caused by these changes costs at most O.lg n/, since the changes modify the tree locally. Fixing up the red-black tree during the second phase requires at most three rotations, and each rotation requires at most O.lg n/ time to propagate the updates to f . Thus, like insertion, the total time for deletion is O.lg n/.
In many cases, such as maintaining the size attributes in order-statistic trees, the cost of updating after a rotation is O.1/, rather than the O.lg n/ derived in the proof of Theorem 14.1. Exercise 14.2-3 gives an example.
Exercises
14.2-1
Show, by adding pointers to the nodes, how to support each of the dynamic-set queries MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR in O.1/ worst- case time on an augmented order-statistic tree. The asymptotic performance of other operations on order-statistic trees should not be affected.
14.2-2
Can we maintain the black-heights of nodes in a red-black tree as attributes in the nodes of the tree without affecting the asymptotic performance of any of the red- black tree operations? Show how, or argue why not. How about maintaining the depths of nodes?

348 Chapter 14 Augmenting Data Structures
14.2-3 ?
Let ̋ be an associative binary operator, and let a be an attribute maintained in each node of a red-black tree. Suppose that we want to include in each node x an addi- tionalattributef suchthatx:f Dx1:a ̋x2:a ̋􏳵􏳵􏳵 ̋xm:a,wherex1;x2;:::;xm is the inorder listing of nodes in the subtree rooted at x. Show how to update the f attributes in O.1/ time after a rotation. Modify your argument slightly to apply it to the size attributes in order-statistic trees.
14.2-4 ?
We wish to augment red-black trees with an operation RB-ENUMERATE.x; a; b/ that outputs all the keys k such that a 􏳥 k 􏳥 b in a red-black tree rooted at x. Describe how to implement RB-ENUMERATE in ‚.mClg n/ time, where m is the number of keys that are output and n is the number of internal nodes in the tree. (Hint: You do not need to add new attributes to the red-black tree.)
14.3 Interval trees
In this section, we shall augment red-black trees to support operations on dynamic sets of intervals. A closed interval is an ordered pair of real numbers Œt1;t2􏳩, with t1 􏳥 t2. The interval Œt1;t2􏳩 represents the set ft 2 R W t1 􏳥 t 􏳥 t2g. Open and half-open intervals omit both or one of the endpoints from the set, respectively. In this section, we shall assume that intervals are closed; extending the results to open and half-open intervals is conceptually straightforward.
Intervals are convenient for representing events that each occupy a continuous period of time. We might, for example, wish to query a database of time intervals to find out what events occurred during a given interval. The data structure in this section provides an efficient means for maintaining such an interval database.
We can represent an interval Œt1; t2􏳩 as an object i, with attributes i:low D t1 (the low endpoint) and i:high D t2 (the high endpoint). We say that intervals i and i0 overlap if i \ i0 ¤ ;, that is, if i:low 􏳥 i0:high and i0:low 􏳥 i:high. As Figure 14.3 shows, any two intervals i and i0 satisfy the interval trichotomy; that is, exactly one of the following three properties holds:
a. iandi0overlap,
b. i is to the left of i0 (i.e., i:high < i0:low), c. i is to the right of i0 (i.e., i0:high < i:low). An interval tree is a red-black tree that maintains a dynamic set of elements, with each element x containing an interval x:int. Interval trees support the following operations: 14.3 Interval trees 349 iiii i′ i′ i′ i′ i i′ (b) i′ i (c) (a) Figure 14.3 The interval trichotomy for two closed intervals i and i0. (a) If i and i0 overlap, there are four situations; in each, i:low 􏳥 i0:high and i0:low 􏳥 i:high. (b) The intervals do not overlap, and i:high < i0:low. (c) The intervals do not overlap, and i0:high < i:low. INTERVAL-INSERT.T;x/ adds the element x, whose int attribute is assumed to contain an interval, to the interval tree T . INTERVAL-DELETE.T; x/ removes the element x from the interval tree T . INTERVAL-SEARCH.T;i/ returns a pointer to an element x in the interval tree T such that x:int overlaps interval i, or a pointer to the sentinel T:nil if no such element is in the set. Figure 14.4 shows how an interval tree represents a set of intervals. We shall track the four-step method from Section 14.2 as we review the design of an interval tree and the operations that run on it. Step 1: Underlying data structure We choose a red-black tree in which each node x contains an interval x:int and the key of x is the low endpoint, x:int:low, of the interval. Thus, an inorder tree walk of the data structure lists the intervals in sorted order by low endpoint. Step 2: Additional information In addition to the intervals themselves, each node x contains a value x:max, which is the maximum value of any interval endpoint stored in the subtree rooted at x. Step 3: Maintaining the information We must verify that insertion and deletion take O.lgn/ time on an interval tree of n nodes. We can determine x:max given interval x:int and the max values of node x’s children: 350 Chapter 14 Augmenting Data Structures 19 20 19 26 26 25 30 (a) 17 16 15 21 23 89 6 10 58 03 0 5 10 15 20 25 30 [16,21] 30 (b) [8,9] 23 int 30 max [25,30] [5,8] 10 23 20 26 [15,23] [17,19] [26,26] [0,3] [6,10] [19,20] 310 20 Figure 14.4 An interval tree. (a) A set of 10 intervals, shown sorted bottom to top by left endpoint. (b) The interval tree that represents them. Each node x contains an interval, shown above the dashed line, and the maximum value of any interval endpoint in the subtree rooted at x, shown below the dashed line. An inorder tree walk of the tree lists the nodes in sorted order by left endpoint. x:max D max.x:int:high; x:left:max; x:right:max/ : Thus, by Theorem 14.1, insertion and deletion run in O.lgn/ time. In fact, we can update the max attributes after a rotation in O.1/ time, as Exercises 14.2-3 and 14.3-1 show. Step 4: Developing new operations The only new operation we need is INTERVAL-SEARCH.T;i/, which finds a node in tree T whose interval overlaps interval i. If there is no interval that overlaps i in the tree, the procedure returns a pointer to the sentinel T:nil. 14.3 Interval trees 351 INTERVAL-SEARCH.T; i/ 1 2 3 4 5 6 xDT:root while x ¤ T:nil and i does not overlap x:int if x:left ¤ T:nil and x:left:max 􏳦 i:low x D x:left else x D x:right return x The search for an interval that overlaps i starts with x at the root of the tree and proceeds downward. It terminates when either it finds an overlapping interval or x points to the sentinel T:nil. Since each iteration of the basic loop takes O.1/ time, and since the height of an n-node red-black tree is O.lg n/, the INTERVAL-SEARCH procedure takes O.lg n/ time. Before we see why INTERVAL-SEARCH is correct, let’s examine how it works on the interval tree in Figure 14.4. Suppose we wish to find an interval that overlaps the interval i D Œ22; 25􏳩. We begin with x as the root, which contains Œ16; 21􏳩 and does not overlap i. Since x:left:max D 23 is greater than i:low D 22, the loop continues with x as the left child of the root—the node containing Œ8; 9􏳩, which also does not overlap i. This time, x:left:max D 10 is less than i:low D 22, and so the loop continues with the right child of x as the new x. Because the interval Œ15; 23􏳩 stored in this node overlaps i, the procedure returns this node. As an example of an unsuccessful search, suppose we wish to find an interval that overlaps i D Œ11; 14􏳩 in the interval tree of Figure 14.4. We once again be- gin with x as the root. Since the root’s interval Œ16;21􏳩 does not overlap i, and since x:left:max D 23 is greater than i:low D 11, we go left to the node con- taining Œ8;9􏳩. Interval Œ8;9􏳩 does not overlap i, and x:left:max D 10 is less than i:low D 11, and so we go right. (Note that no interval in the left subtree over- laps i.) Interval Œ15;23􏳩 does not overlap i, and its left child is T:nil, so again we go right, the loop terminates, and we return the sentinel T:nil. To see why INTERVAL-SEARCH is correct, we must understand why it suffices to examine a single path from the root. The basic idea is that at any node x, if x:int does not overlap i, the search always proceeds in a safe direction: the search will definitely find an overlapping interval if the tree contains one. The following theorem states this property more precisely. Theorem 14.2 Any execution of INTERVAL-SEARCH.T;i/ either returns a node whose interval overlaps i, or it returns T:nil and the tree T contains no node whose interval over- laps i. 352 Chapter 14 Augmenting Data Structures i′ i′′ i′ i i i′ (a) (b) i′′ i′′ Figure 14.5 Intervals in the proof of Theorem 14.2. The value of x:left:max is shown in each case as a dashed line. (a) The search goes right. No interval i0 in x’s left subtree can overlap i. (b) The search goes left. The left subtree of x contains an interval that overlaps i (situation not shown), or x’s left subtree contains an interval i0 such that i0:high D x:left:max. Since i does not overlap i0, neither does it overlap any interval i00 in x’s right subtree, since i0:low 􏳥 i00:low. Proof The while loop of lines 2–5 terminates either when x D T:nil or i over- laps x:int. In the latter case, it is certainly correct to return x. Therefore, we focus on the former case, in which the while loop terminates because x D T:nil. We use the following invariant for the while loop of lines 2–5: If tree T contains an interval that overlaps i, then the subtree rooted at x contains such an interval. We use this loop invariant as follows: Initialization: Prior to the first iteration, line 1 sets x to be the root of T , so that the invariant holds. Maintenance: Each iteration of the while loop executes either line 4 or line 5. We shall show that both cases maintain the loop invariant. If line 5 is executed, then because of the branch condition in line 3, we have x:left D T:nil, or x:left:max < i:low. If x:left D T:nil, the subtree rooted at x:left clearly contains no interval that overlaps i, and so setting x to x:right maintains the invariant. Suppose, therefore, that x:left ¤ T:nil and x:left:max < i:low. As Figure 14.5(a) shows, for each interval i0 in x’s left subtree, we have i0:high 􏳥 x:left:max < i:low: By the interval trichotomy, therefore, i0 and i do not overlap. Thus, the left subtree of x contains no intervals that overlap i, so that setting x to x:right maintains the invariant. 14.3 Interval trees 353 If, on the other hand, line 4 is executed, then we will show that the contrapos- itive of the loop invariant holds. That is, if the subtree rooted at x:left con- tains no interval overlapping i, then no interval anywhere in the tree overlaps i. Since line 4 is executed, then because of the branch condition in line 3, we have x:left:max 􏳦 i:low. Moreover, by definition of the max attribute, x’s left subtree must contain some interval i0 such that i0:high D x:left:max 􏳦 i:low: (Figure 14.5(b) illustrates the situation.) Since i and i0 do not overlap, and since it is not true that i0:high < i:low, it follows by the interval trichotomy that i:high < i0:low. Interval trees are keyed on the low endpoints of intervals, and thus the search-tree property implies that for any interval i00 in x’s right subtree, i:high < i0:low 􏳥 i00:low : By the interval trichotomy, i and i00 do not overlap. We conclude that whether or not any interval in x’s left subtree overlaps i, setting x to x:left maintains the invariant. Termination: If the loop terminates when x D T:nil, then the subtree rooted at x contains no interval overlapping i. The contrapositive of the loop invariant implies that T contains no interval that overlaps i. Hence it is correct to return x D T:nil. Thus, the INTERVAL-SEARCH procedure works correctly. Exercises 14.3-1 Write pseudocode for LEFT-ROTATE that operates on nodes in an interval tree and updates the max attributes in O.1/ time. 14.3-2 Rewrite the code for INTERVAL-SEARCH so that it works properly when all inter- vals are open. 14.3-3 Describe an efficient algorithm that, given an interval i, returns an interval over- lapping i that has the minimum low endpoint, or T:nil if no such interval exists. 354 Chapter 14 Augmenting Data Structures Problems 14.3-4 Given an interval tree T and an interval i, describe how to list all intervals in T that overlap i in O.min.n; k lg n// time, where k is the number of intervals in the output list. (Hint: One simple method makes several queries, modifying the tree between queries. A slightly more complicated method does not modify the tree.) 14.3-5 Suggest modifications to the interval-tree procedures to support the new opera- tion INTERVAL-SEARCH-EXACTLY.T;i/, where T is an interval tree and i is an interval. The operation should return a pointer to a node x in T such that x:int:low D i:low and x:int:high D i:high, or T:nil if T contains no such node. All operations, including INTERVAL-SEARCH-EXACTLY, should run in O.lgn/ time on an n-node interval tree. 14.3-6 Show how to maintain a dynamic set Q of numbers that supports the operation MIN-GAP, which gives the magnitude of the difference of the two closest num- bers in Q. For example, if Q D f1; 5; 9; 15; 18; 22g, then MIN-GAP.Q/ returns 18 􏳣 15 D 3, since 15 and 18 are the two closest numbers in Q. Make the op- erations INSERT, DELETE, SEARCH, and MIN-GAP as efficient as possible, and analyze their running times. 14.3-7 ? VLSI databases commonly represent an integrated circuit as a list of rectan- gles. Assume that each rectangle is rectilinearly oriented (sides parallel to the x- and y-axes), so that we represent a rectangle by its minimum and maximum x- and y-coordinates. Give an O.n lg n/-time algorithm to decide whether or not a set of n rectangles so represented contains two rectangles that overlap. Your algorithm need not report all intersecting pairs, but it must report that an overlap exists if one rectangle entirely covers another, even if the boundary lines do not intersect. (Hint: Move a “sweep” line across the set of rectangles.) 14-1 Point of maximum overlap Suppose that we wish to keep track of a point of maximum overlap in a set of intervals—a point with the largest number of intervals in the set that overlap it. a. Show that there will always be a point of maximum overlap that is an endpoint of one of the segments. Notes for Chapter 14 355 b. Design a data structure that efficiently supports the operations INTERVAL- INSERT, INTERVAL-DELETE, and FIND-POM, which returns a point of max- imum overlap. (Hint: Keep a red-black tree of all the endpoints. Associate a value of C1 with each left endpoint, and associate a value of 􏳣1 with each right endpoint. Augment each node of the tree with some extra information to maintain the point of maximum overlap.) 14-2 Josephus permutation We define the Josephus problem as follows. Suppose that n people form a circle and that we are given a positive integer m 􏳥 n. Beginning with a designated first person, we proceed around the circle, removing every mth person. After each person is removed, counting continues around the circle that remains. This process continues until we have removed all n people. The order in which the people are removed from the circle defines the .n; m/-Josephus permutation of the integers 1; 2; : : : ; n. For example, the .7; 3/-Josephus permutation is h3; 6; 2; 7; 5; 1; 4i. a. Suppose that m is a constant. Describe an O.n/-time algorithm that, given an integer n, outputs the .n; m/-Josephus permutation. b. Suppose that m is not a constant. Describe an O.n lg n/-time algorithm that, given integers n and m, outputs the .n; m/-Josephus permutation. Chapter notes In their book, Preparata and Shamos [282] describe several of the interval trees that appear in the literature, citing work by H. Edelsbrunner (1980) and E. M. McCreight (1981). The book details an interval tree that, given a static database of n intervals, allows us to enumerate all k intervals that overlap a given query interval in O.k C lg n/ time. IV Advanced Design and Analysis Techniques Introduction This part covers three important techniques used in designing and analyzing effi- cient algorithms: dynamic programming (Chapter 15), greedy algorithms (Chap- ter 16), and amortized analysis (Chapter 17). Earlier parts have presented other widely applicable techniques, such as divide-and-conquer, randomization, and how to solve recurrences. The techniques in this part are somewhat more sophisticated, but they help us to attack many computational problems. The themes introduced in this part will recur later in this book. Dynamic programming typically applies to optimization problems in which we make a set of choices in order to arrive at an optimal solution. As we make each choice, subproblems of the same form often arise. Dynamic programming is effective when a given subproblem may arise from more than one partial set of choices; the key technique is to store the solution to each such subproblem in case it should reappear. Chapter 15 shows how this simple idea can sometimes transform exponential-time algorithms into polynomial-time algorithms. Like dynamic-programming algorithms, greedy algorithms typically apply to optimization problems in which we make a set of choices in order to arrive at an optimal solution. The idea of a greedy algorithm is to make each choice in a locally optimal manner. A simple example is coin-changing: to minimize the number of U.S. coins needed to make change for a given amount, we can repeatedly select the largest-denomination coin that is not larger than the amount that remains. A greedy approach provides an optimal solution for many such problems much more quickly than would a dynamic-programming approach. We cannot always easily tell whether a greedy approach will be effective, however. Chapter 16 introduces 358 Part IV Advanced Design and Analysis Techniques matroid theory, which provides a mathematical basis that can help us to show that a greedy algorithm yields an optimal solution. We use amortized analysis to analyze certain algorithms that perform a sequence of similar operations. Instead of bounding the cost of the sequence of operations by bounding the actual cost of each operation separately, an amortized analysis provides a bound on the actual cost of the entire sequence. One advantage of this approach is that although some operations might be expensive, many others might be cheap. In other words, many of the operations might run in well under the worst- case time. Amortized analysis is not just an analysis tool, however; it is also a way of thinking about the design of algorithms, since the design of an algorithm and the analysis of its running time are often closely intertwined. Chapter 17 introduces three ways to perform an amortized analysis of an algorithm. 15 Dynamic Programming Dynamic programming, like the divide-and-conquer method, solves problems by combining the solutions to subproblems. (“Programming” in this context refers to a tabular method, not to writing computer code.) As we saw in Chapters 2 and 4, divide-and-conquer algorithms partition the problem into disjoint subprob- lems, solve the subproblems recursively, and then combine their solutions to solve the original problem. In contrast, dynamic programming applies when the subprob- lems overlap—that is, when subproblems share subsubproblems. In this context, a divide-and-conquer algorithm does more work than necessary, repeatedly solv- ing the common subsubproblems. A dynamic-programming algorithm solves each subsubproblem just once and then saves its answer in a table, thereby avoiding the work of recomputing the answer every time it solves each subsubproblem. We typically apply dynamic programming to optimization problems. Such prob- lems can have many possible solutions. Each solution has a value, and we wish to find a solution with the optimal (minimum or maximum) value. We call such a solution an optimal solution to the problem, as opposed to the optimal solution, since there may be several solutions that achieve the optimal value. When developing a dynamic-programming algorithm, we follow a sequence of four steps: 1. Characterizethestructureofanoptimalsolution. 2. Recursivelydefinethevalueofanoptimalsolution. 3. Computethevalueofanoptimalsolution,typicallyinabottom-upfashion. 4. Constructanoptimalsolutionfromcomputedinformation. Steps 1–3 form the basis of a dynamic-programming solution to a problem. If we need only the value of an optimal solution, and not the solution itself, then we can omit step 4. When we do perform step 4, we sometimes maintain additional information during step 3 so that we can easily construct an optimal solution. The sections that follow use the dynamic-programming method to solve some optimization problems. Section 15.1 examines the problem of cutting a rod into 360 Chapter 15 Dynamic Programming rods of smaller length in way that maximizes their total value. Section 15.2 asks how we can multiply a chain of matrices while performing the fewest total scalar multiplications. Given these examples of dynamic programming, Section 15.3 dis- cusses two key characteristics that a problem must have for dynamic programming to be a viable solution technique. Section 15.4 then shows how to find the longest common subsequence of two sequences via dynamic programming. Finally, Sec- tion 15.5 uses dynamic programming to construct binary search trees that are opti- mal, given a known distribution of keys to be looked up. 15.1 Rod cutting Our first example uses dynamic programming to solve a simple problem in decid- ing where to cut steel rods. Serling Enterprises buys long steel rods and cuts them into shorter rods, which it then sells. Each cut is free. The management of Serling Enterprises wants to know the best way to cut up the rods. We assume that we know, for i D 1; 2; : : :, the price pi in dollars that Serling Enterprises charges for a rod of length i inches. Rod lengths are always an integral number of inches. Figure 15.1 gives a sample price table. The rod-cutting problem is the following. Given a rod of length n inches and a table of prices pi for i D 1; 2; : : : ; n, determine the maximum revenue rn obtain- able by cutting up the rod and selling the pieces. Note that if the price pn for a rod of length n is large enough, an optimal solution may require no cutting at all. Consider the case when n D 4. Figure 15.2 shows all the ways to cut up a rod of 4 inches in length, including the way with no cuts at all. We see that cutting a 4-inch rod into two 2-inch pieces produces revenue p2 C p2 D 5 C 5 D 10, which is optimal. We can cut up a rod of length n in 2n􏳣1 different ways, since we have an in- dependent option of cutting, or not cutting, at distance i inches from the left end, lengthi 1 2 3 4 5 6 7 8 9 10 pricepi 1 5 8 9 10 17 17 20 24 30 Figure 15.1 A sample price table for rods. Each rod of length i inches earns the company pi dollars of revenue. 15.1 Rod cutting 361 9185581 (a) (b) (c) (d) 115 151 5111111 (e) (f) (g) (h) Figure 15.2 The 8 possible ways of cutting up a rod of length 4. Above each piece is the value of that piece, according to the sample price chart of Figure 15.1. The optimal strategy is part (c)—cutting the rod into two pieces of length 2—which has total value 10. for i D 1; 2; : : : ; n 􏳣 1.1 We denote a decomposition into pieces using ordinary additive notation, so that 7 D 2 C 2 C 3 indicates that a rod of length 7 is cut into three pieces—two of length 2 and one of length 3. If an optimal solution cuts the rod into k pieces, for some 1 􏳥 k 􏳥 n, then an optimal decomposition nDi1 Ci2 C􏳵􏳵􏳵Cik of the rod into pieces of lengths i1, i2, . . . , ik provides maximum corresponding revenue rn Dpi1 Cpi2 C􏳵􏳵􏳵Cpik : For our sample problem, we can determine the optimal revenue figures ri , for i D 1; 2; : : : ; 10, by inspection, with the corresponding optimal decompositions 1If we required the pieces to be cut in order of nondecreasing size, there would be fewer ways to consider. For n D 4, we would consider only 5 such ways: parts (a), (b), (c), (e), and (h) in Figure 15.2. The number of ways is called the partition function; it is approximately equal to e􏳬p2n=3=4np3. This quantity is less than 2n􏳣1, but still much greater than any polynomial in n. We shall not pursue this line of inquiry further, however. 362 Chapter 15 Dynamic Programming r1 D r2 D r3 D r4 D r5 D r6 D r7 D r8 D r9 D 1 fromsolution1D1 (nocuts); 5 fromsolution2D2 (nocuts); 8 fromsolution3D3 (nocuts); 10 fromsolution4D2C2; 13 fromsolution5D2C3; 17 fromsolution6D6 (nocuts); 18 fromsolution7D1C6 or 7D2C2C3; 22 fromsolution8D2C6; 25 fromsolution9D3C6; 30 from solution 10 D 10 (no cuts) : r10 D More generally, we can frame the values rn for n 􏳦 1 in terms of optimal rev- enues from shorter rods: rn D max.pn;r1 Crn􏳣1;r2 Crn􏳣2;:::;rn􏳣1 Cr1/ : (15.1) The first argument, pn, corresponds to making no cuts at all and selling the rod of length n as is. The other n 􏳣 1 arguments to max correspond to the maximum rev- enue obtained by making an initial cut of the rod into two pieces of size i and n 􏳣 i , for each i D 1; 2; : : : ; n 􏳣 1, and then optimally cutting up those pieces further, obtaining revenues ri and rn􏳣i from those two pieces. Since we don’t know ahead of time which value of i optimizes revenue, we have to consider all possible values for i and pick the one that maximizes revenue. We also have the option of picking no i at all if we can obtain more revenue by selling the rod uncut. Note that to solve the original problem of size n, we solve smaller problems of the same type, but of smaller sizes. Once we make the first cut, we may consider the two pieces as independent instances of the rod-cutting problem. The overall optimal solution incorporates optimal solutions to the two related subproblems, maximizing revenue from each of those two pieces. We say that the rod-cutting problem exhibits optimal substructure: optimal solutions to a problem incorporate optimal solutions to related subproblems, which we may solve independently. In a related, but slightly simpler, way to arrange a recursive structure for the rod- cutting problem, we view a decomposition as consisting of a first piece of length i cut off the left-hand end, and then a right-hand remainder of length n 􏳣 i. Only the remainder, and not the first piece, may be further divided. We may view every decomposition of a length-n rod in this way: as a first piece followed by some decomposition of the remainder. When doing so, we can couch the solution with no cuts at all as saying that the first piece has size i D n and revenue pn and that the remainder has size 0 with corresponding revenue r0 D 0. We thus obtain the following simpler version of equation (15.1): rn D max .pi Crn􏳣i/ : (15.2) 1􏳥i 􏳥n 15.1 Rod cutting 363 In this formulation, an optimal solution embodies the solution to only one related subproblem—the remainder—rather than two. Recursive top-down implementation The following procedure implements the computation implicit in equation (15.2) in a straightforward, top-down, recursive manner. CUT-ROD.p;n/ 1 2 3 4 5 6 ifn==0 return 0 qD􏳣1 foriD1ton q D max.q;pŒi􏳩CCUT-ROD.p;n􏳣i// return q Procedure CUT-ROD takes as input an array pŒ1 : : n􏳩 of prices and an integer n, and it returns the maximum revenue possible for a rod of length n. If n D 0, no revenue is possible, and so CUT-ROD returns 0 in line 2. Line 3 initializes the maximum revenue q to 􏳣1, so that the for loop in lines 4–5 correctly computes q D max1􏳥i􏳥n.pi C CUT-ROD.p; n 􏳣 i//; line 6 then returns this value. A simple induction on n proves that this answer is equal to the desired answer rn, using equation (15.2). If you were to code up CUT-ROD in your favorite programming language and run it on your computer, you would find that once the input size becomes moderately large, your program would take a long time to run. For n D 40, you would find that your program takes at least several minutes, and most likely more than an hour. In fact, you would find that each time you increase n by 1, your program’s running time would approximately double. Why is CUT-ROD so inefficient? The problem is that CUT-ROD calls itself recursively over and over again with the same parameter values; it solves the same subproblems repeatedly. Figure 15.3 illustrates what happens for n D 4: CUT-ROD.p; n/ calls CUT-ROD.p; n 􏳣 i/ for i D 1; 2; : : : ; n. Equivalently, CUT-ROD.p;n/ calls CUT-ROD.p;j/ for each j D 0;1;:::;n 􏳣 1. When this process unfolds recursively, the amount of work done, as a function of n, grows explosively. To analyze the running time of CUT-ROD, let T.n/ denote the total number of calls made to CUT-ROD when called with its second parameter equal to n. This expression equals the number of nodes in a subtree whose root is labeled n in the recursion tree. The count includes the initial call at its root. Thus, T .0/ D 1 and 364 Chapter 15 Dynamic Programming 4 3210 210100 100 0 0 Figure 15.3 The recursion tree showing recursive calls resulting from a call CUT-ROD.p;n/ for n D 4. Each node label gives the size n of the corresponding subproblem, so that an edge from a parent with label s to a child with label t corresponds to cutting off an initial piece of size s 􏳣 t and leaving a remaining subproblem of size t. A path from the root to a leaf corresponds to one of the 2n􏳣1 ways of cutting up a rod of length n. In general, this recursion tree has 2n nodes and 2n􏳣1 leaves. n􏳣1 X jD0 The initial 1 is for the call at the root, and the term T .j / counts the number of calls (including recursive calls) due to the call CUT-ROD.p; n 􏳣 i/, where j D n 􏳣 i. As Exercise 15.1-1 asks you to show, T.n/D2n ; (15.4) and so the running time of CUT-ROD is exponential in n. In retrospect, this exponential running time is not so surprising. CUT-ROD ex- plicitly considers all the 2n􏳣1 possible ways of cutting up a rod of length n. The tree of recursive calls has 2n􏳣1 leaves, one for each possible way of cutting up the rod. The labels on the simple path from the root to a leaf give the sizes of each remaining right-hand piece before making each cut. That is, the labels give the corresponding cut points, measured from the right-hand end of the rod. Using dynamic programming for optimal rod cutting We now show how to convert CUT-ROD into an efficient algorithm, using dynamic programming. The dynamic-programming method works as follows. Having observed that a naive recursive solution is inefficient because it solves the same subproblems re- peatedly, we arrange for each subproblem to be solved only once, saving its solu- tion. If we need to refer to this subproblem’s solution again later, we can just look it T.n/ D 1 C T.j/ : (15.3) 15.1 Rod cutting 365 up, rather than recompute it. Dynamic programming thus uses additional memory to save computation time; it serves an example of a time-memory trade-off. The savings may be dramatic: an exponential-time solution may be transformed into a polynomial-time solution. A dynamic-programming approach runs in polynomial time when the number of distinct subproblems involved is polynomial in the input size and we can solve each such subproblem in polynomial time. There are usually two equivalent ways to implement a dynamic-programming approach. We shall illustrate both of them with our rod-cutting example. The first approach is top-down with memoization.2 In this approach, we write the procedure recursively in a natural manner, but modified to save the result of each subproblem (usually in an array or hash table). The procedure now first checks to see whether it has previously solved this subproblem. If so, it returns the saved value, saving further computation at this level; if not, the procedure computes the value in the usual manner. We say that the recursive procedure has been memoized; it “remembers” what results it has computed previously. The second approach is the bottom-up method. This approach typically depends on some natural notion of the “size” of a subproblem, such that solving any par- ticular subproblem depends only on solving “smaller” subproblems. We sort the subproblems by size and solve them in size order, smallest first. When solving a particular subproblem, we have already solved all of the smaller subproblems its solution depends upon, and we have saved their solutions. We solve each sub- problem only once, and when we first see it, we have already solved all of its prerequisite subproblems. These two approaches yield algorithms with the same asymptotic running time, except in unusual circumstances where the top-down approach does not actually recurse to examine all possible subproblems. The bottom-up approach often has much better constant factors, since it has less overhead for procedure calls. Here is the the pseudocode for the top-down CUT-ROD procedure, with memo- ization added: MEMOIZED-CUT-ROD.p;n/ 1 let rŒ0::n􏳩 be a new array 2 foriD0ton 3 rŒi􏳩 D 􏳣1 4 return MEMOIZED-CUT-ROD-AUX.p; n; r/ 2This is not a misspelling. The word really is memoization, not memorization. Memoization comes from memo, since the technique consists of recording a value so that we can look it up later. 366 Chapter 15 Dynamic Programming MEMOIZED-CUT-ROD-AUX.p;n;r/ 1 2 3 4 5 6 7 8 9 ifrŒn􏳩􏳦0 return rŒn􏳩 ifn==0 qD0 elseqD􏳣1 for i D 1 to n q D max.q; pŒi􏳩 C MEMOIZED-CUT-ROD-AUX.p; n 􏳣 i; r// rŒn􏳩Dq return q Here, the main procedure MEMOIZED-CUT-ROD initializes a new auxiliary ar- ray rŒ0::n􏳩 with the value 􏳣1, a convenient choice with which to denote “un- known.” (Known revenue values are always nonnegative.) It then calls its helper routine, MEMOIZED-CUT-ROD-AUX. The procedure MEMOIZED-CUT-ROD-AUX is just the memoized version of our previous procedure, CUT-ROD. It first checks in line 1 to see whether the desired value is already known and, if it is, then line 2 returns it. Otherwise, lines 3–7 compute the desired value q in the usual manner, line 8 saves it in rŒn􏳩, and line 9 returns it. The bottom-up version is even simpler: BOTTOM-UP-CUT-ROD.p;n/ 1 2 3 4 5 6 7 8 let rŒ0::n􏳩 be a new array rŒ0􏳩D0 forjD1ton q D 􏳣1 for i D 1 to j q D max.q;pŒi􏳩CrŒj 􏳣i􏳩/ rŒj􏳩 D q return rŒn􏳩 For the bottom-up dynamic-programming approach, BOTTOM-UP-CUT-ROD uses the natural ordering of the subproblems: a problem of size i is “smaller” than a subproblem of size j if i < j . Thus, the procedure solves subproblems of sizes j D 0;1;:::;n, in that order. Line 1 of procedure BOTTOM-UP-CUT-ROD creates a new array rŒ0::n􏳩 in which to save the results of the subproblems, and line 2 initializes rŒ0􏳩 to 0, since a rod of length 0 earns no revenue. Lines 3–6 solve each subproblem of size j , for j D 1; 2; : : : ; n, in order of increasing size. The approach used to solve a problem of a particular size j is the same as that used by CUT-ROD, except that line 6 now 15.1 Rod cutting 367 4 3 2 1 0 The subproblem graph for the rod-cutting problem with n D 4. The vertex labels give the sizes of the corresponding subproblems. A directed edge .x;y/ indicates that we need a solution to subproblem y when solving subproblem x. This graph is a reduced version of the tree of Figure 15.3, in which all nodes with the same label are collapsed into a single vertex and all edges go from parent to child. directly references array entry rŒj 􏳣 i􏳩 instead of making a recursive call to solve the subproblem of size j 􏳣 i . Line 7 saves in r Œj 􏳩 the solution to the subproblem of size j. Finally, line 8 returns rŒn􏳩, which equals the optimal value rn. The bottom-up and top-down versions have the same asymptotic running time. The running time of procedure BOTTOM-UP-CUT-ROD is ‚.n2/, due to its doubly-nested loop structure. The number of iterations of its inner for loop, in lines 5–6, forms an arithmetic series. The running time of its top-down counterpart, MEMOIZED-CUT-ROD, is also ‚.n2/, although this running time may be a little harder to see. Because a recursive call to solve a previously solved subproblem returns immediately, MEMOIZED-CUT-ROD solves each subproblem just once. It solves subproblems for sizes 0; 1; : : : ; n. To solve a subproblem of size n, the for loop of lines 6–7 iterates n times. Thus, the total number of iterations of this for loop, over all recursive calls of MEMOIZED-CUT-ROD, forms an arithmetic series, giving a total of ‚.n2/ iterations, just like the inner for loop of BOTTOM-UP- CUT-ROD. (We actually are using a form of aggregate analysis here. We shall see aggregate analysis in detail in Section 17.1.) Subproblem graphs When we think about a dynamic-programming problem, we should understand the set of subproblems involved and how subproblems depend on one another. The subproblem graph for the problem embodies exactly this information. Fig- ure 15.4 shows the subproblem graph for the rod-cutting problem with n D 4. It is a directed graph, containing one vertex for each distinct subproblem. The sub- Figure 15.4 368 Chapter 15 Dynamic Programming problem graph has a directed edge from the vertex for subproblem x to the vertex for subproblem y if determining an optimal solution for subproblem x involves directly considering an optimal solution for subproblem y. For example, the sub- problem graph contains an edge from x to y if a top-down recursive procedure for solving x directly calls itself to solve y. We can think of the subproblem graph as a “reduced” or “collapsed” version of the recursion tree for the top-down recur- sive method, in which we coalesce all nodes for the same subproblem into a single vertex and direct all edges from parent to child. The bottom-up method for dynamic programming considers the vertices of the subproblem graph in such an order that we solve the subproblems y adjacent to a given subproblem x before we solve subproblem x. (Recall from Section B.4 that the adjacency relation is not necessarily symmetric.) Using the terminology from Chapter 22, in a bottom-up dynamic-programming algorithm, we consider the vertices of the subproblem graph in an order that is a “reverse topological sort,” or a “topological sort of the transpose” (see Section 22.4) of the subproblem graph. In other words, no subproblem is considered until all of the subproblems it depends upon have been solved. Similarly, using notions from the same chapter, we can view the top-down method (with memoization) for dynamic programming as a “depth-first search” of the subproblem graph (see Section 22.3). The size of the subproblem graph G D .V; E/ can help us determine the running time of the dynamic programming algorithm. Since we solve each subproblem just once, the running time is the sum of the times needed to solve each subproblem. Typically, the time to compute the solution to a subproblem is proportional to the degree (number of outgoing edges) of the corresponding vertex in the subproblem graph, and the number of subproblems is equal to the number of vertices in the sub- problem graph. In this common case, the running time of dynamic programming is linear in the number of vertices and edges. Reconstructing a solution Our dynamic-programming solutions to the rod-cutting problem return the value of an optimal solution, but they do not return an actual solution: a list of piece sizes. We can extend the dynamic-programming approach to record not only the optimal value computed for each subproblem, but also a choice that led to the optimal value. With this information, we can readily print an optimal solution. Here is an extended version of BOTTOM-UP-CUT-ROD that computes, for each rod size j , not only the maximum revenue rj , but also sj , the optimal size of the first piece to cut off: 15.1 Rod cutting 369 EXTENDED-BOTTOM-UP-CUT-ROD.p;n/ 1 2 3 4 5 6 7 8 9 10 let rŒ0::n􏳩 and sŒ0::n􏳩 be new arrays rŒ0􏳩D0 forjD1ton q D 􏳣1 for i D 1 to j if q < pŒi􏳩 C rŒj 􏳣 i􏳩 q D pŒi􏳩CrŒj 􏳣i􏳩 sŒj􏳩 D i rŒj􏳩 D q return r and s This procedure is similar to BOTTOM-UP-CUT-ROD, except that it creates the ar- ray s in line 1, and it updates sŒj􏳩 in line 8 to hold the optimal size i of the first piece to cut off when solving a subproblem of size j . The following procedure takes a price table p and a rod size n, and it calls EXTENDED-BOTTOM-UP-CUT-ROD to compute the array sŒ1 : : n􏳩 of optimal first-piece sizes and then prints out the complete list of piece sizes in an optimal decomposition of a rod of length n: PRINT-CUT-ROD-SOLUTION.p;n/ 1 .r;s/ D EXTENDED-BOTTOM-UP-CUT-ROD.p;n/ 2 whilen>0
3 print sŒn􏳩
4 n D n 􏳣 sŒn􏳩
In our rod-cutting example, the call EXTENDED-BOTTOM-UP-CUT-ROD.p;10/ would return the following arrays:
i 0 1 2 3 4 5 6 7 8 9 10 rŒi􏳩 0 1 5 8 10 13 17 18 22 25 30 sŒi􏳩 0 1 2 3 2 2 6 1 2 3 10
A call to PRINT-CUT-ROD-SOLUTION.p;10/ would print just 10, but a call with n D 7 would print the cuts 1 and 6, corresponding to the first optimal decomposi- tion for r7 given earlier.
Exercises
15.1-1
Show that equation (15.4) follows from equation (15.3) and the initial condition T.0/ D 1.

370 Chapter 15 Dynamic Programming
15.1-2
Show, by means of a counterexample, that the following “greedy” strategy does not always determine an optimal way to cut rods. Define the density of a rod of length i to be pi=i, that is, its value per inch. The greedy strategy for a rod of length n cuts off a first piece of length i, where 1 􏳥 i 􏳥 n, having maximum density. It then continues by applying the greedy strategy to the remaining piece of length n 􏳣 i.
15.1-3
Consider a modification of the rod-cutting problem in which, in addition to a price pi for each rod, each cut incurs a fixed cost of c. The revenue associated with a solution is now the sum of the prices of the pieces minus the costs of making the cuts. Give a dynamic-programming algorithm to solve this modified problem.
15.1-4
Modify MEMOIZED-CUT-ROD to return not only the value but the actual solution, too.
15.1-5
The Fibonacci numbers are defined by recurrence (3.22). Give an O.n/-time dynamic-programming algorithm to compute the nth Fibonacci number. Draw the subproblem graph. How many vertices and edges are in the graph?
15.2 Matrix-chain multiplication
Our next example of dynamic programming is an algorithm that solves the problem of matrix-chain multiplication. We are given a sequence (chain) hA1; A2; : : : ; Ani of n matrices to be multiplied, and we wish to compute the product
A1A2 􏳵􏳵􏳵An : (15.5)
We can evaluate the expression (15.5) using the standard algorithm for multiply- ing pairs of matrices as a subroutine once we have parenthesized it to resolve all ambiguities in how the matrices are multiplied together. Matrix multiplication is associative, and so all parenthesizations yield the same product. A product of ma- trices is fully parenthesized if it is either a single matrix or the product of two fully parenthesized matrix products, surrounded by parentheses. For example, if the chain of matrices is hA1; A2; A3; A4i, then we can fully parenthesize the product A1A2A3A4 in five distinct ways:

15.2 Matrix-chain multiplication 371
.A1.A2.A3A4/// ; .A1..A2A3/A4// ; ..A1A2/.A3A4// ; ..A1.A2A3//A4/ ; …A1A2/A3/A4/ :
How we parenthesize a chain of matrices can have a dramatic impact on the cost of evaluating the product. Consider first the cost of multiplying two matrices. The standard algorithm is given by the following pseudocode, which generalizes the SQUARE-MATRIX-MULTIPLY procedure from Section 4.2. The attributes rows and columns are the numbers of rows and columns in a matrix.
MATRIX-MULTIPLY.A;B/
1 2 3 4 5 6 7 8 9
if A:columns ¤ B:rows
error “incompatible dimensions”
else let C be a new A:rows 􏳨 B:columns matrix for i D 1 to A:rows
for j D 1 to B:columns cij D0
for k D 1 to A:columns cij DcijCaik􏳵bkj
return C
We can multiply two matrices A and B only if they are compatible: the number of columns of A must equal the number of rows of B. If A is a p 􏳨 q matrix and B is a q 􏳨 r matrix, the resulting matrix C is a p 􏳨 r matrix. The time to compute C is dominated by the number of scalar multiplications in line 8, which is pqr. In what follows, we shall express costs in terms of the number of scalar multiplications.
To illustrate the different costs incurred by different parenthesizations of a matrix product, consider the problem of a chain hA1; A2; A3i of three matrices. Suppose that the dimensions of the matrices are 10 􏳨 100, 100 􏳨 5, and 5 􏳨 50, respec- tively. If we multiply according to the parenthesization ..A1A2/A3/, we perform 10 􏳵 100 􏳵 5 D 5000 scalar multiplications to compute the 10 􏳨 5 matrix prod- uct A1A2, plus another 10 􏳵 5 􏳵 50 D 2500 scalar multiplications to multiply this matrix by A3, for a total of 7500 scalar multiplications. If instead we multiply according to the parenthesization .A1.A2A3//, we perform 100 􏳵 5 􏳵 50 D 25,000 scalar multiplications to compute the 100 􏳨 50 matrix product A2A3, plus another 10 􏳵 100 􏳵 50 D 50,000 scalar multiplications to multiply A1 by this matrix, for a total of 75,000 scalar multiplications. Thus, computing the product according to the first parenthesization is 10 times faster.
We state the matrix-chain multiplication problem as follows: given a chain hA1;A2;:::;Aniofnmatrices,wherefori D1;2;:::;n,matrixAi hasdimension

372 Chapter 15 Dynamic Programming
pi􏳣1 􏳨pi,fullyparenthesizetheproductA1A2􏳵􏳵􏳵An inawaythatminimizesthe number of scalar multiplications.
Note that in the matrix-chain multiplication problem, we are not actually multi- plying matrices. Our goal is only to determine an order for multiplying matrices that has the lowest cost. Typically, the time invested in determining this optimal order is more than paid for by the time saved later on when actually performing the matrix multiplications (such as performing only 7500 scalar multiplications instead of 75,000).
Counting the number of parenthesizations
Before solving the matrix-chain multiplication problem by dynamic programming, let us convince ourselves that exhaustively checking all possible parenthesizations does not yield an efficient algorithm. Denote the number of alternative parenthe- sizations of a sequence of n matrices by P.n/. When n D 1, we have just one matrix and therefore only one way to fully parenthesize the matrix product. When n 􏳦 2, a fully parenthesized matrix product is the product of two fully parenthe- sized matrix subproducts, and the split between the two subproducts may occur between the kth and .k C 1/st matrices for any k D 1;2;:::;n 􏳣 1. Thus, we obtain th􏳾e recurrence
Problem 12-4 asked you to show that the solution to a similar recurrence is the sequence of Catalan numbers, which grows as 􏳫.4n=n3=2/. A simpler exercise (see Exercise 15.2-3) is to show that the solution to the recurrence (15.6) is 􏳫.2n/. The number of solutions is thus exponential in n, and the brute-force method of exhaustive search makes for a poor strategy when determining how to optimally parenthesize a matrix chain.
Applying dynamic programming
We shall use the dynamic-programming method to determine how to optimally parenthesize a matrix chain. In so doing, we shall follow the four-step sequence that we stated at the beginning of this chapter:
1. Characterize the structure of an optimal solution.
2. Recursively define the value of an optimal solution.
3. Compute the value of an optimal solution.
1 if n D 1 ; n􏳣1
P.n/D XP.k/P.n􏳣k/ ifn􏳦2: (15.6) kD1

15.2 Matrix-chain multiplication 373
4. Constructanoptimalsolutionfromcomputedinformation.
We shall go through these steps in order, demonstrating clearly how we apply each step to the problem.
Step 1: The structure of an optimal parenthesization
For our first step in the dynamic-programming paradigm, we find the optimal sub- structure and then use it to construct an optimal solution to the problem from opti- mal solutions to subproblems. In the matrix-chain multiplication problem, we can perform this step as follows. For convenience, let us adopt the notation Ai ::j , where i 􏳥 j , for the matrix that results from evaluating the product Ai Ai C1 􏳵 􏳵 􏳵 Aj . Ob- serve that if the problem is nontrivial, i.e., i < j , then to parenthesize the product Ai Ai C1 􏳵 􏳵 􏳵 Aj , we must split the product between Ak and AkC1 for some integer k in the range i 􏳥 k < j . That is, for some value of k, we first compute the matrices Ai::k and AkC1::j and then multiply them together to produce the final product Ai::j . The cost of parenthesizing this way is the cost of computing the matrix Ai::k, plus the cost of computing AkC1::j , plus the cost of multiplying them together. The optimal substructure of this problem is as follows. Suppose that to op- timally parenthesize AiAiC1 􏳵􏳵􏳵Aj, we split the product between Ak and AkC1. Then the way we parenthesize the “prefix” subchain Ai Ai C1 􏳵 􏳵 􏳵 Ak within this optimalparenthesizationofAiAiC1􏳵􏳵􏳵Aj mustbeanoptimalparenthesizationof Ai Ai C1 􏳵 􏳵 􏳵 Ak . Why? If there were a less costly way to parenthesize Ai Ai C1 􏳵 􏳵 􏳵 Ak , then we could substitute that parenthesization in the optimal parenthesization of AiAiC1 􏳵􏳵􏳵Aj to produce another way to parenthesize AiAiC1 􏳵􏳵􏳵Aj whose cost was lower than the optimum: a contradiction. A similar observation holds for how we parenthesize the subchain AkC1AkC2 􏳵 􏳵 􏳵 Aj in the optimal parenthesization of A i A i C 1 􏳵 􏳵 􏳵 Aj : i t m u s t b e a n o p t i m a l p a r e n t h e s i z a t i o n o f A k C 1 A k C 2 􏳵 􏳵 􏳵 Aj . Now we use our optimal substructure to show that we can construct an optimal solution to the problem from optimal solutions to subproblems. We have seen that any solution to a nontrivial instance of the matrix-chain multiplication problem requires us to split the product, and that any optimal solution contains within it op- timal solutions to subproblem instances. Thus, we can build an optimal solution to an instance of the matrix-chain multiplication problem by splitting the problem into two subproblems (optimally parenthesizing AiAiC1 􏳵􏳵􏳵Ak and AkC1AkC2 􏳵􏳵􏳵Aj), finding optimal solutions to subproblem instances, and then combining these op- timal subproblem solutions. We must ensure that when we search for the correct place to split the product, we have considered all possible places, so that we are sure of having examined the optimal one. 374 Chapter 15 Dynamic Programming Step 2: A recursive solution Next, we define the cost of an optimal solution recursively in terms of the optimal solutions to subproblems. For the matrix-chain multiplication problem, we pick as our subproblems the problems of determining the minimum cost of parenthesizing AiAiC1 􏳵􏳵􏳵Aj for 1 􏳥 i 􏳥 j 􏳥 n. Let mŒi;j􏳩 be the minimum number of scalar multiplications needed to compute the matrix Ai ::j ; for the full problem, the lowest- cost way to compute A1::n would thus be mŒ1; n􏳩. We can define mŒi; j 􏳩 recursively as follows. If i D j , the problem is trivial; the chain consists of just one matrix Ai::i D Ai, so that no scalar multiplications are necessary to compute the product. Thus, mŒi;i􏳩 D 0 for i D 1;2;:::;n. To compute mŒi;j􏳩 when i < j, we take advantage of the structure of an optimal solution from step 1. Let us assume that to optimally parenthesize, we split the product AiAiC1 􏳵􏳵􏳵Aj between Ak and AkC1, where i 􏳥 k < j. Then, mŒi;j􏳩 equals the minimum cost for computing the subproducts Ai::k and AkC1::j , plus the cost of multiplying these two matrices together. Recalling that each matrix Ai is pi􏳣1􏳨pi,weseethatcomputingthematrixproductAi::kAkC1::j takespi􏳣1pkpj scalar multiplications. Thus, we obtain mŒi;j􏳩DmŒi;k􏳩CmŒkC1;j􏳩Cpi􏳣1pkpj : This recursive equation assumes that we know the value of k, which we do not. There are only j 􏳣i possible values for k, however, namely k D i; i C1; : : : ; j 􏳣1. Since the optimal parenthesization must use one of these values for k, we need only check them all to find the best. Thus, our recursive definition for the minimum cost ofparenthesizingtheproductAiAiC1􏳵􏳵􏳵Aj becomes ( i􏳥k 1 :
which completes the proof. Thus, the total amount of work performed by the call RECURSIVE-MATRIX-CHAIN.p; 1; n/ is at least exponential in n.
Compare this top-down, recursive algorithm (without memoization) with the bottom-up dynamic-programming algorithm. The latter is more efficient because it takes advantage of the overlapping-subproblems property. Matrix-chain mul- tiplication has only ‚.n2/ distinct subproblems, and the dynamic-programming algorithm solves each exactly once. The recursive algorithm, on the other hand, must again solve each subproblem every time it reappears in the recursion tree. Whenever a recursion tree for the natural recursive solution to a problem contains the same subproblem repeatedly, and the total number of distinct subproblems is small, dynamic programming can improve efficiency, sometimes dramatically.

15.3 Elements of dynamic programming 387
Reconstructing an optimal solution
As a practical matter, we often store which choice we made in each subproblem in a table so that we do not have to reconstruct this information from the costs that we stored.
For matrix-chain multiplication, the table sŒi; j 􏳩 saves us a significant amount of work when reconstructing an optimal solution. Suppose that we did not maintain the sŒi; j 􏳩 table, having filled in only the table mŒi; j 􏳩 containing optimal subprob- lem costs. We choose from among j 􏳣 i possibilities when we determine which subproblems to use in an optimal solution to parenthesizing Ai Ai C1 􏳵 􏳵 􏳵 Aj , and j 􏳣 i is not a constant. Therefore, it would take ‚.j 􏳣 i/ D !.1/ time to recon- struct which subproblems we chose for a solution to a given problem. By storing in sŒi;j􏳩 the index of the matrix at which we split the product AiAiC1 􏳵􏳵􏳵Aj, we can reconstruct each choice in O.1/ time.
Memoization
As we saw for the rod-cutting problem, there is an alternative approach to dy- namic programming that often offers the efficiency of the bottom-up dynamic- programming approach while maintaining a top-down strategy. The idea is to memoize the natural, but inefficient, recursive algorithm. As in the bottom-up ap- proach, we maintain a table with subproblem solutions, but the control structure for filling in the table is more like the recursive algorithm.
A memoized recursive algorithm maintains an entry in a table for the solution to each subproblem. Each table entry initially contains a special value to indicate that the entry has yet to be filled in. When the subproblem is first encountered as the recursive algorithm unfolds, its solution is computed and then stored in the table. Each subsequent time that we encounter this subproblem, we simply look up the value stored in the table and return it.5
Here is a memoized version of RECURSIVE-MATRIX-CHAIN. Note where it resembles the memoized top-down method for the rod-cutting problem.
5This approach presupposes that we know the set of all possible subproblem parameters and that we have established the relationship between table positions and subproblems. Another, more general, approach is to memoize by using hashing with the subproblem parameters as keys.

388 Chapter 15 Dynamic Programming
MEMOIZED-MATRIX-CHAIN.p/
1 2 3 4 5 6
1 2 3 4 5 6
7 8 9
nDp:length􏳣1
let mŒ1::n;1::n􏳩 be a new table foriD1ton
for j D i to n mŒi;j􏳩 D 1
return LOOKUP-CHAIN.m; p; 1; n/ LOOKUP-CHAIN.m; p; i; j /
ifmŒi;j􏳩<1 return mŒi; j 􏳩 ifi==j mŒi;j􏳩 D 0 elseforkDitoj􏳣1 q D LOOKUP-CHAIN.m;p;i;k/ C LOOKUP-CHAIN.m;p;k C 1;j/ C pi􏳣1pkpj if q < mŒi; j 􏳩 mŒi;j􏳩 D q return mŒi; j 􏳩 The MEMOIZED-MATRIX-CHAIN procedure, like MATRIX-CHAIN-ORDER, maintains a table mŒ1 : : n; 1 : : n􏳩 of computed values of mŒi; j 􏳩, the minimum num- ber of scalar multiplications needed to compute the matrix Ai ::j . Each table entry initially contains the value 1 to indicate that the entry has yet to be filled in. Upon calling LOOKUP-CHAIN.m; p; i; j /, if line 1 finds that mŒi; j 􏳩 < 1, then the pro- cedure simply returns the previously computed cost mŒi; j 􏳩 in line 2. Otherwise, the cost is computed as in RECURSIVE-MATRIX-CHAIN, stored in mŒi; j 􏳩, and returned. Thus, LOOKUP-CHAIN.m;p;i;j/ always returns the value of mŒi;j􏳩, but it computes it only upon the first call of LOOKUP-CHAIN with these specific values of i and j . Figure 15.7 illustrates how MEMOIZED-MATRIX-CHAIN saves time compared with RECURSIVE-MATRIX-CHAIN. Shaded subtrees represent values that it looks up rather than recomputes. Like the bottom-up dynamic-programming algorithm MATRIX-CHAIN-ORDER, the procedure MEMOIZED-MATRIX-CHAIN runs in O.n3/ time. Line 5 of MEMOIZED-MATRIX-CHAIN executes ‚.n2/ times. We can categorize the calls of LOOKUP-CHAIN into two types: 1. calls in which mŒi; j 􏳩 D 1, so that lines 3–9 execute, and 2. calls in which mŒi;j􏳩 < 1, so that LOOKUP-CHAIN simply returns in line 2. 15.3 Elements of dynamic programming 389 There are ‚.n2/ calls of the first type, one per table entry. All calls of the sec- ond type are made as recursive calls by calls of the first type. Whenever a given call of LOOKUP-CHAIN makes recursive calls, it makes O.n/ of them. There- fore, there are O.n3/ calls of the second type in all. Each call of the second type takes O.1/ time, and each call of the first type takes O.n/ time plus the time spent in its recursive calls. The total time, therefore, is O.n3/. Memoization thus turns an 􏳫.2n/-time algorithm into an O.n3/-time algorithm. In summary, we can solve the matrix-chain multiplication problem by either a top-down, memoized dynamic-programming algorithm or a bottom-up dynamic- programming algorithm in O.n3/ time. Both methods take advantage of the overlapping-subproblems property. There are only ‚.n2/ distinct subproblems in total, and either of these methods computes the solution to each subproblem only once. Without memoization, the natural recursive algorithm runs in exponential time, since solved subproblems are repeatedly solved. In general practice, if all subproblems must be solved at least once, a bottom-up dynamic-programming algorithm usually outperforms the corresponding top-down memoized algorithm by a constant factor, because the bottom-up algorithm has no overhead for recursion and less overhead for maintaining the table. Moreover, for some problems we can exploit the regular pattern of table accesses in the dynamic- programming algorithm to reduce time or space requirements even further. Alter- natively, if some subproblems in the subproblem space need not be solved at all, the memoized solution has the advantage of solving only those subproblems that are definitely required. Exercises 15.3-1 Which is a more efficient way to determine the optimal number of multiplications in a matrix-chain multiplication problem: enumerating all the ways of parenthesiz- ing the product and computing the number of multiplications for each, or running RECURSIVE-MATRIX-CHAIN? Justify your answer. 15.3-2 Draw the recursion tree for the MERGE-SORT procedure from Section 2.3.1 on an array of 16 elements. Explain why memoization fails to speed up a good divide- and-conquer algorithm such as MERGE-SORT. 15.3-3 Consider a variant of the matrix-chain multiplication problem in which the goal is to parenthesize the sequence of matrices so as to maximize, rather than minimize, 390 Chapter 15 Dynamic Programming the number of scalar multiplications. Does this problem exhibit optimal substruc- ture? 15.3-4 As stated, in dynamic programming we first solve the subproblems and then choose which of them to use in an optimal solution to the problem. Professor Capulet claims that we do not always need to solve all the subproblems in order to find an optimal solution. She suggests that we can find an optimal solution to the matrix- chain multiplication problem by always choosing the matrix Ak at which to split the subproduct AiAiC1 􏳵􏳵􏳵Aj (by selecting k to minimize the quantity pi􏳣1pkpj) before solving the subproblems. Find an instance of the matrix-chain multiplica- tion problem for which this greedy approach yields a suboptimal solution. 15.3-5 Suppose that in the rod-cutting problem of Section 15.1, we also had limit li on the number of pieces of length i that we are allowed to produce, for i D 1;2;:::;n. Show that the optimal-substructure property described in Section 15.1 no longer holds. 15.3-6 Imagine that you wish to exchange one currency for another. You realize that instead of directly exchanging one currency for another, you might be better off making a series of trades through other currencies, winding up with the currency you want. Suppose that you can trade n different currencies, numbered 1; 2; : : : ; n, where you start with currency 1 and wish to wind up with currency n. You are given, for each pair of currencies i and j , an exchange rate rij , meaning that if you start with d units of currency i, you can trade for drij units of currency j. A sequence of trades may entail a commission, which depends on the number of trades you make. Let ck be the commission that you are charged when you make k trades.Showthat,ifck D0forallkD1;2;:::;n,thentheproblemoffindingthe best sequence of exchanges from currency 1 to currency n exhibits optimal sub- structure. Then show that if commissions ck are arbitrary values, then the problem of finding the best sequence of exchanges from currency 1 to currency n does not necessarily exhibit optimal substructure. 15.4 Longest common subsequence Biological applications often need to compare the DNA of two (or more) dif- ferent organisms. A strand of DNA consists of a string of molecules called 15.4 Longest common subsequence 391 bases, where the possible bases are adenine, guanine, cytosine, and thymine. Representing each of these bases by its initial letter, we can express a strand of DNA as a string over the finite set fA; C; G; Tg. (See Appendix C for the definition of a string.) For example, the DNA of one organism may be S1 D ACCGGTCGAGTGCGCGGAAGCCGGCCGAA, and the DNA of another organ- ism may be S2 D GTCGTTCGGAATGCCGTTGCTCTGTAAA. One reason to com- pare two strands of DNA is to determine how “similar” the two strands are, as some measure of how closely related the two organisms are. We can, and do, define sim- ilarity in many different ways. For example, we can say that two DNA strands are similar if one is a substring of the other. (Chapter 32 explores algorithms to solve this problem.) In our example, neither S1 nor S2 is a substring of the other. Alter- natively, we could say that two strands are similar if the number of changes needed to turn one into the other is small. (Problem 15-5 looks at this notion.) Yet another way to measure the similarity of strands S1 and S2 is by finding a third strand S3 in which the bases in S3 appear in each of S1 and S2; these bases must appear in the same order, but not necessarily consecutively. The longer the strand S3 we can find, the more similar S1 and S2 are. In our example, the longest strand S3 is GTCGTCGGAAGCCGGCCGAA. We formalize this last notion of similarity as the longest-common-subsequence problem. A subsequence of a given sequence is just the given sequence with zero or more elements left out. Formally, given a sequence X D hx1; x2; : : : ; xmi, another sequence Z D h ́1; ́2; :::; ́ki is a subsequence of X if there exists a strictly increasingsequencehi1;i2;:::;ikiofindicesofXsuchthatforallj D1;2;:::;k, we have xij D ́j. For example, Z D hB;C;D;Bi is a subsequence of X D hA; B; C; B; D; A; Bi with corresponding index sequence h2; 3; 5; 7i. Given two sequences X and Y , we say that a sequence Z is a common sub- sequence of X and Y if Z is a subsequence of both X and Y . For example, if X D hA;B;C;B;D;A;Bi and Y D hB;D;C;A;B;Ai, the sequence hB;C;Ai is a common subsequence of both X and Y . The sequence hB; C; Ai is not a longest common subsequence (LCS) of X and Y , however, since it has length 3 and the sequence hB; C; B; Ai, which is also common to both X and Y , has length 4. The sequence hB;C;B;Ai is an LCS of X and Y, as is the sequence hB;D;A;Bi, since X and Y have no common subsequence of length 5 or greater. In the longest-common-subsequence problem, we are given two sequences X D hx1; x2; :::; xmi and Y D hy1; y2; :::; yni and wish to find a maximum- length common subsequence of X and Y . This section shows how to efficiently solve the LCS problem using dynamic programming. 392 Chapter 15 Dynamic Programming Step 1: Characterizing a longest common subsequence In a brute-force approach to solving the LCS problem, we would enumerate all subsequences of X and check each subsequence to see whether it is also a subse- quence of Y , keeping track of the longest subsequence we find. Each subsequence of X corresponds to a subset of the indices f1;2;:::;mg of X. Because X has 2m subsequences, this approach requires exponential time, making it impractical for long sequences. The LCS problem has an optimal-substructure property, however, as the follow- ing theorem shows. As we shall see, the natural classes of subproblems corre- spond to pairs of “prefixes” of the two input sequences. To be precise, given a sequenceX Dhx1;x2;:::;xmi,wedefinetheithprefixofX,fori D0;1;:::;m, as Xi D hx1;x2;:::;xii. For example, if X D hA;B;C;B;D;A;Bi, then X4 D hA; B; C; Bi and X0 is the empty sequence. Theorem 15.1 (Optimal substructure of an LCS) Let X D hx1;x2;:::;xmi and Y D hy1;y2;:::;yni be sequences, and let Z D h ́1; ́2;:::; ́kibeanyLCSofX andY. 1. Ifxm Dyn,then ́k Dxm Dyn andZk􏳣1 isanLCSofXm􏳣1 andYn􏳣1. 2. Ifxm ¤yn,then ́k ¤xm impliesthatZisanLCSofXm􏳣1 andY. 3. Ifxm ¤yn,then ́k ¤yn impliesthatZisanLCSofXandYn􏳣1. Proof (1) If ́k ¤ xm, then we could append xm D yn to Z to obtain a common subsequence of X and Y of length k C 1, contradicting the supposition that Z is a longest common subsequence of X and Y . Thus, we must have ́k D xm D yn. Now, the prefix Zk􏳣1 is a length-.k 􏳣 1/ common subsequence of Xm􏳣1 and Yn􏳣1. We wish to show that it is an LCS. Suppose for the purpose of contradiction that there exists a common subsequence W of Xm􏳣1 and Yn􏳣1 with length greater than k 􏳣 1. Then, appending xm D yn to W produces a common subsequence of X and Y whose length is greater than k, which is a contradiction. (2) If ́k ¤ xm, then Z is a common subsequence of Xm􏳣1 and Y . If there were a common subsequence W of Xm􏳣1 and Y with length greater than k, then W would also be a common subsequence of Xm and Y , contradicting the assumption that Z isanLCSofX andY. (3) The proof is symmetric to (2). The way that Theorem 15.1 characterizes longest common subsequences tells us that an LCS of two sequences contains within it an LCS of prefixes of the two sequences. Thus, the LCS problem has an optimal-substructure property. A recur- 15.4 Longest common subsequence 393 sive solution also has the overlapping-subproblems property, as we shall see in a moment. Step 2: A recursive solution Theorem 15.1 implies that we should examine either one or two subproblems when finding an LCS of X D hx1;x2;:::;xmi and Y D hy1;y2;:::;yni. If xm D yn, we must find an LCS of Xm􏳣1 and Yn􏳣1. Appending xm D yn to this LCS yields an LCS of X and Y . If xm ¤ yn, then we must solve two subproblems: finding an LCS of Xm􏳣1 and Y and finding an LCS of X and Yn􏳣1. Whichever of these two LCSs is longer is an LCS of X and Y . Because these cases exhaust all possibilities, we know that one of the optimal subproblem solutions must appear within an LCS of X and Y . We can readily see the overlapping-subproblems property in the LCS problem. TofindanLCSofXandY,wemayneedtofindtheLCSsofXandYn􏳣1 and of Xm􏳣1 and Y . But each of these subproblems has the subsubproblem of finding an LCS of Xm􏳣1 and Yn􏳣1. Many other subproblems share subsubproblems. As in the matrix-chain multiplication problem, our recursive solution to the LCS problem involves establishing a recurrence for the value of an optimal solution. Let us define cŒi;j􏳩 to be the length of an LCS of the sequences Xi and Yj. If either i D 0 or j D 0, one of the sequences has length 0, and so the LCS has length 0. T􏳾he optimal substructure of the LCS problem gives the recursive formula 0 if i D 0 or j D 0 ; cŒi;j􏳩D cŒi􏳣1;j􏳣1􏳩C1 ifi;j>0andxi Dyj ; (15.9)
max.cŒi;j􏳣1􏳩;cŒi􏳣1;j􏳩/ ifi;j>0andxi ¤yj :
Observe that in this recursive formulation, a condition in the problem restricts which subproblems we may consider. When xi D yj , we can and should consider the subproblem of finding an LCS of Xi􏳣1 and Yj􏳣1. Otherwise, we instead con- sider the two subproblems of finding an LCS of Xi and Yj 􏳣1 and of Xi 􏳣1 and Yj . In the previous dynamic-programming algorithms we have examined—for rod cutting and matrix-chain multiplication—we ruled out no subproblems due to conditions in the problem. Finding an LCS is not the only dynamic-programming algorithm that rules out subproblems based on conditions in the problem. For example, the edit-distance problem (see Problem 15-5) has this characteristic.
Step 3: Computing the length of an LCS
Based on equation (15.9), we could easily write an exponential-time recursive al- gorithm to compute the length of an LCS of two sequences. Since the LCS problem

394 Chapter 15 Dynamic Programming
has only ‚.mn/ distinct subproblems, however, we can use dynamic programming to compute the solutions bottom up.
Procedure LCS-LENGTH takes two sequences X D hx1; x2; : : : ; xmi and Y Dhy1;y2;:::;yniasinputs. ItstoresthecŒi;j􏳩valuesinatablecŒ0::m;0::n􏳩, and it computes the entries in row-major order. (That is, the procedure fills in the first row of c from left to right, then the second row, and so on.) The procedure also maintains the table bŒ1 : : m; 1 : : n􏳩 to help us construct an optimal solution. Intu- itively, bŒi;j􏳩 points to the table entry corresponding to the optimal subproblem solution chosen when computing cŒi; j 􏳩. The procedure returns the b and c tables; cŒm; n􏳩 contains the length of an LCS of X and Y .
LCS-LENGTH.X; Y /
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
m D X: length
n D Y: length
let bŒ1::m;1::n􏳩 and cŒ0::m;0::n􏳩 be new tables foriD1tom
cŒi;0􏳩 D 0 forjD0ton
cŒ0;j􏳩 D 0 foriD1tom
for j D 1 to n ifxi ==yj
cŒi;j􏳩 D cŒi 􏳣1;j 􏳣1􏳩C1
bŒi;j􏳩 D “-”
elseif cŒi 􏳣 1; j 􏳩 􏳦 cŒi; j 􏳣 1􏳩
cŒi;j􏳩 D cŒi 􏳣1;j􏳩
bŒi;j􏳩 D “””
else cŒi;j􏳩 D cŒi;j 􏳣1􏳩
bŒi;j􏳩D“ ” return c and b
Figure 15.8 shows the tables produced by LCS-LENGTH on the sequences X D hA;B;C;B;D;A;Bi and Y D hB;D;C;A;B;Ai. The running time of the procedure is ‚.mn/, since each table entry takes ‚.1/ time to compute.
Step 4: Constructing an LCS
The b table returned by LCS-LENGTH enables us to quickly construct an LCS of X D hx1;x2;:::;xmi and Y D hy1;y2;:::;yni. We simply begin at bŒm;n􏳩 and trace through the table by following the arrows. Whenever we encounter a “-” in entry bŒi;j􏳩, it implies that xi D yj is an element of the LCS that LCS-LENGTH

15.4 Longest common subsequence 395
j0123456 yj B D C A B A
i
0 xi 1A 2B 3C 4B 5D 6A 7B
0
0
0
0
0
0
0
0
0
0
0
1
1
1
0
1
1
1
1
2
2
0
1
1
2
2
2
2
0
1
1
2
2
3
3
0
1
2
2
2
3
3
0
1
2
2
3
3
4
0
1
2
2
3
4
4
The c and b tables computed by LCS-LENGTH on the sequences X D hA; B; C; B; D;A;BiandY DhB;D;C;A;B;Ai.ThesquareinrowiandcolumnjcontainsthevalueofcŒi;j􏳩 and the appropriate arrow for the value of bŒi; j 􏳩. The entry 4 in cŒ7; 6􏳩—the lower right-hand corner of the table—is the length of an LCS hB;C;B;Ai of X and Y. For i;j > 0, entry cŒi;j􏳩 depends onlyonwhetherxi Dyj andthevaluesinentriescŒi􏳣1;j􏳩,cŒi;j􏳣1􏳩,andcŒi􏳣1;j􏳣1􏳩,which are computed before cŒi; j 􏳩. To reconstruct the elements of an LCS, follow the bŒi; j 􏳩 arrows from the lower right-hand corner; the sequence is shaded. Each “-” on the shaded sequence corresponds to an entry (highlighted) for which xi D yj is a member of an LCS.
found. With this method, we encounter the elements of this LCS in reverse order. The following recursive procedure prints out an LCS of X and Y in the proper, forward order. The initial call is PRINT-LCS.b; X; X:length; Y:length/.
PRINT-LCS.b; X; i; j /
Figure 15.8
1 2 3 4 5 6 7 8
ifi ==0orj ==0 return
if bŒi;j􏳩 == “-” PRINT-LCS.b;X;i 􏳣1;j 􏳣1/ print xi
elseif bŒi; j 􏳩 == “”” PRINT-LCS.b;X;i 􏳣1;j/
else PRINT-LCS.b; X; i; j 􏳣 1/
For the b table in Figure 15.8, this procedure prints BCBA. The procedure takes time O.m C n/, since it decrements at least one of i and j in each recursive call.

396 Chapter 15 Dynamic Programming
Improving the code
Once you have developed an algorithm, you will often find that you can improve on the time or space it uses. Some changes can simplify the code and improve constant factors but otherwise yield no asymptotic improvement in performance. Others can yield substantial asymptotic savings in time and space.
In the LCS algorithm, for example, we can eliminate the b table altogether. Each cŒi; j 􏳩 entry depends on only three other c table entries: cŒi 􏳣 1; j 􏳣 1􏳩, cŒi 􏳣 1; j 􏳩, and cŒi; j 􏳣 1􏳩. Given the value of cŒi; j 􏳩, we can determine in O.1/ time which of these three values was used to compute cŒi; j 􏳩, without inspecting table b. Thus, we can reconstruct an LCS in O.mCn/ time using a procedure similar to PRINT-LCS. (Exercise 15.4-2 asks you to give the pseudocode.) Although we save ‚.mn/ space by this method, the auxiliary space requirement for computing an LCS does not asymptotically decrease, since we need ‚.mn/ space for the c table anyway.
We can, however, reduce the asymptotic space requirements for LCS-LENGTH, since it needs only two rows of table c at a time: the row being computed and the previous row. (In fact, as Exercise 15.4-4 asks you to show, we can use only slightly more than the space for one row of c to compute the length of an LCS.) This improvement works if we need only the length of an LCS; if we need to reconstruct the elements of an LCS, the smaller table does not keep enough information to retrace our steps in O.m C n/ time.
Exercises
15.4-1
Determine an LCS of h1;0;0;1;0;1;0;1i and h0;1;0;1;1;0;1;1;0i.
15.4-2
Give pseudocode to reconstruct an LCS from the completed c table and the original sequences X D hx1; x2; :::; xmi and Y D hy1; y2; :::; yni in O.m C n/ time, without using the b table.
15.4-3
Give a memoized version of LCS-LENGTH that runs in O.mn/ time.
15.4-4
Show how to compute the length of an LCS using only 2 􏳵 min.m; n/ entries in the c table plus O.1/ additional space. Then show how to do the same thing, but using min.m; n/ entries plus O.1/ additional space.

15.5 Optimal binary search trees 397
15.4-5
Give an O.n2/-time algorithm to find the longest monotonically increasing subse- quence of a sequence of n numbers.
15.4-6 ?
Give an O.n lg n/-time algorithm to find the longest monotonically increasing sub- sequence of a sequence of n numbers. (Hint: Observe that the last element of a candidate subsequence of length i is at least as large as the last element of a can- didate subsequence of length i 􏳣 1. Maintain candidate subsequences by linking them through the input sequence.)
15.5 Optimal binary search trees
Suppose that we are designing a program to translate text from English to French. For each occurrence of each English word in the text, we need to look up its French equivalent. We could perform these lookup operations by building a binary search tree with n English words as keys and their French equivalents as satellite data. Because we will search the tree for each individual word in the text, we want the total time spent searching to be as low as possible. We could ensure an O.lg n/ search time per occurrence by using a red-black tree or any other balanced binary search tree. Words appear with different frequencies, however, and a frequently used word such as the may appear far from the root while a rarely used word such as machicolation appears near the root. Such an organization would slow down the translation, since the number of nodes visited when searching for a key in a binary search tree equals one plus the depth of the node containing the key. We want words that occur frequently in the text to be placed nearer the root.6 Moreover, some words in the text might have no French translation,7 and such words would not appear in the binary search tree at all. How do we organize a binary search tree so as to minimize the number of nodes visited in all searches, given that we know how often each word occurs?
What we need is known as an optimal binary search tree. Formally, we are given a sequence K D hk1; k2; : : : ; kni of n distinct keys in sorted order (so that k1 < k2 < 􏳵􏳵􏳵 < kn), and we wish to build a binary search tree from these keys. For each key ki , we have a probability pi that a search will be for ki . Some searches may be for values not in K, and so we also have n C 1 “dummy keys” 6If the subject of the text is castle architecture, we might want machicolation to appear near the root. 7Yes, machicolation has a French counterpart: maˆchicoulis. 398 Chapter 15 Dynamic Programming k2 k2 k1k4 k1k5 d0 d1 k3 k5 d2 d3 d4 d5 (a) d0 d1 k4 d5 k3 d4 Figure 15.9 Two binary search trees for a set of n D 5 keys with the following probabilities: i012345 pi 0.15 0.10 0.05 0.10 0.20 qi 0.05 0.10 0.05 0.05 0.05 0.10 (a) A binary search tree with expected search cost 2.80. (b) A binary search tree with expected search cost 2.75. This tree is optimal. d0 ; d1 ; d2 ; : : : ; dn representing values not in K . In particular, d0 represents all val- ues less than k1, dn represents all values greater than kn, and for i D 1; 2; : : : ; n􏳣1, the dummy key di represents all values between ki and kiC1. For each dummy key di , we have a probability qi that a search will correspond to di . Figure 15.9 shows two binary search trees for a set of n D 5 keys. Each key ki is an internal node, and each dummy key di is a leaf. Every search is either successful (finding some key ki ) or unsuccessful (finding some dummy key di ), and so we have d2 d3 (b) Xn iD1 pi C Xn iD0 qi D 1 : (15.10) Because we have probabilities of searches for each key and each dummy key, we can determine the expected cost of a search in a given binary search tree T . Let us assume that the actual cost of a search equals the number of nodes examined, i.e., the depth of the node found by the search in T , plus 1. Then the expected cost of a search in T is Xn .depthT.ki/C1/􏳵pi C .depthT.di/C1/􏳵qi EŒsearchcostinT􏳩 D D 1C Xn iD1 depthT.ki/􏳵pi C iD0 Xn depthT.di/􏳵qi ; (15.11) Xn iD1 iD0 15.5 Optimal binary search trees 399 where depthT denotes a node’s depth in the tree T . The last equality follows from equation (15.10). In Figure 15.9(a), we can calculate the expected search cost node by node: node depth probability k1 1 0.15 0.30 k2 0 0.10 0.10 k3 2 0.05 0.15 k4 1 0.10 0.20 k5 2 0.20 0.60 d0 2 0.05 0.15 d1 2 0.10 0.30 d2 3 0.05 0.20 d3 3 0.05 0.20 d4 3 0.05 0.20 d5 3 0.10 0.40 contribution Total 2.80 For a given set of probabilities, we wish to construct a binary search tree whose expected search cost is smallest. We call such a tree an optimal binary search tree. Figure 15.9(b) shows an optimal binary search tree for the probabilities given in the figure caption; its expected cost is 2.75. This example shows that an optimal binary search tree is not necessarily a tree whose overall height is smallest. Nor can we necessarily construct an optimal binary search tree by always putting the key with the greatest probability at the root. Here, key k5 has the greatest search probability of any key, yet the root of the optimal binary search tree shown is k2. (The lowest expected cost of any binary search tree with k5 at the root is 2.85.) As with matrix-chain multiplication, exhaustive checking of all possibilities fails to yield an efficient algorithm. We can label the nodes of any n-node binary tree with the keys k1; k2; : : : ; kn to construct a binary search tree, and then add in the dummy keys as leaves. In Problem 12-4, we saw that the number of binary trees with n nodes is 􏳫.4n=n3=2/, and so we would have to examine an exponential number of binary search trees in an exhaustive search. Not surprisingly, we shall solve this problem with dynamic programming. Step 1: The structure of an optimal binary search tree To characterize the optimal substructure of optimal binary search trees, we start with an observation about subtrees. Consider any subtree of a binary search tree. It must contain keys in a contiguous range ki;:::;kj, for some 1 􏳥 i 􏳥 j 􏳥 n. Inaddition,asubtreethatcontainskeyski;:::;kj mustalsohaveasitsleavesthe dummy keys di􏳣1;:::;dj . Now we can state the optimal substructure: if an optimal binary search tree T hasasubtreeT0 containingkeyski;:::;kj,thenthissubtreeT0 mustbeoptimalas 400 Chapter 15 Dynamic Programming well for the subproblem with keys ki;:::;kj and dummy keys di􏳣1;:::;dj. The usual cut-and-paste argument applies. If there were a subtree T 00 whose expected cost is lower than that of T0, then we could cut T0 out of T and paste in T00, resulting in a binary search tree of lower expected cost than T , thus contradicting the optimality of T . We need to use the optimal substructure to show that we can construct an opti- mal solution to the problem from optimal solutions to subproblems. Given keys ki;:::;kj, one of these keys, say kr (i 􏳥 r 􏳥 j), is the root of an optimal subtree containing these keys. The left subtree of the root kr contains the keys ki;:::;kr􏳣1 (and dummy keys di􏳣1;:::;dr􏳣1), and the right subtree contains the keys krC1;:::;kj (and dummy keys dr;:::;dj ). As long as we examine all candi- date roots kr , where i 􏳥 r 􏳥 j , and we determine all optimal binary search trees containingki;:::;kr􏳣1 andthosecontainingkrC1;:::;kj,weareguaranteedthat we will find an optimal binary search tree. There is one detail worth noting about “empty” subtrees. Suppose that in a subtreewithkeyski;:::;kj,weselectki astheroot.Bytheaboveargument,ki’s left subtree contains the keys ki ; : : : ; ki 􏳣1 . We interpret this sequence as containing no keys. Bear in mind, however, that subtrees also contain dummy keys. We adopt the convention that a subtree containing keys ki ; : : : ; ki 􏳣1 has no actual keys but doescontainthesingledummykeydi􏳣1.Symmetrically,ifweselectkj astheroot, then kj ’s right subtree contains the keys kj C1; : : : ; kj ; this right subtree contains no actual keys, but it does contain the dummy key dj . Step 2: A recursive solution We are ready to define the value of an optimal solution recursively. We pick our subproblem domain as finding an optimal binary search tree containing the keys ki ; : : : ; kj , where i 􏳦 1, j 􏳥 n, and j 􏳦 i 􏳣 1. (When j D i 􏳣 1, there are no actual keys; we have just the dummy key di􏳣1.) Let us define eŒi;j􏳩 as the expected cost of searching an optimal binary search tree containing the keys ki ; : : : ; kj . Ultimately, we wish to compute eŒ1; n􏳩. The easy case occurs when j D i 􏳣 1. Then we have just the dummy key di􏳣1. The expected search cost is eŒi;i 􏳣 1􏳩 D qi􏳣1. Whenj 􏳦i,weneedtoselectarootkr fromamongki;:::;kj andthenmakean optimal binary search tree with keys ki ; : : : ; kr 􏳣1 as its left subtree and an optimal binarysearchtreewithkeyskrC1;:::;kj asitsrightsubtree.Whathappenstothe expected search cost of a subtree when it becomes a subtree of a node? The depth of each node in the subtree increases by 1. By equation (15.11), the expected search cost of this subtree increases by the sum of all the probabilities in the subtree. For a subtree with keys ki ; : : : ; kj , let us denote this sum of probabilities as 15.5 Optimal binary search trees 401 Xj w.i;j/D Xj lDi􏳣1 eŒi;j􏳩Dpr C.eŒi;r􏳣1􏳩Cw.i;r􏳣1//C.eŒrC1;j􏳩Cw.rC1;j//: Noting that w.i;j/Dw.i;r􏳣1/Cpr Cw.rC1;j/; we rewrite eŒi; j 􏳩 as eŒi;j􏳩 D eŒi;r 􏳣 1􏳩 C eŒr C 1;j􏳩 C w.i;j/ : (15.13) The recursive equation (15.13) assumes that we know which node kr to use as the root. We choose the root that gives the lowest expected search cost, giving us our final recursive formulation: ( i􏳥r􏳥j eŒi;j􏳩D qi􏳣1 if j D i 􏳣 1 ; min feŒi;r􏳣1􏳩CeŒrC1;j􏳩Cw.i;j/g ifi 􏳥j : (15.14) pl C ql : (15.12) lDi Thus,ifkr istherootofanoptimalsubtreecontainingkeyski;:::;kj,wehave The eŒi; j 􏳩 values give the expected search costs in optimal binary search trees. To help us keep track of the structure of optimal binary search trees, we define rootŒi;j􏳩,for1􏳥i􏳥j􏳥n,tobetheindexrforwhichkr istherootofan optimal binary search tree containing keys ki ; : : : ; kj . Although we will see how to compute the values of rootŒi; j 􏳩, we leave the construction of an optimal binary search tree from these values as Exercise 15.5-1. Step 3: Computing the expected search cost of an optimal binary search tree At this point, you may have noticed some similarities between our characterizations of optimal binary search trees and matrix-chain multiplication. For both problem domains, our subproblems consist of contiguous index subranges. A direct, recur- sive implementation of equation (15.14) would be as inefficient as a direct, recur- sive matrix-chain multiplication algorithm. Instead, we store the eŒi; j 􏳩 values in a tableeŒ1::nC1;0::n􏳩. ThefirstindexneedstoruntonC1ratherthannbecause in order to have a subtree containing only the dummy key dn, we need to compute and store eŒn C 1; n􏳩. The second index needs to start from 0 because in order to have a subtree containing only the dummy key d0, we need to compute and store eŒ1;0􏳩. We use only the entries eŒi;j􏳩 for which j 􏳦 i 􏳣 1. We also use a table rootŒi; j 􏳩, for recording the root of the subtree containing keys ki ; : : : ; kj . This table uses only the entries for which 1 􏳥 i 􏳥 j 􏳥 n. We will need one other table for efficiency. Rather than compute the value of w.i;j/ from scratch every time we are computing eŒi;j􏳩—which would take 402 Chapter 15 Dynamic Programming ‚.j 􏳣 i/ additions—we store these values in a table wŒ1 : : n C 1; 0 : : n􏳩. For the base case, we compute wŒi;i 􏳣 1􏳩 D qi􏳣1 for 1 􏳥 i 􏳥 n C 1. For j 􏳦 i, we compute wŒi;j􏳩DwŒi;j􏳣1􏳩Cpj Cqj : (15.15) Thus, we can compute the ‚.n2/ values of wŒi; j 􏳩 in ‚.1/ time each. The pseudocode that follows takes as inputs the probabilities p1; : : : ; pn and q0;:::;qn and the size n, and it returns the tables e and root. OPTIMAL-BST.p; q; n/ leteŒ1::nC1;0::n􏳩,wŒ1::nC1;0::n􏳩, and rootŒ1::n;1::n􏳩 be new tables foriD1tonC1 eŒi;i 􏳣1􏳩 D qi􏳣1 wŒi;i 􏳣1􏳩 D qi􏳣1 forlD1ton for i D 1 to n 􏳣 l C 1 jDiCl􏳣1 eŒi;j􏳩 D 1 wŒi;j􏳩 D wŒi;j 􏳣1􏳩Cpj Cqj for r D i to j t D eŒi;r 􏳣1􏳩CeŒr C1;j􏳩CwŒi;j􏳩 if t < eŒi;j􏳩 eŒi;j􏳩 D t rootŒi;j􏳩 D r return e and root From the description above and the similarity to the MATRIX-CHAIN-ORDER pro- cedure in Section 15.2, you should find the operation of this procedure to be fairly straightforward. The for loop of lines 2–4 initializes the values of eŒi; i 􏳣 1􏳩 and wŒi; i 􏳣 1􏳩. The for loop of lines 5–14 then uses the recurrences (15.14) and (15.15) to compute eŒi;j􏳩 and wŒi;j􏳩 for all 1 􏳥 i 􏳥 j 􏳥 n. In the first itera- tion,whenl D1,theloopcomputeseŒi;i􏳩andwŒi;i􏳩fori D1;2;:::;n. Thesec- onditeration,withl D2,computeseŒi;iC1􏳩andwŒi;iC1􏳩fori D1;2;:::;n􏳣1, and so forth. The innermost for loop, in lines 10–14, tries each candidate index r to determine which key kr to use as the root of an optimal binary search tree con- taining keys ki ; : : : ; kj . This for loop saves the current value of the index r in rootŒi; j 􏳩 whenever it finds a better key to use as the root. Figure 15.10 shows the tables eŒi;j􏳩, wŒi;j􏳩, and rootŒi;j􏳩 computed by the procedure OPTIMAL-BST on the key distribution shown in Figure 15.9. As in the matrix-chain multiplication example of Figure 15.5, the tables are rotated to make 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 15.5 Optimal binary search trees 403 ew jiji root ji Figure 15.10 The tables eŒi;j􏳩, wŒi;j􏳩, and rootŒi;j􏳩 computed by OPTIMAL-BST on the key distribution shown in Figure 15.9. The tables are rotated so that the diagonals run horizontally. the diagonals run horizontally. OPTIMAL-BST computes the rows from bottom to top and from left to right within each row. The OPTIMAL-BST procedure takes ‚.n3/ time, just like MATRIX-CHAIN- ORDER. We can easily see that its running time is O.n3/, since its for loops are nested three deep and each loop index takes on at most n values. The loop indices in OPTIMAL-BST do not have exactly the same bounds as those in MATRIX-CHAIN- ORDER, but they are within at most 1 in all directions. Thus, like MATRIX-CHAIN- ORDER, the OPTIMAL-BST procedure takes 􏳫.n3/ time. Exercises 15.5-1 Write pseudocode for the procedure CONSTRUCT-OPTIMAL-BST.root/ which, given the table root, outputs the structure of an optimal binary search tree. For the example in Figure 15.10, your procedure should print out the structure 51 4 2.75 2 3 1.75 2.00 3 2 1.25 1.20 1.30 4 5 51 4 1.00 2 3 0.70 0.80 3 2 0.55 0.50 0.60 4 5 1 0.90 0.70 0.60 0.90 0.45 0.40 0.25 0.30 0.50 1 0.45 0.35 0.30 0.50 0.30 0.25 0.15 0.20 0.35 0 0.05 0.10 0.05 0.05 0.05 0.10 6 0 0.05 0.10 0.05 0.05 0.05 0.10 6 51 422 3243 22254 112455 12345 404 Chapter 15 Dynamic Programming Problems k2 is the root k1 is the left child of k2 d0 is the left child of k1 d1 is the right child of k1 k5 is the right child of k2 k4 is the left child of k5 k3 is the left child of k4 d2 is the left child of k3 d3 is the right child of k3 d4 is the right child of k4 d5 is the right child of k5 corresponding to the optimal binary search tree shown in Figure 15.9(b). 15.5-2 Determine the cost and structure of an optimal binary search tree for a set of n D 7 keys with the following probabilities: i01234567 pi 0.04 0.06 0.08 0.02 0.10 0.12 0.14 qi 0.06 0.06 0.06 0.06 0.05 0.05 0.05 0.05 15.5-3 Suppose that instead of maintaining the table wŒi;j􏳩, we computed the value of w.i;j/ directly from equation (15.12) in line 9 of OPTIMAL-BST and used this computed value in line 11. How would this change affect the asymptotic running time of OPTIMAL-BST? 15.5-4 ? Knuth [212] has shown that there are always roots of optimal subtrees such that rootŒi; j 􏳣 1􏳩 􏳥 rootŒi; j 􏳩 􏳥 rootŒi C 1; j 􏳩 for all 1 􏳥 i < j 􏳥 n. Use this fact to modify the OPTIMAL-BST procedure to run in ‚.n2/ time. 15-1 Longest simple path in a directed acyclic graph Suppose that we are given a directed acyclic graph G D .V;E/ with real- valued edge weights and two distinguished vertices s and t. Describe a dynamic- programming approach for finding a longest weighted simple path from s to t. What does the subproblem graph look like? What is the efficiency of your algo- rithm? Problems for Chapter 15 405 (a) (b) Figure 15.11 Seven points in the plane, shown on a unit grid. (a) The shortest closed tour, with length approximately 24:89. This tour is not bitonic. (b) The shortest bitonic tour for the same set of points. Its length is approximately 25:58. 15-2 Longest palindrome subsequence A palindrome is a nonempty string over some alphabet that reads the same for- ward and backward. Examples of palindromes are all strings of length 1, civic, racecar, and aibohphobia (fear of palindromes). Give an efficient algorithm to find the longest palindrome that is a subsequence of a given input string. For example, given the input character, your algorithm should return carac. What is the running time of your algorithm? 15-3 Bitonic euclidean traveling-salesman problem In the euclidean traveling-salesman problem, we are given a set of n points in the plane, and we wish to find the shortest closed tour that connects all n points. Figure 15.11(a) shows the solution to a 7-point problem. The general problem is NP-hard, and its solution is therefore believed to require more than polynomial time (see Chapter 34). J. L. Bentley has suggested that we simplify the problem by restricting our at- tention to bitonic tours, that is, tours that start at the leftmost point, go strictly rightward to the rightmost point, and then go strictly leftward back to the starting point. Figure 15.11(b) shows the shortest bitonic tour of the same 7 points. In this case, a polynomial-time algorithm is possible. Describe an O.n2/-time algorithm for determining an optimal bitonic tour. You may assume that no two points have the same x-coordinate and that all operations on real numbers take unit time. (Hint: Scan left to right, maintaining optimal pos- sibilities for the two parts of the tour.) 15-4 Printing neatly Consider the problem of neatly printing a paragraph with a monospaced font (all characters having the same width) on a printer. The input text is a sequence of n 406 Chapter 15 Dynamic Programming words of lengths l1 ; l2 ; : : : ; ln , measured in characters. We want to print this para- graph neatly on a number of lines that hold a maximum of M characters each. Our criterion of “neatness” is as follows. If a given line contains words i through j , where i 􏳥 j , and we leave exactly one space between words, the number of extra space characters at the end of the line is M 􏳣 j C i 􏳣 PjkDi lk, which must be nonnegative so that the words fit on the line. We wish to minimize the sum, over all lines except the last, of the cubes of the numbers of extra space characters at the ends of lines. Give a dynamic-programming algorithm to print a paragraph of n words neatly on a printer. Analyze the running time and space requirements of your algorithm. 15-5 Edit distance In order to transform one source string of text xŒ1 : : m􏳩 to a target string yŒ1 : : n􏳩, we can perform various transformation operations. Our goal is, given x and y, to produce a series of transformations that change x to y. We use an ar- ray ́—assumed to be large enough to hold all the characters it will need—to hold the intermediate results. Initially, ́ is empty, and at termination, we should have ́Œj 􏳩 D yŒj 􏳩 for j D 1; 2; : : : ; n. We maintain current indices i into x and j into ́, and the operations are allowed to alter ́ and these indices. Initially, i D j D 1. We are required to examine every character in x during the transformation, which means that at the end of the sequence of transformation operations, we must have i D m C 1. We may choose from among six transformation operations: Copy a character from x to ́ by setting ́Œj􏳩 D xŒi􏳩 and then incrementing both i and j . This operation examines xŒi􏳩. Replace a character from x by another character c, by setting ́Œj􏳩 D c, and then incrementing both i and j. This operation examines xŒi􏳩. Delete a character from x by incrementing i but leaving j alone. This operation examines xŒi􏳩. Insert the character c into ́ by setting ́Œj 􏳩 D c and then incrementing j , but leaving i alone. This operation examines no characters of x. Twiddle (i.e., exchange) the next two characters by copying them from x to ́ but in the opposite order; we do so by setting ́Œj􏳩 D xŒi C1􏳩 and ́Œj C1􏳩 D xŒi􏳩 and then setting i D i C 2 and j D j C 2. This operation examines xŒi􏳩 and xŒi C 1􏳩. Kill the remainder of x by setting i D m C 1. This operation examines all char- acters in x that have not yet been examined. This operation, if performed, must be the final operation. Problems for Chapter 15 407 As an example, one way to transform the source string algorithm to the target string altruistic is to use the following sequence of operations, where the underlined characters are xŒi􏳩 and ́Œj􏳩 after the operation: x ́ algorithm algorithm a algorithm al Operation initial strings copy copy replace by t delete copy insert u insert i insert s twiddle insert c kill Note that there are several other sequences of transformation operations that trans- form algorithm to altruistic. Each of the transformation operations has an associated cost. The cost of an operation depends on the specific application, but we assume that each operation’s cost is a constant that is known to us. We also assume that the individual costs of the copy and replace operations are less than the combined costs of the delete and insert operations; otherwise, the copy and replace operations would not be used. The cost of a given sequence of transformation operations is the sum of the costs of the individual operations in the sequence. For the sequence above, the cost of transforming algorithm to altruistic is .3 􏳵 cost.copy// C cost.replace/ C cost.delete/ C .4 􏳵 cost.insert// C cost.twiddle/ C cost.kill/ : a. GiventwosequencesxŒ1::m􏳩andyŒ1::n􏳩andsetoftransformation-operation costs, the edit distance from x to y is the cost of the least expensive operation sequence that transforms x to y. Describe a dynamic-programming algorithm that finds the edit distance from xŒ1 : : m􏳩 to yŒ1 : : n􏳩 and prints an optimal op- eration sequence. Analyze the running time and space requirements of your algorithm. The edit-distance problem generalizes the problem of aligning two DNA sequences (see, for example, Setubal and Meidanis [310, Section 3.2]). There are several methods for measuring the similarity of two DNA sequences by aligning them. One such method to align two sequences x and y consists of inserting spaces at algo algor algori rithm alt ithm alt thm altr algori algori thm altru thm altrui m altruisti algori algorith thm altruis m altruistic algorith algorithm altruistic 408 Chapter 15 Dynamic Programming arbitrary locations in the two sequences (including at either end) so that the result- ing sequences x0 and y0 have the same length but do not have a space in the same position (i.e., for no position j are both x0Œj 􏳩 and y0Œj 􏳩 a space). Then we assign a “score” to each position. Position j receives a score as follows: C1 if x0Œj 􏳩 D y0Œj 􏳩 and neither is a space, 􏳣1 if x0Œj 􏳩 ¤ y0Œj 􏳩 and neither is a space, 􏳣2 if either x0Œj 􏳩 or y0Œj 􏳩 is a space. The score for the alignment is the sum of the scores of the individual positions. For example, given the sequences x D GATCGGCAT and y D CAATGTGAATC, one alignment is G ATCG GCAT CAAT GTGAATC -*++*+*+-++* A + under a position indicates a score of C1 for that position, a - indicates a score of 􏳣1, and a * indicates a score of 􏳣2, so that this alignment has a total score of 6 􏳵 1 􏳣 2 􏳵 1 􏳣 4 􏳵 2 D 􏳣4. b. Explain how to cast the problem of finding an optimal alignment as an edit distance problem using a subset of the transformation operations copy, replace, delete, insert, twiddle, and kill. 15-6 Planning a company party Professor Stewart is consulting for the president of a corporation that is planning a company party. The company has a hierarchical structure; that is, the supervisor relation forms a tree rooted at the president. The personnel office has ranked each employee with a conviviality rating, which is a real number. In order to make the party fun for all attendees, the president does not want both an employee and his or her immediate supervisor to attend. Professor Stewart is given the tree that describes the structure of the corporation, using the left-child, right-sibling representation described in Section 10.4. Each node of the tree holds, in addition to the pointers, the name of an employee and that employee’s conviviality ranking. Describe an algorithm to make up a guest list that maximizes the sum of the conviviality ratings of the guests. Analyze the running time of your algorithm. 15-7 Viterbi algorithm We can use dynamic programming on a directed graph G D .V;E/ for speech recognition. Each edge .u;􏳪/ 2 E is labeled with a sound 􏳯.u;􏳪/ from a fi- nite set † of sounds. The labeled graph is a formal model of a person speaking 􏳮 􏳮 􏳮 Problems for Chapter 15 409 a restricted language. Each path in the graph starting from a distinguished ver- tex 􏳪0 2 V corresponds to a possible sequence of sounds produced by the model. We define the label of a directed path to be the concatenation of the labels of the edges on that path. a. Describe an efficient algorithm that, given an edge-labeled graph G with dis- tinguished vertex 􏳪0 and a sequence s D h􏳯1; 􏳯2; : : : ; 􏳯k i of sounds from †, returns a path in G that begins at 􏳪0 and has s as its label, if any such path exists. Otherwise, the algorithm should return NO-SUCH-PATH. Analyze the running time of your algorithm. (Hint: You may find concepts from Chapter 22 useful.) Now, suppose that every edge .u;􏳪/ 2 E has an associated nonnegative proba- bility p.u;􏳪/ of traversing the edge .u;􏳪/ from vertex u and thus producing the corresponding sound. The sum of the probabilities of the edges leaving any vertex equals 1. The probability of a path is defined to be the product of the probabil- ities of its edges. We can view the probability of a path beginning at 􏳪0 as the probability that a “random walk” beginning at 􏳪0 will follow the specified path, where we randomly choose which edge to take leaving a vertex u according to the probabilities of the available edges leaving u. b. Extend your answer to part (a) so that if a path is returned, it is a most prob- able path starting at 􏳪0 and having label s. Analyze the running time of your algorithm. 15-8 Image compression by seam carving We are given a color picture consisting of an m􏳨n array AŒ1::m;1::n􏳩 of pixels, where each pixel specifies a triple of red, green, and blue (RGB) intensities. Sup- pose that we wish to compress this picture slightly. Specifically, we wish to remove one pixel from each of the m rows, so that the whole picture becomes one pixel narrower. To avoid disturbing visual effects, however, we require that the pixels removed in two adjacent rows be in the same or adjacent columns; the pixels re- moved form a “seam” from the top row to the bottom row where successive pixels in the seam are adjacent vertically or diagonally. a. Showthatthenumberofsuchpossibleseamsgrowsatleastexponentiallyinm, assuming that n > 1.
b. Suppose now that along with each pixel AŒi;j􏳩, we have calculated a real- valued disruption measure dŒi;j􏳩, indicating how disruptive it would be to remove pixel AŒi;j􏳩. Intuitively, the lower a pixel’s disruption measure, the more similar the pixel is to its neighbors. Suppose further that we define the disruption measure of a seam to be the sum of the disruption measures of its pixels.

410 Chapter 15 Dynamic Programming
Give an algorithm to find a seam with the lowest disruption measure. How efficient is your algorithm?
15-9 Breaking a string
A certain string-processing language allows a programmer to break a string into two pieces. Because this operation copies the string, it costs n time units to break a string of n characters into two pieces. Suppose a programmer wants to break a string into many pieces. The order in which the breaks occur can affect the total amount of time used. For example, suppose that the programmer wants to break a 20-character string after characters 2, 8, and 10 (numbering the characters in ascending order from the left-hand end, starting from 1). If she programs the breaks to occur in left-to-right order, then the first break costs 20 time units, the second break costs 18 time units (breaking the string from characters 3 to 20 at character 8), and the third break costs 12 time units, totaling 50 time units. If she programs the breaks to occur in right-to-left order, however, then the first break costs 20 time units, the second break costs 10 time units, and the third break costs 8 time units, totaling 38 time units. In yet another order, she could break first at 8 (costing 20), then break the left piece at 2 (costing 8), and finally the right piece at 10 (costing 12), for a total cost of 40.
Design an algorithm that, given the numbers of characters after which to break, determines a least-cost way to sequence those breaks. More formally, given a string S with n characters and an array LŒ1 : : m􏳩 containing the break points, com- pute the lowest cost for a sequence of breaks, along with a sequence of breaks that achieves this cost.
15-10 Planning an investment strategy
Your knowledge of algorithms helps you obtain an exciting job with the Acme Computer Company, along with a $10,000 signing bonus. You decide to invest this money with the goal of maximizing your return at the end of 10 years. You decide to use the Amalgamated Investment Company to manage your investments. Amalgamated Investments requires you to observe the following rules. It offers n different investments, numbered 1 through n. In each year j , investment i provides a return rate of rij . In other words, if you invest d dollars in investment i in year j , then at the end of year j, you have drij dollars. The return rates are guaranteed, that is, you are given all the return rates for the next 10 years for each investment. You make investment decisions only once per year. At the end of each year, you can leave the money made in the previous year in the same investments, or you can shift money to other investments, by either shifting money between existing investments or moving money to a new investement. If you do not move your money between two consecutive years, you pay a fee of f1 dollars, whereas if you switch your money, you pay a fee of f2 dollars, where f2 > f1.

Problems for Chapter 15 411
a. The problem, as stated, allows you to invest your money in multiple investments in each year. Prove that there exists an optimal investment strategy that, in each year, puts all the money into a single investment. (Recall that an optimal investment strategy maximizes the amount of money after 10 years and is not concerned with any other objectives, such as minimizing risk.)
b. Prove that the problem of planning your optimal investment strategy exhibits optimal substructure.
c. Design an algorithm that plans your optimal investment strategy. What is the running time of your algorithm?
d. SupposethatAmalgamatedInvestmentsimposedtheadditionalrestrictionthat, at any point, you can have no more than $15,000 in any one investment. Show that the problem of maximizing your income at the end of 10 years no longer exhibits optimal substructure.
15-11 Inventory planning
The Rinky Dink Company makes machines that resurface ice rinks. The demand
for such products varies from month to month, and so the company needs to de-
velop a strategy to plan its manufacturing given the fluctuating, but predictable,
demand. The company wishes to design a plan for the next n months. For each
month i, the company knows the demand d , that is, the number of machines that Pn i
it will sell. Let D D iD1 di be the total demand over the next n months. The company keeps a full-time staff who provide labor to manufacture up to m ma- chines per month. If the company needs to make more than m machines in a given month, it can hire additional, part-time labor, at a cost that works out to c dollars per machine. Furthermore, if, at the end of a month, the company is holding any unsold machines, it must pay inventory costs. The cost for holding j machines is givenasafunctionh.j/forj D1;2;:::;D,whereh.j/􏳦0for1􏳥j 􏳥Dand h.j/􏳥h.j C1/for1􏳥j 􏳥D􏳣1.
Give an algorithm that calculates a plan for the company that minimizes its costs while fulfilling all the demand. The running time should be polyomial in n and D.
15-12 Signing free-agent baseball players
Suppose that you are the general manager for a major-league baseball team. During the off-season, you need to sign some free-agent players for your team. The team owner has given you a budget of $X to spend on free agents. You are allowed to spend less than $X altogether, but the owner will fire you if you spend any more than $X.

412 Chapter 15 Dynamic Programming
You are considering N different positions, and for each position, P free-agent playerswhoplaythatpositionareavailable.8 Becauseyoudonotwanttooverload your roster with too many players at any position, for each position you may sign at most one free agent who plays that position. (If you do not sign any players at a particular position, then you plan to stick with the players you already have at that position.)
To determine how valuable a player is going to be, you decide to use a sabermet- ric statistic9 known as “VORP,” or “value over replacement player.” A player with a higher VORP is more valuable than a player with a lower VORP. A player with a higher VORP is not necessarily more expensive to sign than a player with a lower VORP, because factors other than a player’s value determine how much it costs to sign him.
For each available free-agent player, you have three pieces of information:
the player’s position,
the amount of money it will cost to sign the player, and the player’s VORP.
Devise an algorithm that maximizes the total VORP of the players you sign while spending no more than $X altogether. You may assume that each player signs for a multiple of $100,000. Your algorithm should output the total VORP of the players you sign, the total amount of money you spend, and a list of which players you sign. Analyze the running time and space requirement of your algorithm.
Chapter notes
R. Bellman began the systematic study of dynamic programming in 1955. The word “programming,” both here and in linear programming, refers to using a tab- ular solution method. Although optimization techniques incorporating elements of dynamic programming were known earlier, Bellman provided the area with a solid mathematical basis [37].
8Although there are nine positions on a baseball team, N is not necesarily equal to 9 because some general managers have particular ways of thinking about positions. For example, a general manager might consider right-handed pitchers and left-handed pitchers to be separate “positions,” as well as starting pitchers, long relief pitchers (relief pitchers who can pitch several innings), and short relief pitchers (relief pitchers who normally pitch at most only one inning).
9Sabermetrics is the application of statistical analysis to baseball records. It provides several ways to compare the relative values of individual players.
􏳮 􏳮 􏳮

Notes for Chapter 15 413
Galil and Park [125] classify dynamic-programming algorithms according to the size of the table and the number of other table entries each entry depends on. They call a dynamic-programming algorithm tD=eD if its table size is O.nt / and each entry depends on O.ne / other entries. For example, the matrix-chain multiplication algorithm in Section 15.2 would be 2D=1D, and the longest-common-subsequence algorithm in Section 15.4 would be 2D=0D.
Hu and Shing [182, 183] give an O.n lg n/-time algorithm for the matrix-chain multiplication problem.
The O.mn/-time algorithm for the longest-common-subsequence problem ap- pears to be a folk algorithm. Knuth [70] posed the question of whether subquadratic algorithms for the LCS problem exist. Masek and Paterson [244] answered this question in the affirmative by giving an algorithm that runs in O.mn= lg n/ time, where n 􏳥 m and the sequences are drawn from a set of bounded size. For the special case in which no element appears more than once in an input sequence, Szymanski [326] shows how to solve the problem in O..n C m/ lg.n C m// time. Many of these results extend to the problem of computing string edit distances (Problem 15-5).
An early paper on variable-length binary encodings by Gilbert and Moore [133] had applications to constructing optimal binary search trees for the case in which all probabilities pi are 0; this paper contains an O.n3/-time algorithm. Aho, Hopcroft, and Ullman [5] present the algorithm from Section 15.5. Exercise 15.5-4 is due to Knuth [212]. Hu and Tucker [184] devised an algorithm for the case in which all probabilities pi are 0 that uses O.n2/ time and O.n/ space; subsequently, Knuth [211] reduced the time to O.n lg n/.
Problem 15-8 is due to Avidan and Shamir [27], who have posted on the Web a wonderful video illustrating this image-compression technique.

16 Greedy Algorithms
Algorithms for optimization problems typically go through a sequence of steps, with a set of choices at each step. For many optimization problems, using dynamic programming to determine the best choices is overkill; simpler, more efficient al- gorithms will do. A greedy algorithm always makes the choice that looks best at the moment. That is, it makes a locally optimal choice in the hope that this choice will lead to a globally optimal solution. This chapter explores optimization prob- lems for which greedy algorithms provide optimal solutions. Before reading this chapter, you should read about dynamic programming in Chapter 15, particularly Section 15.3.
Greedy algorithms do not always yield optimal solutions, but for many problems they do. We shall first examine, in Section 16.1, a simple but nontrivial problem, the activity-selection problem, for which a greedy algorithm efficiently computes an optimal solution. We shall arrive at the greedy algorithm by first consider- ing a dynamic-programming approach and then showing that we can always make greedy choices to arrive at an optimal solution. Section 16.2 reviews the basic elements of the greedy approach, giving a direct approach for proving greedy al- gorithms correct. Section 16.3 presents an important application of greedy tech- niques: designing data-compression (Huffman) codes. In Section 16.4, we inves- tigate some of the theory underlying combinatorial structures called “matroids,” for which a greedy algorithm always produces an optimal solution. Finally, Sec- tion 16.5 applies matroids to solve a problem of scheduling unit-time tasks with deadlines and penalties.
The greedy method is quite powerful and works well for a wide range of prob- lems. Later chapters will present many algorithms that we can view as applica- tions of the greedy method, including minimum-spanning-tree algorithms (Chap- ter 23), Dijkstra’s algorithm for shortest paths from a single source (Chapter 24), and Chva ́tal’s greedy set-covering heuristic (Chapter 35). Minimum-spanning-tree algorithms furnish a classic example of the greedy method. Although you can read

16.1 An activity-selection problem 415
this chapter and Chapter 23 independently of each other, you might find it useful to read them together.
16.1 An activity-selection problem
Our first example is the problem of scheduling several competing activities that re- quire exclusive use of a common resource, with a goal of selecting a maximum-size set of mutually compatible activities. Suppose we have a set S D fa1 ; a2 ; : : : ; an g of n proposed activities that wish to use a resource, such as a lecture hall, which can serve only one activity at a time. Each activity ai has a start time si and a finish time fi , where 0 􏳥 si < fi < 1. If selected, activity ai takes place during the half-open time interval Œsi ; fi /. Activities ai and aj are compatible if the intervals Œsi;fi/ and Œsj;fj/ do not overlap. That is, ai and aj are compatible if si 􏳦 fj or sj 􏳦 fi . In the activity-selection problem, we wish to select a maximum-size subset of mutually compatible activities. We assume that the activities are sorted in monotonically increasing order of finish time: f1 􏳥f2 􏳥f3 􏳥􏳵􏳵􏳵􏳥fn􏳣1 􏳥fn : (16.1) (We shall see later the advantage that this assumption provides.) For example, consider the following set S of activities: i 1 2 3 4 5 6 7 8 9 10 11 si 1 3 0 5 3 5 6 8 8 2 12 fi 4 5 6 7 9 9 10 11 12 14 16 For this example, the subset fa3 ; a9 ; a11 g consists of mutually compatible activities. It is not a maximum subset, however, since the subset fa1;a4;a8;a11g is larger. In fact, fa1; a4; a8; a11g is a largest subset of mutually compatible activities; another largest subset is fa2;a4;a9;a11g. We shall solve this problem in several steps. We start by thinking about a dynamic-programming solution, in which we consider several choices when deter- mining which subproblems to use in an optimal solution. We shall then observe that we need to consider only one choice—the greedy choice—and that when we make the greedy choice, only one subproblem remains. Based on these observations, we shall develop a recursive greedy algorithm to solve the activity-scheduling prob- lem. We shall complete the process of developing a greedy solution by converting the recursive algorithm to an iterative one. Although the steps we shall go through in this section are slightly more involved than is typical when developing a greedy algorithm, they illustrate the relationship between greedy algorithms and dynamic programming. 416 Chapter 16 Greedy Algorithms The optimal substructure of the activity-selection problem We can easily verify that the activity-selection problem exhibits optimal substruc- ture. Let us denote by Sij the set of activities that start after activity ai finishes and that finish before activity aj starts. Suppose that we wish to find a maximum set of mutually compatible activities in Sij , and suppose further that such a maximum set is Aij , which includes some activity ak . By including ak in an optimal solution, we are left with two subproblems: finding mutually compatible activities in the set Si k (activities that start after activity ai finishes and that finish before activity ak starts) and finding mutually compatible activities in the set Skj (activities that start after activity ak finishes and that finish before activity aj starts). Let Aik D Aij \ Sik and Akj D Aij \ Skj , so that Ai k contains the activities in Aij that finish before ak starts and Akj contains the activities in Aij that start after ak finishes. Thus, we have Aij D Ai k [ fak g [ Akj , and so the maximum-size set Aij of mutually com- patibleactivitiesinSij consistsofjAijjDjAikjCjAkjjC1activities. The usual cut-and-paste argument shows that the optimal solution Aij must also include optimal solutions to the two subproblems for Si k and Skj . If we could find a set A0kj of mutually compatible activities in Skj where jA0kj j > jAkj j, then we could use A0kj , rather than Akj , in a solution to the subproblem for Sij . We would have constructed a set of jAikjCjA0kjjC1 > jAikjCjAkjjC1 D jAijj mutually compatible activities, which contradicts the assumption that Aij is an optimal solution. A symmetric argument applies to the activities in Sik.
This way of characterizing optimal substructure suggests that we might solve the activity-selection problem by dynamic programming. If we denote the size of anoptimalsolutionforthesetSij bycŒi;j􏳩,thenwewouldhavetherecurrence
cŒi;j􏳩 D cŒi;k􏳩 C cŒk;j􏳩 C 1 :
Of course, if we did not know that an optimal solution for the set Sij includes activity ak, we would have to examine all activities in Sij to find which one to choose, so that
(0 ifSij D;;
cŒi;j􏳩 D max fcŒi;k􏳩 C cŒk;j􏳩 C 1g if Sij ¤ ; : (16.2)
ak2Sij
We could then develop a recursive algorithm and memoize it, or we could work bottom-up and fill in table entries as we go along. But we would be overlooking another important characteristic of the activity-selection problem that we can use to great advantage.

16.1 An activity-selection problem 417
Making the greedy choice
What if we could choose an activity to add to our optimal solution without having to first solve all the subproblems? That could save us from having to consider all the choices inherent in recurrence (16.2). In fact, for the activity-selection problem, we need consider only one choice: the greedy choice.
What do we mean by the greedy choice for the activity-selection problem? Intu- ition suggests that we should choose an activity that leaves the resource available for as many other activities as possible. Now, of the activities we end up choos- ing, one of them must be the first one to finish. Our intuition tells us, therefore, to choose the activity in S with the earliest finish time, since that would leave the resource available for as many of the activities that follow it as possible. (If more than one activity in S has the earliest finish time, then we can choose any such activity.) In other words, since the activities are sorted in monotonically increasing order by finish time, the greedy choice is activity a1. Choosing the first activity to finish is not the only way to think of making a greedy choice for this problem; Exercise 16.1-3 asks you to explore other possibilities.
If we make the greedy choice, we have only one remaining subproblem to solve: finding activities that start after a1 finishes. Why don’t we have to consider ac- tivities that finish before a1 starts? We have that s1 < f1, and f1 is the earliest finish time of any activity, and therefore no activity can have a finish time less than or equal to s1. Thus, all activities that are compatible with activity a1 must start after a1 finishes. Furthermore, we have already established that the activity-selection problem ex- hibits optimal substructure. Let Sk D fai 2 S W si 􏳦 fk g be the set of activities that start after activity ak finishes. If we make the greedy choice of activity a1, then S1 remains as the only subproblem to solve.1 Optimal substructure tells us that if a1 is in the optimal solution, then an optimal solution to the original problem consists of activity a1 and all the activities in an optimal solution to the subproblem S1. One big question remains: is our intuition correct? Is the greedy choice—in which we choose the first activity to finish—always part of some optimal solution? The following theorem shows that it is. 1We sometimes refer to the sets Sk as subproblems rather than as just sets of activities. It will always be clear from the context whether we are referring to Sk as a set of activities or as a subproblem whose input is that set. 418 Chapter 16 Greedy Algorithms Theorem 16.1 Consider any nonempty subproblem Sk, and let am be an activity in Sk with the earliest finish time. Then am is included in some maximum-size subset of mutually compatible activities of Sk . Proof Let Ak be a maximum-size subset of mutually compatible activities in Sk, and let aj be the activity in Ak with the earliest finish time. If aj D am, we are done, since we have shown that am is in some maximum-size subset of mutually compatible activities of Sk. If aj ¤ am, let the set A0k D Ak 􏳣 faj g [ famg be Ak but substituting am for aj . The activities in A0k are disjoint, which follows because the activities in Ak are disjoint, aj is the first activity in Ak to finish, and fm 􏳥 fj . Since jA0kj D jAkj, we conclude that A0k is a maximum-size subset of mutually compatible activities of Sk, and it includes am. Thus, we see that although we might be able to solve the activity-selection prob- lem with dynamic programming, we don’t need to. (Besides, we have not yet examined whether the activity-selection problem even has overlapping subprob- lems.) Instead, we can repeatedly choose the activity that finishes first, keep only the activities compatible with this activity, and repeat until no activities remain. Moreover, because we always choose the activity with the earliest finish time, the finish times of the activities we choose must strictly increase. We can consider each activity just once overall, in monotonically increasing order of finish times. An algorithm to solve the activity-selection problem does not need to work bottom-up, like a table-based dynamic-programming algorithm. Instead, it can work top-down, choosing an activity to put into the optimal solution and then solv- ing the subproblem of choosing activities from those that are compatible with those already chosen. Greedy algorithms typically have this top-down design: make a choice and then solve a subproblem, rather than the bottom-up technique of solving subproblems before making a choice. A recursive greedy algorithm Now that we have seen how to bypass the dynamic-programming approach and in- stead use a top-down, greedy algorithm, we can write a straightforward, recursive procedure to solve the activity-selection problem. The procedure RECURSIVE- ACTIVITY-SELECTOR takes the start and finish times of the activities, represented as arrays s and f ,2 the index k that defines the subproblem Sk it is to solve, and 2Because the pseudocode takes s and f as arrays, it indexes into them with square brackets rather than subscripts. 16.1 An activity-selection problem 419 the size n of the original problem. It returns a maximum-size set of mutually com- patible activities in Sk . We assume that the n input activities are already ordered by monotonically increasing finish time, according to equation (16.1). If not, we can sort them into this order in O.n lg n/ time, breaking ties arbitrarily. In order to start, we add the fictitious activity a0 with f0 D 0, so that subproblem S0 is the entire set of activities S. The initial call, which solves the entire problem, is RECURSIVE-ACTIVITY-SELECTOR.s;f;0;n/. RECURSIVE-ACTIVITY-SELECTOR.s;f;k;n/ 1 2 3 4 5 6 mDkC1 while m 􏳥 n and sŒm􏳩 < f Œk􏳩 //find the first activity in Sk to finish mDmC1 ifm􏳥n return famg [ RECURSIVE-ACTIVITY-SELECTOR.s;f;m;n/ else return ; Figure 16.1 shows the operation of the algorithm. In a given recursive call RECURSIVE-ACTIVITY-SELECTOR.s;f;k;n/, the while loop of lines 2–3 looks for the first activity in Sk to finish. The loop examines akC1; akC2; : : : ; an, un- til it finds the first activity am that is compatible with ak; such an activity has sm 􏳦 fk. If the loop terminates because it finds such an activity, line 5 returns the union of famg and the maximum-size subset of Sm returned by the recursive call RECURSIVE-ACTIVITY-SELECTOR.s;f;m;n/. Alternatively, the loop may terminate because m > n, in which case we have examined all activities in Sk without finding one that is compatible with ak. In this case, Sk D ;, and so the procedure returns ; in line 6.
Assuming that the activities have already been sorted by finish times, the running time of the call RECURSIVE-ACTIVITY-SELECTOR.s;f;0;n/ is ‚.n/, which we can see as follows. Over all recursive calls, each activity is examined exactly once in the while loop test of line 2. In particular, activity ai is examined in the last call made in which k < i. An iterative greedy algorithm We easily can convert our recursive procedure to an iterative one. The procedure RECURSIVE-ACTIVITY-SELECTOR is almost “tail recursive” (see Problem 7-4): it ends with a recursive call to itself followed by a union operation. It is usually a straightforward task to transform a tail-recursive procedure to an iterative form; in fact, some compilers for certain programming languages perform this task automat- ically. As written, RECURSIVE-ACTIVITY-SELECTOR works for subproblems Sk, i.e., subproblems that consist of the last activities to finish. 420 Chapter 16 Greedy Algorithms k sk fk 0–0 114 235 306 457 539 659 7 6 10 8 8 11 9 8 12 10 2 14 11 12 16 a0 a0 a1 a1 a1 a1 a1 a1 a1 a3 a4 RECURSIVE-ACTIVITY-SELECTOR(s, f, 0, 11) m =1 a2 RECURSIVE-ACTIVITY-SELECTOR(s, f, 1, 11) a1 a4 m= 4 a1 a5 a4 RECURSIVE-ACTIVITY-SELECTOR(s, f, 4, 11) a6 a4 a7 a4 a10 a8 a1 a4 RECURSIVE-ACTIVITY-SELECTOR(s, f, 8, 11) m =8 a9 a1 a4 a8 a8 a11 a4 a8 m = 11 RECURSIVE-ACTIVITY-SELECTOR(s, f, 11, 11) a1 a4 a8 a11 time 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 The operation of RECURSIVE-ACTIVITY-SELECTOR on the 11 activities given ear- lier. Activities considered in each recursive call appear between horizontal lines. The fictitious activity a0 finishes at time 0, and the initial call RECURSIVE-ACTIVITY-SELECTOR.s; f; 0; 11/, se- lects activity a1. In each recursive call, the activities that have already been selected are shaded, and the activity shown in white is being considered. If the starting time of an activity occurs before the finish time of the most recently added activity (the arrow between them points left), it is re- jected. Otherwise (the arrow points directly up or to the right), it is selected. The last recursive call, RECURSIVE-ACTIVITY-SELECTOR.s; f; 11; 11/, returns ;. The resulting set of selected activities is fa1; a4; a8; a11g. Figure 16.1 16.1 An activity-selection problem 421 The procedure GREEDY-ACTIVITY-SELECTOR is an iterative version of the pro- cedure RECURSIVE-ACTIVITY-SELECTOR. It also assumes that the input activi- ties are ordered by monotonically increasing finish time. It collects selected activ- ities into a set A and returns this set when it is done. GREEDY-ACTIVITY-SELECTOR.s;f / 1 2 3 4 5 6 7 8 n D s: length ADfa1g kD1 formD2ton if sŒm􏳩 􏳦 f Œk􏳩 A D A [ famg kDm return A The procedure works as follows. The variable k indexes the most recent addition to A, corresponding to the activity ak in the recursive version. Since we consider the activities in order of monotonically increasing finish time, fk is always the maximum finish time of any activity in A. That is, fk Dmaxffi Wai 2Ag : (16.3) Lines 2–3 select activity a1, initialize A to contain just this activity, and initialize k to index this activity. The for loop of lines 4–7 finds the earliest activity in Sk to finish. The loop considers each activity am in turn and adds am to A if it is compat- ible with all previously selected activities; such an activity is the earliest in Sk to finish. To see whether activity am is compatible with every activity currently in A, it suffices by equation (16.3) to check (in line 5) that its start time sm is not earlier than the finish time fk of the activity most recently added to A. If activity am is compatible, then lines 6–7 add activity am to A and set k to m. The set A returned by the call GREEDY-ACTIVITY-SELECTOR.s;f / is precisely the set returned by the call RECURSIVE-ACTIVITY-SELECTOR.s; f; 0; n/. Like the recursive version, GREEDY-ACTIVITY-SELECTOR schedules a set of n activities in ‚.n/ time, assuming that the activities were already sorted initially by their finish times. Exercises 16.1-1 Give a dynamic-programming algorithm for the activity-selection problem, based on recurrence (16.2). Have your algorithm compute the sizes cŒi;j􏳩 as defined above and also produce the maximum-size subset of mutually compatible activities. 422 Chapter 16 Greedy Algorithms Assume that the inputs have been sorted as in equation (16.1). Compare the running time of your solution to the running time of GREEDY-ACTIVITY-SELECTOR. 16.1-2 Suppose that instead of always selecting the first activity to finish, we instead select the last activity to start that is compatible with all previously selected activities. De- scribe how this approach is a greedy algorithm, and prove that it yields an optimal solution. 16.1-3 Not just any greedy approach to the activity-selection problem produces a max- imum-size set of mutually compatible activities. Give an example to show that the approach of selecting the activity of least duration from among those that are compatible with previously selected activities does not work. Do the same for the approaches of always selecting the compatible activity that overlaps the fewest other remaining activities and always selecting the compatible remaining activity with the earliest start time. 16.1-4 Suppose that we have a set of activities to schedule among a large number of lecture halls, where any activity can take place in any lecture hall. We wish to schedule all the activities using as few lecture halls as possible. Give an efficient greedy algorithm to determine which activity should use which lecture hall. (This problem is also known as the interval-graph coloring problem. We can create an interval graph whose vertices are the given activities and whose edges connect incompatible activities. The smallest number of colors required to color every vertex so that no two adjacent vertices have the same color corresponds to finding the fewest lecture halls needed to schedule all of the given activities.) 16.1-5 Consider a modification to the activity-selection problem in which each activity ai has, in addition to a start and finish time, a value 􏳪i . The objective is no longer to maximize the number of activities scheduled, but instead to maximize the total value of the activities scheduled. That is, we wish to choose a set A of compatible 􏳪k is maximized. Give a polynomial-time algorithm for activities such that P this problem. ak 2A 16.2 Elements of the greedy strategy 423 16.2 Elements of the greedy strategy A greedy algorithm obtains an optimal solution to a problem by making a sequence of choices. At each decision point, the algorithm makes choice that seems best at the moment. This heuristic strategy does not always produce an optimal solution, but as we saw in the activity-selection problem, sometimes it does. This section discusses some of the general properties of greedy methods. The process that we followed in Section 16.1 to develop a greedy algorithm was a bit more involved than is typical. We went through the following steps: 1. Determinetheoptimalsubstructureoftheproblem. 2. Develop a recursive solution. (For the activity-selection problem, we formu- lated recurrence (16.2), but we bypassed developing a recursive algorithm based on this recurrence.) 3. Showthatifwemakethegreedychoice,thenonlyonesubproblemremains. 4. Provethatitisalwayssafetomakethegreedychoice.(Steps3and4canoccur in either order.) 5. Developarecursivealgorithmthatimplementsthegreedystrategy. 6. Converttherecursivealgorithmtoaniterativealgorithm. In going through these steps, we saw in great detail the dynamic-programming un- derpinnings of a greedy algorithm. For example, in the activity-selection problem, we first defined the subproblems Sij , where both i and j varied. We then found that if we always made the greedy choice, we could restrict the subproblems to be of the form Sk . Alternatively, we could have fashioned our optimal substructure with a greedy choice in mind, so that the choice leaves just one subproblem to solve. In the activity-selection problem, we could have started by dropping the second subscript and defining subproblems of the form Sk . Then, we could have proven that a greedy choice (the first activity am to finish in Sk ), combined with an optimal solution to the remaining set Sm of compatible activities, yields an optimal solution to Sk. More generally, we design greedy algorithms according to the following sequence of steps: 1. Cast the optimization problem as one in which we make a choice and are left with one subproblem to solve. 2. Provethatthereisalwaysanoptimalsolutiontotheoriginalproblemthatmakes the greedy choice, so that the greedy choice is always safe. 424 Chapter 16 Greedy Algorithms 3. Demonstrate optimal substructure by showing that, having made the greedy choice, what remains is a subproblem with the property that if we combine an optimal solution to the subproblem with the greedy choice we have made, we arrive at an optimal solution to the original problem. We shall use this more direct process in later sections of this chapter. Neverthe- less, beneath every greedy algorithm, there is almost always a more cumbersome dynamic-programming solution. How can we tell whether a greedy algorithm will solve a particular optimization problem? No way works all the time, but the greedy-choice property and optimal substructure are the two key ingredients. If we can demonstrate that the problem has these properties, then we are well on the way to developing a greedy algorithm for it. Greedy-choice property The first key ingredient is the greedy-choice property: we can assemble a globally optimal solution by making locally optimal (greedy) choices. In other words, when we are considering which choice to make, we make the choice that looks best in the current problem, without considering results from subproblems. Here is where greedy algorithms differ from dynamic programming. In dynamic programming, we make a choice at each step, but the choice usually depends on the solutions to subproblems. Consequently, we typically solve dynamic-programming problems in a bottom-up manner, progressing from smaller subproblems to larger subproblems. (Alternatively, we can solve them top down, but memoizing. Of course, even though the code works top down, we still must solve the subprob- lems before making a choice.) In a greedy algorithm, we make whatever choice seems best at the moment and then solve the subproblem that remains. The choice made by a greedy algorithm may depend on choices so far, but it cannot depend on any future choices or on the solutions to subproblems. Thus, unlike dynamic pro- gramming, which solves the subproblems before making the first choice, a greedy algorithm makes its first choice before solving any subproblems. A dynamic- programming algorithm proceeds bottom up, whereas a greedy strategy usually progresses in a top-down fashion, making one greedy choice after another, reduc- ing each given problem instance to a smaller one. Of course, we must prove that a greedy choice at each step yields a globally optimal solution. Typically, as in the case of Theorem 16.1, the proof examines a globally optimal solution to some subproblem. It then shows how to modify the solution to substitute the greedy choice for some other choice, resulting in one similar, but smaller, subproblem. We can usually make the greedy choice more efficiently than when we have to consider a wider set of choices. For example, in the activity-selection problem, as- 16.2 Elements of the greedy strategy 425 suming that we had already sorted the activities in monotonically increasing order of finish times, we needed to examine each activity just once. By preprocessing the input or by using an appropriate data structure (often a priority queue), we often can make greedy choices quickly, thus yielding an efficient algorithm. Optimal substructure A problem exhibits optimal substructure if an optimal solution to the problem contains within it optimal solutions to subproblems. This property is a key in- gredient of assessing the applicability of dynamic programming as well as greedy algorithms. As an example of optimal substructure, recall how we demonstrated in Section 16.1 that if an optimal solution to subproblem Sij includes an activity ak, then it must also contain optimal solutions to the subproblems Si k and Skj . Given this optimal substructure, we argued that if we knew which activity to use as ak , we could construct an optimal solution to Sij by selecting ak along with all activities in optimal solutions to the subproblems Si k and Skj . Based on this observation of optimal substructure, we were able to devise the recurrence (16.2) that described the value of an optimal solution. We usually use a more direct approach regarding optimal substructure when applying it to greedy algorithms. As mentioned above, we have the luxury of assuming that we arrived at a subproblem by having made the greedy choice in the original problem. All we really need to do is argue that an optimal solution to the subproblem, combined with the greedy choice already made, yields an optimal solution to the original problem. This scheme implicitly uses induction on the subproblems to prove that making the greedy choice at every step produces an optimal solution. Greedy versus dynamic programming Because both the greedy and dynamic-programming strategies exploit optimal sub- structure, you might be tempted to generate a dynamic-programming solution to a problem when a greedy solution suffices or, conversely, you might mistakenly think that a greedy solution works when in fact a dynamic-programming solution is re- quired. To illustrate the subtleties between the two techniques, let us investigate two variants of a classical optimization problem. The 0-1 knapsack problem is the following. A thief robbing a store finds n items. The ith item is worth 􏳪i dollars and weighs wi pounds, where 􏳪i and wi are integers. The thief wants to take as valuable a load as possible, but he can carry at most W pounds in his knapsack, for some integer W . Which items should he take? (We call this the 0-1 knapsack problem because for each item, the thief must either 426 Chapter 16 Greedy Algorithms take it or leave it behind; he cannot take a fractional amount of an item or take an item more than once.) In the fractional knapsack problem, the setup is the same, but the thief can take fractions of items, rather than having to make a binary (0-1) choice for each item. You can think of an item in the 0-1 knapsack problem as being like a gold ingot and an item in the fractional knapsack problem as more like gold dust. Both knapsack problems exhibit the optimal-substructure property. For the 0-1 problem, consider the most valuable load that weighs at most W pounds. If we remove item j from this load, the remaining load must be the most valuable load weighing at most W 􏳣 wj that the thief can take from the n 􏳣 1 original items excluding j . For the comparable fractional problem, consider that if we remove a weight w of one item j from the optimal load, the remaining load must be the most valuable load weighing at most W 􏳣 w that the thief can take from the n 􏳣 1 original items plus wj 􏳣 w pounds of item j . Although the problems are similar, we can solve the fractional knapsack problem by a greedy strategy, but we cannot solve the 0-1 problem by such a strategy. To solve the fractional problem, we first compute the value per pound 􏳪i =wi for each item. Obeying a greedy strategy, the thief begins by taking as much as possible of the item with the greatest value per pound. If the supply of that item is exhausted and he can still carry more, he takes as much as possible of the item with the next greatest value per pound, and so forth, until he reaches his weight limit W . Thus, by sorting the items by value per pound, the greedy algorithm runs in O.nlgn/ time. We leave the proof that the fractional knapsack problem has the greedy- choice property as Exercise 16.2-1. To see that this greedy strategy does not work for the 0-1 knapsack problem, consider the problem instance illustrated in Figure 16.2(a). This example has 3 items and a knapsack that can hold 50 pounds. Item 1 weighs 10 pounds and is worth 60 dollars. Item 2 weighs 20 pounds and is worth 100 dollars. Item 3 weighs 30 pounds and is worth 120 dollars. Thus, the value per pound of item 1 is 6 dollars per pound, which is greater than the value per pound of either item 2 (5 dollars per pound) or item 3 (4 dollars per pound). The greedy strategy, therefore, would take item 1 first. As you can see from the case analysis in Figure 16.2(b), however, the optimal solution takes items 2 and 3, leaving item 1 behind. The two possible solutions that take item 1 are both suboptimal. For the comparable fractional problem, however, the greedy strategy, which takes item 1 first, does yield an optimal solution, as shown in Figure 16.2(c). Tak- ing item 1 doesn’t work in the 0-1 problem because the thief is unable to fill his knapsack to capacity, and the empty space lowers the effective value per pound of his load. In the 0-1 problem, when we consider whether to include an item in the knapsack, we must compare the solution to the subproblem that includes the item with the solution to the subproblem that excludes the item before we can make the 16.2 Elements of the greedy strategy 427 20 30 20 10 (a) item 3 $120 + $100 = $220 $80 + $120 item 1 30 + + + item 2 20 10 $60 $100 $100 $60 $60 $60 = $160 = $180 = $240 (b) (c) 50 30 20 20 10 Figure 16.2 An example showing that the greedy strategy does not work for the 0-1 knapsack problem. (a) The thief must select a subset of the three items shown whose weight must not exceed 50 pounds. (b) The optimal subset includes items 2 and 3. Any solution with item 1 is suboptimal, even though item 1 has the greatest value per pound. (c) For the fractional knapsack problem, taking the items in order of greatest value per pound yields an optimal solution. choice. The problem formulated in this way gives rise to many overlapping sub- problems—a hallmark of dynamic programming, and indeed, as Exercise 16.2-2 asks you to show, we can use dynamic programming to solve the 0-1 problem. Exercises 16.2-1 Prove that the fractional knapsack problem has the greedy-choice property. 16.2-2 Give a dynamic-programming solution to the 0-1 knapsack problem that runs in O.n W / time, where n is the number of items and W is the maximum weight of items that the thief can put in his knapsack. 16.2-3 Suppose that in a 0-1 knapsack problem, the order of the items when sorted by increasing weight is the same as their order when sorted by decreasing value. Give an efficient algorithm to find an optimal solution to this variant of the knapsack problem, and argue that your algorithm is correct. 16.2-4 Professor Gekko has always dreamed of inline skating across North Dakota. He plans to cross the state on highway U.S. 2, which runs from Grand Forks, on the eastern border with Minnesota, to Williston, near the western border with Montana. 30 10 $100 $120 knapsack 428 Chapter 16 Greedy Algorithms The professor can carry two liters of water, and he can skate m miles before running out of water. (Because North Dakota is relatively flat, the professor does not have to worry about drinking water at a greater rate on uphill sections than on flat or downhill sections.) The professor will start in Grand Forks with two full liters of water. His official North Dakota state map shows all the places along U.S. 2 at which he can refill his water and the distances between these locations. The professor’s goal is to minimize the number of water stops along his route across the state. Give an efficient method by which he can determine which water stops he should make. Prove that your strategy yields an optimal solution, and give its running time. 16.2-5 Describe an efficient algorithm that, given a set fx1;x2;:::;xng of points on the real line, determines the smallest set of unit-length closed intervals that contains all of the given points. Argue that your algorithm is correct. 16.2-6 ? Show how to solve the fractional knapsack problem in O.n/ time. 16.2-7 Suppose you are given two sets A and B, each containing n positive integers. You can choose to reorder each set however you like. After reordering, let ai be the ith element of set A, and let b be the ith element of set B. You then receive a payoff Qn i of iD1 aibi . Give an algorithm that will maximize your payoff. Prove that your algorithm maximizes the payoff, and state its running time. 16.3 Huffman codes Huffman codes compress data very effectively: savings of 20% to 90% are typical, depending on the characteristics of the data being compressed. We consider the data to be a sequence of characters. Huffman’s greedy algorithm uses a table giving how often each character occurs (i.e., its frequency) to build up an optimal way of representing each character as a binary string. Suppose we have a 100,000-character data file that we wish to store compactly. We observe that the characters in the file occur with the frequencies given by Fig- ure 16.3. That is, only 6 different characters appear, and the character a occurs 45,000 times. We have many options for how to represent such a file of information. Here, we consider the problem of designing a binary character code (or code for short) 16.3 Huffman codes 429 Frequency (in thousands) Fixed-length codeword Variable-length codeword 45 13 12 000 001 010 0 101 100 16 9 5 011 100 101 111 1101 1100 abcdef Figure 16.3 A character-coding problem. A data file of 100,000 characters contains only the char- acters a–f, with the frequencies indicated. If we assign each character a 3-bit codeword, we can encode the file in 300,000 bits. Using the variable-length code shown, we can encode the file in only 224,000 bits. in which each character is represented by a unique binary string, which we call a codeword. If we use a fixed-length code, we need 3 bits to represent 6 characters: a = 000, b = 001, ..., f= 101. This method requires 300,000 bits to code the entire file. Can we do better? A variable-length code can do considerably better than a fixed-length code, by giving frequent characters short codewords and infrequent characters long code- words. Figure 16.3 shows such a code; here the 1-bit string 0 represents a, and the 4-bit string 1100 represents f. This code requires .45􏳵1 C 13􏳵3 C 12􏳵3 C 16􏳵3 C 9􏳵4 C 5􏳵4/􏳵1,000D224,000bits to represent the file, a savings of approximately 25%. In fact, this is an optimal character code for this file, as we shall see. Prefix codes We consider here only codes in which no codeword is also a prefix of some other codeword.Suchcodesarecalledprefixcodes.3 Althoughwewon’tproveithere,a prefix code can always achieve the optimal data compression among any character code, and so we suffer no loss of generality by restricting our attention to prefix codes. Encoding is always simple for any binary character code; we just concatenate the codewords representing each character of the file. For example, with the variable- length prefix code of Figure 16.3, we code the 3-character fileabcas 0􏳵101􏳵100 D 0101100, where “􏳵” denotes concatenation. Prefix codes are desirable because they simplify decoding. Since no codeword is a prefix of any other, the codeword that begins an encoded file is unambiguous. We can simply identify the initial codeword, translate it back to the original char- 3Perhaps “prefix-free codes” would be a better name, but the term “prefix codes” is standard in the literature. 430 Chapter 16 Greedy Algorithms 100 100 01 01 14 a:45 55 86 01001 58 28 14 25 30 010101 0101 a:45 b:13 c:12 d:16 e:9 f:5 c:12 b:13 14 d:16 01 f:5 e:9 (a) (b) Figure 16.4 Trees corresponding to the coding schemes in Figure 16.3. Each leaf is labeled with a character and its frequency of occurrence. Each internal node is labeled with the sum of the fre- quencies of the leaves in its subtree. (a) The tree corresponding to the fixed-length code a = 000, . . . , f= 101. (b) The tree corresponding to the optimal prefix codea= 0,b= 101, ...,f= 1100. acter, and repeat the decoding process on the remainder of the encoded file. In our example, the string 001011101 parses uniquely as 0 􏳵 0 􏳵 101 􏳵 1101, which decodes to aabe. The decoding process needs a convenient representation for the prefix code so that we can easily pick off the initial codeword. A binary tree whose leaves are the given characters provides one such representation. We interpret the binary codeword for a character as the simple path from the root to that character, where 0 means “go to the left child” and 1 means “go to the right child.” Figure 16.4 shows the trees for the two codes of our example. Note that these are not binary search trees, since the leaves need not appear in sorted order and internal nodes do not contain character keys. An optimal code for a file is always represented by a full binary tree, in which every nonleaf node has two children (see Exercise 16.3-2). The fixed-length code in our example is not optimal since its tree, shown in Figure 16.4(a), is not a full bi- nary tree: it contains codewords beginning 10. . . , but none beginning 11. . . . Since we can now restrict our attention to full binary trees, we can say that if C is the alphabet from which the characters are drawn and all character frequencies are pos- itive, then the tree for an optimal prefix code has exactly jC j leaves, one for each letter of the alphabet, and exactly jC j 􏳣 1 internal nodes (see Exercise B.5-3). Given a tree T corresponding to a prefix code, we can easily compute the number of bits required to encode a file. For each character c in the alphabet C, let the attribute c:freq denote the frequency of c in the file and let dT .c/ denote the depth 16.3 Huffman codes 431 of c’s leaf in the tree. Note that dT .c/ is also the length of the codeword for character c. The number of bits required to encode a file is thus X c:freq 􏳵 dT .c/ ; which we define as the cost of the tree T . Constructing a Huffman code B.T / D (16.4) 1 2 3 4 5 6 7 8 9 nDjCj QDC foriD1ton􏳣1 allocate a new node ́ ́:left D x D EXTRACT-MIN.Q/ ́:right D y D EXTRACT-MIN.Q/ ́:freq D x:freq C y:freq INSERT.Q; ́/ return EXTRACT-MIN.Q/ //return the root of the tree c2C Huffman invented a greedy algorithm that constructs an optimal prefix code called a Huffman code. In line with our observations in Section 16.2, its proof of cor- rectness relies on the greedy-choice property and optimal substructure. Rather than demonstrating that these properties hold and then developing pseudocode, we present the pseudocode first. Doing so will help clarify how the algorithm makes greedy choices. In the pseudocode that follows, we assume that C is a set of n characters and that each character c 2 C is an object with an attribute c:freq giving its frequency. The algorithm builds the tree T corresponding to the optimal code in a bottom-up manner. It begins with a set of jC j leaves and performs a sequence of jC j 􏳣 1 “merging” operations to create the final tree. The algorithm uses a min-priority queue Q, keyed on the freq attribute, to identify the two least-frequent objects to merge together. When we merge two objects, the result is a new object whose frequency is the sum of the frequencies of the two objects that were merged. HUFFMAN.C/ For our example, Huffman’s algorithm proceeds as shown in Figure 16.5. Since the alphabet contains 6 letters, the initial queue size is n D 6, and 5 merge steps build the tree. The final tree represents the optimal prefix code. The codeword for a letter is the sequence of edge labels on the simple path from the root to the letter. Line 2 initializes the min-priority queue Q with the characters in C. The for loop in lines 3–8 repeatedly extracts the two nodes x and y of lowest frequency 432 Chapter 16 Greedy Algorithms (a) f:5 e:9 c:12 b:13 d:16 a:45 (b) c:12 b:13 14 d:16 a:45 01 (c) 14 d:16 25 01 01 a:45 f:5 e:9 (d) 25 30 01 01 a:45 f:5 e:9 c:12 b:13 c:12 b:13 14 d:16 01 f:5 e:9 (e) a:45 (f) 100 55 01 01 25 0101 30 a:45 55 01 25 01 0101 f:5 e:9 c:12 b:13 14 d:16 01 f:5 e:9 c:12 b:13 14 d:16 30 Figure 16.5 The steps of Huffman’s algorithm for the frequencies given in Figure 16.3. Each part shows the contents of the queue sorted into increasing order by frequency. At each step, the two trees with lowest frequencies are merged. Leaves are shown as rectangles containing a character and its frequency. Internal nodes are shown as circles containing the sum of the frequencies of their children. An edge connecting an internal node with its children is labeled 0 if it is an edge to a left child and 1 if it is an edge to a right child. The codeword for a letter is the sequence of labels on the edges connecting the root to the leaf for that letter. (a) The initial set of n D 6 nodes, one for each letter. (b)–(e) Intermediate stages. (f) The final tree. from the queue, replacing them in the queue with a new node ́ representing their merger. The frequency of ́ is computed as the sum of the frequencies of x and y in line 7. The node ́ has x as its left child and y as its right child. (This order is arbitrary; switching the left and right child of any node yields a different code of the same cost.) After n 􏳣 1 mergers, line 9 returns the one node left in the queue, which is the root of the code tree. Although the algorithm would produce the same result if we were to excise the variables x and y—assigning directly to ́:left and ́:right in lines 5 and 6, and changing line 7 to ́:freq D ́:left:freq C ́:right:freq—we shall use the node 16.3 Huffman codes 433 names x and y in the proof of correctness. Therefore, we find it convenient to leave them in. To analyze the running time of Huffman’s algorithm, we assume that Q is im- plemented as a binary min-heap (see Chapter 6). For a set C of n characters, we can initialize Q in line 2 in O.n/ time using the BUILD-MIN-HEAP procedure dis- cussed in Section 6.3. The for loop in lines 3–8 executes exactly n 􏳣 1 times, and since each heap operation requires time O.lg n/, the loop contributes O.n lg n/ to the running time. Thus, the total running time of HUFFMAN on a set of n charac- ters is O.n lg n/. We can reduce the running time to O.n lg lg n/ by replacing the binary min-heap with a van Emde Boas tree (see Chapter 20). Correctness of Huffman’s algorithm To prove that the greedy algorithm HUFFMAN is correct, we show that the prob- lem of determining an optimal prefix code exhibits the greedy-choice and optimal- substructure properties. The next lemma shows that the greedy-choice property holds. Lemma 16.2 Let C be an alphabet in which each character c 2 C has frequency c:freq. Let x and y be two characters in C having the lowest frequencies. Then there exists an optimal prefix code for C in which the codewords for x and y have the same length and differ only in the last bit. Proof The idea of the proof is to take the tree T representing an arbitrary optimal prefix code and modify it to make a tree representing another optimal prefix code such that the characters x and y appear as sibling leaves of maximum depth in the new tree. If we can construct such a tree, then the codewords for x and y will have the same length and differ only in the last bit. Let a and b be two characters that are sibling leaves of maximum depth in T . Without loss of generality, we assume that a:freq 􏳥 b:freq and x:freq 􏳥 y:freq. Since x:freq and y:freq are the two lowest leaf frequencies, in order, and a:freq and b:freq are two arbitrary frequencies, in order, we have x:freq 􏳥 a:freq and y:freq 􏳥 b:freq. In the remainder of the proof, it is possible that we could have x:freq D a:freq or y:freq D b:freq. However, if we had x:freq D b:freq, then we would also have a:freq D b:freq D x:freq D y:freq (see Exercise 16.3-1), and the lemma would be trivially true. Thus, we will assume that x:freq ¤ b:freq, which means that x ¤ b. As Figure 16.6 shows, we exchange the positions in T of a and x to produce a tree T0, and then we exchange the positions in T0 of b and y to produce a tree T00 434 Chapter 16 Greedy Algorithms T T′ T′′ xaa yyb abxbxy Figure 16.6 An illustration of the key step in the proof of Lemma 16.2. In the optimal tree T , leaves a and b are two siblings of maximum depth. Leaves x and y are the two characters with the lowest frequencies; they appear in arbitrary positions in T . Assuming that x ¤ b, swapping leaves a and x produces tree T 0, and then swapping leaves b and y produces tree T 00. Since each swap does not increase the cost, the resulting tree T 00 is also an optimal tree. in which x and y are sibling leaves of maximum depth. (Note that if x D b but y ¤ a, then tree T 00 does not have x and y as sibling leaves of maximum depth. Because we assume that x ¤ b, this situation cannot occur.) By equation (16.4), the difference in cost between T and T 0 is B.T/􏳣B.T0/ XX D c:freq 􏳵 dT .c/ 􏳣 c:freq 􏳵 dT 0 .c/ c2C c2C D x:freq􏳵dT.x/Ca:freq􏳵dT.a/􏳣x:freq􏳵dT0.x/􏳣a:freq􏳵dT0.a/ D x:freq􏳵dT.x/Ca:freq􏳵dT.a/􏳣x:freq􏳵dT.a/􏳣a:freq􏳵dT.x/ D .a:freq 􏳣 x:freq/.dT .a/ 􏳣 dT .x// 􏳦0; because both a:freq 􏳣 x:freq and dT .a/ 􏳣 dT .x/ are nonnegative. More specifi- cally, a:freq 􏳣 x:freq is nonnegative because x is a minimum-frequency leaf, and dT .a/􏳣dT .x/ is nonnegative because a is a leaf of maximum depth in T . Similarly, exchanging y and b does not increase the cost, and so B.T 0/ 􏳣 B.T 00/ is nonnega- tive. Therefore, B.T 00/ 􏳥 B.T /, and since T is optimal, we have B.T / 􏳥 B.T 00/, which implies B.T 00/ D B.T /. Thus, T 00 is an optimal tree in which x and y appear as sibling leaves of maximum depth, from which the lemma follows. Lemma 16.2 implies that the process of building up an optimal tree by mergers can, without loss of generality, begin with the greedy choice of merging together those two characters of lowest frequency. Why is this a greedy choice? We can view the cost of a single merger as being the sum of the frequencies of the two items being merged. Exercise 16.3-4 shows that the total cost of the tree constructed equals the sum of the costs of its mergers. Of all possible mergers at each step, HUFFMAN chooses the one that incurs the least cost. 16.3 Huffman codes 435 The next lemma shows that the problem of constructing optimal prefix codes has the optimal-substructure property. Lemma 16.3 Let C be a given alphabet with frequency c:freq defined for each character c 2 C. Let x and y be two characters in C with minimum frequency. Let C0 be the alphabet C with the characters x and y removed and a new character ́ added, so that C0 D C 􏳣fx;yg[f ́g. Define f for C0 as for C, except that ́:freq D x:freq C y:freq. Let T 0 be any tree representing an optimal prefix code for the alphabet C 0 . Then the tree T , obtained from T 0 by replacing the leaf node for ́ with an internal node having x and y as children, represents an optimal prefix code for the alphabet C . Proof We first show how to express the cost B.T/ of tree T in terms of the cost B.T0/ of tree T0, by considering the component costs in equation (16.4). For each character c 2 C 􏳣 fx;yg, we have that dT .c/ D dT0.c/, and hence c:freq 􏳵 dT .c/ D c:freq 􏳵 dT 0 .c/. Since dT .x/ D dT .y/ D dT 0 . ́/ C 1, we have x:freq 􏳵 dT .x/ C y:freq 􏳵 dT .y/ D D ́:freq 􏳵 dT 0 . ́/ C .x:freq C y:freq/ ; from which we conclude that B.T / D B.T 0/ C x:freq C y:freq or, equivalently, B.T 0/ D B.T / 􏳣 x:freq 􏳣 y:freq : We now prove the lemma by contradiction. Suppose that T does not repre- sent an optimal prefix code for C . Then there exists an optimal tree T 00 such that B.T 00/ < B.T /. Without loss of generality (by Lemma 16.2), T 00 has x and y as siblings. Let T 000 be the tree T 00 with the common parent of x and y replaced by a leaf ́ with frequency ́:freq D x:freq C y:freq. Then B.T 000/ D B.T 00/ 􏳣 x:freq 􏳣 y:freq < B.T/􏳣x:freq􏳣y:freq D B.T0/; yielding a contradiction to the assumption that T 0 represents an optimal prefix code for C 0 . Thus, T must represent an optimal prefix code for the alphabet C . Theorem 16.4 Procedure HUFFMAN produces an optimal prefix code. Proof Immediate from Lemmas 16.2 and 16.3. .x:freq C y:freq/.dT 0 . ́/ C 1/ 436 Chapter 16 Greedy Algorithms Exercises 16.3-1 Explain why, in the proof of Lemma 16.2, if x:freq D b:freq, then we must have a:freq D b:freq D x:freq D y:freq. 16.3-2 Prove that a binary tree that is not full cannot correspond to an optimal prefix code. 16.3-3 What is an optimal Huffman code for the following set of frequencies, based on the first 8 Fibonacci numbers? a:1 b:1 c:2 d:3 e:5 f:8 g:13 h:21 Can you generalize your answer to find the optimal code when the frequencies are the first n Fibonacci numbers? 16.3-4 Prove that we can also express the total cost of a tree for a code as the sum, over all internal nodes, of the combined frequencies of the two children of the node. 16.3-5 Prove that if we order the characters in an alphabet so that their frequencies are monotonically decreasing, then there exists an optimal code whose codeword lengths are monotonically increasing. 16.3-6 SupposewehaveanoptimalprefixcodeonasetC Df0;1;:::;n􏳣1gofcharac- ters and we wish to transmit this code using as few bits as possible. Show how to represent any optimal prefix code on C using only 2n 􏳣 1 C n dlg ne bits. (Hint: Use 2n 􏳣 1 bits to specify the structure of the tree, as discovered by a walk of the tree.) 16.3-7 Generalize Huffman’s algorithm to ternary codewords (i.e., codewords using the symbols 0, 1, and 2), and prove that it yields optimal ternary codes. 16.3-8 Suppose that a data file contains a sequence of 8-bit characters such that all 256 characters are about equally common: the maximum character frequency is less than twice the minimum character frequency. Prove that Huffman coding in this case is no more efficient than using an ordinary 8-bit fixed-length code. ? 16.4 16.3-9 Show that no compression scheme can expect to compress a file of randomly cho- sen 8-bit characters by even a single bit. (Hint: Compare the number of possible files with the number of possible encoded files.) Matroids and greedy methods In this section, we sketch a beautiful theory about greedy algorithms. This theory describes many situations in which the greedy method yields optimal solutions. It involves combinatorial structures known as “matroids.” Although this theory does not cover all cases for which a greedy method applies (for example, it does not cover the activity-selection problem of Section 16.1 or the Huffman-coding prob- lem of Section 16.3), it does cover many cases of practical interest. Furthermore, this theory has been extended to cover many applications; see the notes at the end of this chapter for references. Matroids A matroid is an ordered pair M D .S;􏳻/ satisfying the following conditions. 1. Sisafiniteset. 2. 􏳻 is a nonempty family of subsets of S, called the independent subsets of S, suchthatifB 2􏳻 andA􏳧B,thenA2􏳻. Wesaythat􏳻 ishereditaryifit satisfies this property. Note that the empty set ; is necessarily a member of 􏳻 . 3. IfA2􏳻,B2􏳻,andjAj jAj. That is, A and B are acyclic sets of edges, and B contains more edges than A does.
We claim that a forest F D .VF ; EF / contains exactly jVF j 􏳣 jEF j trees. To see why, suppose that F consists of t trees, where the ith tree contains 􏳪i vertices and ei edges. Then, we have
Xt jEFjD ei
iD1 Xt
.􏳪i 􏳣 1/
iD1 Xt
D 􏳪i􏳣t iD1
D jVFj􏳣t;
D
(by Theorem B.2)
which implies that t D jVF j 􏳣 jEF j. Thus, forest GA contains jV j 􏳣 jAj trees, and forestGB containsjVj􏳣jBjtrees.
Since forest GB has fewer trees than forest GA does, forest GB must contain some tree T whose vertices are in two different trees in forest GA. Moreover, since T is connected, it must contain an edge .u;􏳪/ such that vertices u and 􏳪 are in different trees in forest GA. Since the edge .u;􏳪/ connects vertices in two different trees in forest GA, we can add the edge .u; 􏳪/ to forest GA without creating a cycle. Therefore, MG satisfies the exchange property, completing the proof that MG is a matroid.
Given a matroid M D .S;􏳻/, we call an element x … A an extension of A 2 􏳻 if we can add x to A while preserving independence; that is, x is an extension of A if A [ fxg 2 􏳻. As an example, consider a graphic matroid MG. If A is an independent set of edges, then edge e is an extension of A if and only if e is not in A and the addition of e to A does not create a cycle.
If A is an independent subset in a matroid M , we say that A is maximal if it has no extensions. That is, A is maximal if it is not contained in any larger independent subset of M . The following property is often useful.

16.4 Matroids and greedy methods 439
Theorem 16.6
All maximal independent subsets in a matroid have the same size.
Proof Suppose to the contrary that A is a maximal independent subset of M and there exists another larger maximal independent subset B of M. Then, the exchange property implies that for some x 2 B 􏳣 A, we can extend A to a larger independent set A [ fxg, contradicting the assumption that A is maximal.
As an illustration of this theorem, consider a graphic matroid MG for a con- nected, undirected graph G. Every maximal independent subset of MG must be a free tree with exactly jV j 􏳣 1 edges that connects all the vertices of G. Such a tree is called a spanning tree of G.
We say that a matroid M D .S;􏳻/ is weighted if it is associated with a weight
function w that assigns a strictly positive weight w.x/ to each element x 2 S. The
weight function w extends to subsets of S by summation:
X
w.x/
for any A 􏳧 S. For example, if we let w.e/ denote the weight of an edge e in a
w.A/ D
graphic matroid MG , then w.A/ is the total weight of the edges in edge set A.
x2A
Greedy algorithms on a weighted matroid
Many problems for which a greedy approach provides optimal solutions can be for- mulated in terms of finding a maximum-weight independent subset in a weighted matroid. That is, we are given a weighted matroid M D .S;􏳻/, and we wish to find an independent set A 2 􏳻 such that w.A/ is maximized. We call such a sub- set that is independent and has maximum possible weight an optimal subset of the matroid. Because the weight w.x/ of any element x 2 S is positive, an optimal subset is always a maximal independent subset—it always helps to make A as large as possible.
For example, in the minimum-spanning-tree problem, we are given a connected undirected graph G D .V; E/ and a length function w such that w.e/ is the (posi- tive) length of edge e. (We use the term “length” here to refer to the original edge weights for the graph, reserving the term “weight” to refer to the weights in the associated matroid.) We wish to find a subset of the edges that connects all of the vertices together and has minimum total length. To view this as a problem of finding an optimal subset of a matroid, consider the weighted matroid MG with weight function w0, where w0.e/ D w0 􏳣 w.e/ and w0 is larger than the maximum length of any edge. In this weighted matroid, all weights are positive and an opti- mal subset is a spanning tree of minimum total length in the original graph. More specifically, each maximal independent subset A corresponds to a spanning tree

440 Chapter 16 Greedy Algorithms
with jV j 􏳣 1 edges, and since
w0.A/ D D
X w0.e/ e2A
1 2 3 4 5 6
AD;
sort M:S into monotonically decreasing order by weight w
for each x 2 M:S, taken in monotonically decreasing order by weight w.x/
if A [ fxg 2 M:􏳻 A D A [ fxg
return A
X
.w0 􏳣w.e// X
e2A
D .jVj􏳣1/w0 􏳣
w.e/ D .jVj􏳣1/w0 􏳣w.A/
for any maximal independent subset A, an independent subset that maximizes the quantity w0.A/ must minimize w.A/. Thus, any algorithm that can find an optimal subset A in an arbitrary matroid can solve the minimum-spanning-tree problem.
Chapter 23 gives algorithms for the minimum-spanning-tree problem, but here we give a greedy algorithm that works for any weighted matroid. The algorithm takes as input a weighted matroid M D .S;􏳻/ with an associated positive weight function w, and it returns an optimal subset A. In our pseudocode, we denote the components of M by M:S and M:􏳻 and the weight function by w. The algorithm is greedy because it considers in turn each element x 2 S, in order of monotoni- cally decreasing weight, and immediately adds it to the set A being accumulated if A [ fxg is independent.
GREEDY.M;w/
e2A
Line 4 checks whether adding each element x to A would maintain A as an inde- pendent set. If A would remain independent, then line 5 adds x to A. Otherwise, x is discarded. Since the empty set is independent, and since each iteration of the for loop maintains A’s independence, the subset A is always independent, by induc- tion. Therefore, GREEDY always returns an independent subset A. We shall see in a moment that A is a subset of maximum possible weight, so that A is an optimal subset.
The running time of GREEDY is easy to analyze. Let n denote jSj. The sorting phase of GREEDY takes time O.n lg n/. Line 4 executes exactly n times, once for each element of S. Each execution of line 4 requires a check on whether or not the set A [ fxg is independent. If each such check takes time O.f .n//, the entire algorithm runs in time O.n lg n C nf .n//.

16.4 Matroids and greedy methods 441
We now prove that GREEDY returns an optimal subset.
Lemma 16.7 (Matroids exhibit the greedy-choice property)
Suppose that M D .S; 􏳻 / is a weighted matroid with weight function w and that S is sorted into monotonically decreasing order by weight. Let x be the first element of S such that fxg is independent, if any such x exists. If x exists, then there exists an optimal subset A of S that contains x.
Proof If no such x exists, then the only independent subset is the empty set and the lemma is vacuously true. Otherwise, let B be any nonempty optimal subset. Assume that x … B; otherwise, letting A D B gives an optimal subset of S that contains x.
No element of B has weight greater than w.x/. To see why, observe that y 2 B implies that fyg is independent, since B 2 􏳻 and 􏳻 is hereditary. Our choice of x therefore ensures that w.x/ 􏳦 w.y/ for any y 2 B.
Construct the set A as follows. Begin with A D fxg. By the choice of x, set A is independent. Using the exchange property, repeatedly find a new element of B that we can add to A until jAj D jBj, while preserving the independence of A. At that point, A and B are the same except that A has x and B has some other element y. That is, A D B 􏳣 fyg [ fxg for some y 2 B, and so
w.A/ D w.B/ 􏳣 w.y/ C w.x/ 􏳦 w.B/:
Because set B is optimal, set A, which contains x, must also be optimal.
We next show that if an element is not an option initially, then it cannot be an
option later.
Lemma 16.8
Let M D .S;􏳻/ be any matroid. If x is an element of S that is an extension of some independent subset A of S, then x is also an extension of ;.
Proof Since x is an extension of A, we have that A[fxg is independent. Since 􏳻 is hereditary, fxg must be independent. Thus, x is an extension of ;.
Corollary 16.9
LetM D.S;􏳻/beanymatroid. IfxisanelementofSsuchthatxisnotan extension of ;, then x is not an extension of any independent subset A of S.
Proof This corollary is simply the contrapositive of Lemma 16.8.

442 Chapter 16 Greedy Algorithms
Corollary 16.9 says that any element that cannot be used immediately can never be used. Therefore, GREEDY cannot make an error by passing over any initial elements in S that are not an extension of ;, since they can never be used.
Lemma 16.10 (Matroids exhibit the optimal-substructure property)
Let x be the first element of S chosen by GREEDY for the weighted matroid M D .S; 􏳻 /. The remaining problem of finding a maximum-weight indepen- dent subset containing x reduces to finding a maximum-weight independent subset of the weighted matroid M0 D .S0;􏳻0/, where
S0 D fy2SWfx;yg2􏳻g;
􏳻0 D fB􏳧S􏳣fxgWB[fxg2􏳻g;
and the weight function for M0 is the weight function for M, restricted to S0. (We call M0 the contraction of M by the element x.)
Proof If A is any maximum-weight independent subset of M containing x, then A0 D A 􏳣 fxg is an independent subset of M0. Conversely, any independent sub- set A0 of M0 yields an independent subset A D A0 [ fxg of M. Since we have in both cases that w.A/ D w.A0/ C w.x/, a maximum-weight solution in M contain- ing x yields a maximum-weight solution in M0, and vice versa.
Theorem 16.11 (Correctness of the greedy algorithm on matroids)
IfM D.S;􏳻/isaweightedmatroidwithweightfunctionw,thenGREEDY.M;w/ returns an optimal subset.
Proof By Corollary 16.9, any elements that GREEDY passes over initially be- cause they are not extensions of ; can be forgotten about, since they can never be useful. Once GREEDY selects the first element x, Lemma 16.7 implies that the algorithm does not err by adding x to A, since there exists an optimal subset containing x. Finally, Lemma 16.10 implies that the remaining problem is one of finding an optimal subset in the matroid M0 that is the contraction of M by x. After the procedure GREEDY sets A to fxg, we can interpret all of its remaining steps as acting in the matroid M0 D .S0;􏳻0/, because B is independent in M0 if and only if B [ fxg is independent in M , for all sets B 2 􏳻 0. Thus, the subsequent operation of GREEDY will find a maximum-weight independent subset for M 0, and the overall operation of GREEDY will find a maximum-weight independent subset for M .

? 16.5
Exercises
16.4-1
Show that .S;􏳻k/ is a matroid, where S is any finite set and 􏳻k is the set of all subsets of S of size at most k, where k 􏳥 jSj.
16.4-2 ?
Given an m 􏳨 n matrix T over some field (such as the reals), show that .S; 􏳻 / is a matroid, where S is the set of columns of T and A 2 􏳻 if and only if the columns in A are linearly independent.
16.4-3 ?
Show that if .S;􏳻/ is a matroid, then .S;􏳻0/ is a matroid, where
􏳻0 DfA0 WS􏳣A0 containssomemaximalA2􏳻g :
That is, the maximal independent sets of .S;􏳻0/ are just the complements of the
maximal independent sets of .S; 􏳻 /.
16.4-4 ?
Let S be a finite set and let S1; S2; : : : ; Sk be a partition of S into nonempty disjoint subsets. Definethestructure.S;􏳻/bytheconditionthat􏳻 DfAWjA\Sij􏳥1 for i D 1;2;:::;kg. Show that .S;􏳻/ is a matroid. That is, the set of all sets A that contain at most one member of each subset in the partition determines the independent sets of a matroid.
16.4-5
Show how to transform the weight function of a weighted matroid problem, where the desired optimal solution is a minimum-weight maximal independent subset, to make it a standard weighted-matroid problem. Argue carefully that your transfor- mation is correct.
A task-scheduling problem as a matroid
An interesting problem that we can solve using matroids is the problem of op- timally scheduling unit-time tasks on a single processor, where each task has a deadline, along with a penalty paid if the task misses its deadline. The problem looks complicated, but we can solve it in a surprisingly simple manner by casting it as a matroid and using a greedy algorithm.
A unit-time task is a job, such as a program to be run on a computer, that requires exactly one unit of time to complete. Given a finite set S of unit-time tasks, a
16.5 A task-scheduling problem as a matroid 443

444 Chapter 16 Greedy Algorithms
schedule for S is a permutation of S specifying the order in which to perform these tasks. The first task in the schedule begins at time 0 and finishes at time 1, the second task begins at time 1 and finishes at time 2, and so on.
The problem of scheduling unit-time tasks with deadlines and penalties for a single processor has the following inputs:
a set S D fa1;a2;:::;ang of n unit-time tasks; asetofnintegerdeadlinesd1;d2;:::;dn,suchthateachdi satisfies1􏳥di 􏳥n
and task ai is supposed to finish by time di ; and
a set of n nonnegative weights or penalties w1; w2; : : : ; wn, such that we incur a penalty of wi if task ai is not finished by time di , and we incur no penalty if a task finishes by its deadline.
We wish to find a schedule for S that minimizes the total penalty incurred for missed deadlines.
Consider a given schedule. We say that a task is late in this schedule if it finishes after its deadline. Otherwise, the task is early in the schedule. We can always trans- form an arbitrary schedule into early-first form, in which the early tasks precede the late tasks. To see why, note that if some early task ai follows some late task aj , then we can switch the positions of ai and aj , and ai will still be early and aj will still be late.
Furthermore, we claim that we can always transform an arbitrary schedule into canonical form, in which the early tasks precede the late tasks and we schedule the early tasks in order of monotonically increasing deadlines. To do so, we put the schedule into early-first form. Then, as long as there exist two early tasks ai andaj finishingatrespectivetimeskandkC1intheschedulesuchthatdj t for some t , then there is no way to make a schedule with no late tasks for set A, because more than t tasks must finish before time t. Therefore, (1) implies (2). If (2) holds, then (3) must follow: there is no way to “get stuck” when scheduling the tasks in order of monotonically increasing deadlines, since (2) implies that the ith largest deadline is at least i. Finally, (3) trivially implies (1).
Using property 2 of Lemma 16.12, we can easily compute whether or not a given set of tasks is independent (see Exercise 16.5-2).
The problem of minimizing the sum of the penalties of the late tasks is the same as the problem of maximizing the sum of the penalties of the early tasks. The following theorem thus ensures that we can use the greedy algorithm to find an independent set A of tasks with the maximum total penalty.
Theorem 16.13
If S is a set of unit-time tasks with deadlines, and 􏳻 is the set of all independent sets of tasks, then the corresponding system .S; 􏳻 / is a matroid.
Proof Every subset of an independent set of tasks is certainly independent. To prove the exchange property, suppose that B and A are independent sets of tasks and that jBj > jAj. Let k be the largest t such that Nt .B/ 􏳥 Nt .A/. (Such a value of t exists, since N0.A/ D N0.B/ D 0.) Since Nn.B/ D jBj and Nn.A/ D jAj, but jBj > jAj, we must have that k < n and that Nj.B/ > Nj.A/ for all j in the range k C 1 􏳥 j 􏳥 n. Therefore, B contains more tasks with deadline k C 1 thanAdoes.Letai beataskinB􏳣AwithdeadlinekC1.LetA0 DA[faig.
We now show that A0 must be independent by using property 2 of Lemma 16.12. For 0 􏳥 t 􏳥 k, we have Nt.A0/ D Nt.A/ 􏳥 t, since A is independent. For k < t 􏳥 n, we have Nt.A0/ 􏳥 Nt.B/ 􏳥 t, since B is independent. Therefore, A0 is independent, completing our proof that .S; 􏳻 / is a matroid. By Theorem 16.11, we can use a greedy algorithm to find a maximum-weight independent set of tasks A. We can then create an optimal schedule having the tasks in A as its early tasks. This method is an efficient algorithm for scheduling 446 Chapter 16 Greedy Algorithms Problems Task ai 1 2 3 4 5 6 7 di 4 2 4 3 1 4 6 wi 70 60 50 40 30 20 10 Figure 16.7 An instance of the problem of scheduling unit-time tasks with deadlines and penalties for a single processor. unit-time tasks with deadlines and penalties for a single processor. The running time is O.n2/ using GREEDY, since each of the O.n/ independence checks made by that algorithm takes time O.n/ (see Exercise 16.5-2). Problem 16-4 gives a faster implementation. Figure 16.7 demonstrates an example of the problem of scheduling unit-time tasks with deadlines and penalties for a single processor. In this example, the greedy algorithm selects, in order, tasks a1, a2, a3, and a4, then rejects a5 (because N4.fa1;a2;a3;a4;a5g/ D 5) and a6 (because N4.fa1;a2;a3;a4;a6g/ D 5), and finally accepts a7. The final optimal schedule is ha2; a4; a1; a3; a7; a5; a6i ; which has a total penalty incurred of w5 C w6 D 50. Exercises 16.5-1 Solve the instance of the scheduling problem given in Figure 16.7, but with each penaltywi replacedby80􏳣wi. 16.5-2 Show how to use property 2 of Lemma 16.12 to determine in time O.jAj/ whether or not a given set A of tasks is independent. 16-1 Coin changing Consider the problem of making change for n cents using the fewest number of coins. Assume that each coin’s value is an integer. a. Describe a greedy algorithm to make change consisting of quarters, dimes, nickels, and pennies. Prove that your algorithm yields an optimal solution. Problems for Chapter 16 447 b. Suppose that the available coins are in the denominations that are powers of c, i.e., the denominations are c0;c1;:::;ck for some integers c > 1 and k 􏳦 1. Show that the greedy algorithm always yields an optimal solution.
c. Give a set of coin denominations for which the greedy algorithm does not yield an optimal solution. Your set should include a penny so that there is a solution for every value of n.
d. GiveanO.nk/-timealgorithmthatmakeschangeforanysetofkdifferentcoin denominations, assuming that one of the coins is a penny.
16-2 Scheduling to minimize average completion time
Suppose you are given a set S D fa1;a2;:::;ang of tasks, where task ai re- quires pi units of processing time to complete, once it has started. You have one computer on which to run these tasks, and the computer can run only one task at a time.Letci bethecompletiontimeoftaskai,thatis,thetimeatwhichtaskai com- pletes processing. Your goal is to minimize the average completion time, that is, to minimize .1=n/PniD1 ci. For example, suppose there are two tasks, a1 and a2, with p1 D 3 and p2 D 5, and consider the schedule in which a2 runs first, followed by a1. Then c2 D 5, c1 D 8, and the average completion time is .5 C 8/=2 D 6:5. If task a1 runs first, however, then c1 D 3, c2 D 8, and the average completion time is .3 C 8/=2 D 5:5.
a. Give an algorithm that schedules the tasks so as to minimize the average com- pletion time. Each task must run non-preemptively, that is, once task ai starts, it must run continuously for pi units of time. Prove that your algorithm minimizes the average completion time, and state the running time of your algorithm.
b. Suppose now that the tasks are not all available at once. That is, each task cannot start until its release time ri . Suppose also that we allow preemption, so that a task can be suspended and restarted at a later time. For example, a task ai with processing time pi D 6 and release time ri D 1 might start running at time 1 and be preempted at time 4. It might then resume at time 10 but be preempted at time 11, and it might finally resume at time 13 and complete at time 15. Task ai has run for a total of 6 time units, but its running time has been divided into three pieces. In this scenario, ai ’s completion time is 15. Give an algorithm that schedules the tasks so as to minimize the average completion time in this new scenario. Prove that your algorithm minimizes the average completion time, and state the running time of your algorithm.

448 Chapter 16 Greedy Algorithms
16-3 Acyclic subgraphs
a. The incidence matrix for an undirected graph G D .V; E/ is a jV j 􏳨 jEj ma-
trix M such that M􏳪e D 1 if edge e is incident on vertex 􏳪, and M􏳪e D 0 other- wise. Argue that a set of columns of M is linearly independent over the field of integers modulo 2 if and only if the corresponding set of edges is acyclic. Then, use the result of Exercise 16.4-2 to provide an alternate proof that .E; 􏳻 / of part (a) is a matroid.
b. Suppose that we associate a nonnegative weight w.e/ with each edge in an undirected graph G D .V;E/. Give an efficient algorithm to find an acyclic subset of E of maximum total weight.
c. Let G.V; E/ be an arbitrary directed graph, and let .E; 􏳻 / be defined so that A 2 􏳻 if and only if A does not contain any directed cycles. Give an example of a directed graph G such that the associated system .E;􏳻/ is not a matroid. Specify which defining condition for a matroid fails to hold.
d. The incidence matrix for a directed graph G D .V;E/ with no self-loops is a jVj􏳨jEjmatrixM suchthatM􏳪e D􏳣1ifedgeeleavesvertex􏳪,M􏳪e D1if edge e enters vertex 􏳪, and M􏳪e D 0 otherwise. Argue that if a set of columns of M is linearly independent, then the corresponding set of edges does not contain a directed cycle.
e. Exercise 16.4-2 tells us that the set of linearly independent sets of columns of any matrix M forms a matroid. Explain carefully why the results of parts (d) and (e) are not contradictory. How can there fail to be a perfect correspon- dence between the notion of a set of edges being acyclic and the notion of the associated set of columns of the incidence matrix being linearly independent?
16-4 Scheduling variations
Consider the following algorithm for the problem from Section 16.5 of scheduling unit-time tasks with deadlines and penalties. Let all n time slots be initially empty, where time slot i is the unit-length slot of time that finishes at time i. We consider the tasks in order of monotonically decreasing penalty. When considering task aj , ifthereexistsatimeslotatorbeforeaj’sdeadlinedj thatisstillempty,assignaj to the latest such slot, filling it. If there is no such slot, assign task aj to the latest of the as yet unfilled slots.
a. Argue that this algorithm always gives an optimal answer.
b. Use the fast disjoint-set forest presented in Section 21.3 to implement the algo- rithm efficiently. Assume that the set of input tasks has already been sorted into

Problems for Chapter 16 449
monotonically decreasing order by penalty. Analyze the running time of your implementation.
16-5 Off-line caching
Modern computers use a cache to store a small amount of data in a fast memory. Even though a program may access large amounts of data, by storing a small subset of the main memory in the cache—a small but faster memory—overall access time can greatly decrease. When a computer program executes, it makes a sequence hr1; r2; : : : ; rni of n memory requests, where each request is for a particular data element. For example, a program that accesses 4 distinct elements fa; b; c; d g might make the sequence of requests hd; b; d; b; d; a; c; d; b; a; c; bi. Let k be the size of the cache. When the cache contains k elements and the program requests the .k C 1/st element, the system must decide, for this and each subsequent request, which k elements to keep in the cache. More precisely, for each request ri , the cache-management algorithm checks whether element ri is already in the cache. If it is, then we have a cache hit; otherwise, we have a cache miss. Upon a cache miss, the system retrieves ri from the main memory, and the cache-management algorithm must decide whether to keep ri in the cache. If it decides to keep ri and the cache already holds k elements, then it must evict one element to make room for ri . The cache-management algorithm evicts data with the goal of minimizing the number of cache misses over the entire sequence of requests.
Typically, caching is an on-line problem. That is, we have to make decisions about which data to keep in the cache without knowing the future requests. Here, however, we consider the off-line version of this problem, in which we are given in advance the entire sequence of n requests and the cache size k, and we wish to minimize the total number of cache misses.
We can solve this off-line problem by a greedy strategy called furthest-in-future, which chooses to evict the item in the cache whose next access in the request sequence comes furthest in the future.
a. Write pseudocode for a cache manager that uses the furthest-in-future strategy. The input should be a sequence hr1; r2; : : : ; rni of requests and a cache size k, and the output should be a sequence of decisions about which data element (if any) to evict upon each request. What is the running time of your algorithm?
b. Show that the off-line caching problem exhibits optimal substructure.
c. Prove that furthest-in-future produces the minimum possible number of cache misses.

450 Chapter 16 Greedy Algorithms
Chapter notes
Much more material on greedy algorithms and matroids can be found in Lawler [224] and Papadimitriou and Steiglitz [271].
The greedy algorithm first appeared in the combinatorial optimization literature in a 1971 article by Edmonds [101], though the theory of matroids dates back to a 1935 article by Whitney [355].
Our proof of the correctness of the greedy algorithm for the activity-selection problem is based on that of Gavril [131]. The task-scheduling problem is studied in Lawler [224]; Horowitz, Sahni, and Rajasekaran [181]; and Brassard and Bratley [54].
Huffman codes were invented in 1952 [185]; Lelewer and Hirschberg [231] sur- veys data-compression techniques known as of 1987.
An extension of matroid theory to greedoid theory was pioneered by Korte and Lova ́sz [216, 217, 218, 219], who greatly generalize the theory presented here.

17 Amortized Analysis
In an amortized analysis, we average the time required to perform a sequence of data-structure operations over all the operations performed. With amortized analy- sis, we can show that the average cost of an operation is small, if we average over a sequence of operations, even though a single operation within the sequence might be expensive. Amortized analysis differs from average-case analysis in that prob- ability is not involved; an amortized analysis guarantees the average performance of each operation in the worst case.
The first three sections of this chapter cover the three most common techniques used in amortized analysis. Section 17.1 starts with aggregate analysis, in which we determine an upper bound T .n/ on the total cost of a sequence of n operations. The average cost per operation is then T.n/=n. We take the average cost as the amortized cost of each operation, so that all operations have the same amortized cost.
Section 17.2 covers the accounting method, in which we determine an amortized cost of each operation. When there is more than one type of operation, each type of operation may have a different amortized cost. The accounting method overcharges some operations early in the sequence, storing the overcharge as “prepaid credit” on specific objects in the data structure. Later in the sequence, the credit pays for operations that are charged less than they actually cost.
Section 17.3 discusses the potential method, which is like the accounting method in that we determine the amortized cost of each operation and may overcharge op- erations early on to compensate for undercharges later. The potential method main- tains the credit as the “potential energy” of the data structure as a whole instead of associating the credit with individual objects within the data structure.
We shall use two examples to examine these three methods. One is a stack with the additional operation MULTIPOP, which pops several objects at once. The other is a binary counter that counts up from 0 by means of the single operation INCREMENT.

452 Chapter 17 Amortized Analysis
While reading this chapter, bear in mind that the charges assigned during an amortized analysis are for analysis purposes only. They need not—and should not—appear in the code. If, for example, we assign a credit to an object x when using the accounting method, we have no need to assign an appropriate amount to some attribute, such as x:credit, in the code.
When we perform an amortized analysis, we often gain insight into a particular data structure, and this insight can help us optimize the design. In Section 17.4, for example, we shall use the potential method to analyze a dynamically expanding and contracting table.
17.1 Aggregate analysis
In aggregate analysis, we show that for all n, a sequence of n operations takes worst-case time T .n/ in total. In the worst case, the average cost, or amortized cost, per operation is therefore T.n/=n. Note that this amortized cost applies to each operation, even when there are several types of operations in the sequence. The other two methods we shall study in this chapter, the accounting method and the potential method, may assign different amortized costs to different types of operations.
Stack operations
In our first example of aggregate analysis, we analyze stacks that have been aug- mented with a new operation. Section 10.1 presented the two fundamental stack operations, each of which takes O.1/ time:
PUSH.S;x/ pushes object x onto stack S.
POP.S/ pops the top of stack S and returns the popped object. Calling POP on an
empty stack generates an error.
Since each of these operations runs in O.1/ time, let us consider the cost of each to be 1. The total cost of a sequence of n PUSH and POP operations is therefore n, and the actual running time for n operations is therefore ‚.n/.
Now we add the stack operation MULTIPOP.S;k/, which removes the k top ob- jects of stack S, popping the entire stack if the stack contains fewer than k objects. Of course, we assume that k is positive; otherwise the MULTIPOP operation leaves the stack unchanged. In the following pseudocode, the operation STACK-EMPTY returns TRUE if there are no objects currently on the stack, and FALSE otherwise.

17.1 Aggregate analysis
453
top 23 17 6 39 10 47
(a)
top 10 47
(b)
(c)
The action of MULTIPOP on a stack S, shown initially in (a). The top 4 objects are
Figure 17.1
popped by MULTIPOP.S;4/, whose result is shown in (b). The next operation is MULTIPOP.S;7/, which empties the stack—shown in (c)—since there were fewer than 7 objects remaining.
MULTIPOP.S;k/
1 while not STACK-EMPTY.S/ and k > 0 2 POP.S/
3 kDk􏳣1
Figure 17.1 shows an example of MULTIPOP.
What is the running time of MULTIPOP.S;k/ on a stack of s objects? The
actual running time is linear in the number of POP operations actually executed, and thus we can analyze MULTIPOP in terms of the abstract costs of 1 each for PUSH and POP. The number of iterations of the while loop is the number min.s; k/ of objects popped off the stack. Each iteration of the loop makes one call to POP in line 2. Thus, the total cost of MULTIPOP is min.s;k/, and the actual running time is a linear function of this cost.
Let us analyze a sequence of n PUSH, POP, and MULTIPOP operations on an ini- tially empty stack. The worst-case cost of a MULTIPOP operation in the sequence is O.n/, since the stack size is at most n. The worst-case time of any stack opera- tion is therefore O.n/, and hence a sequence of n operations costs O.n2/, since we may have O.n/ MULTIPOP operations costing O.n/ each. Although this analysis is correct, the O.n2/ result, which we obtained by considering the worst-case cost of each operation individually, is not tight.
Using aggregate analysis, we can obtain a better upper bound that considers the entire sequence of n operations. In fact, although a single MULTIPOP operation can be expensive, any sequence of n PUSH, POP, and MULTIPOP operations on an initially empty stack can cost at most O.n/. Why? We can pop each object from the stack at most once for each time we have pushed it onto the stack. Therefore, the number of times that POP can be called on a nonempty stack, including calls within MULTIPOP, is at most the number of PUSH operations, which is at most n. For any value of n, any sequence of n PUSH, POP, and MULTIPOP operations takes a total of O.n/ time. The average cost of an operation is O.n/=n D O.1/. In aggregate

454 Chapter 17 Amortized Analysis
analysis, we assign the amortized cost of each operation to be the average cost. In this example, therefore, all three stack operations have an amortized cost of O.1/. We emphasize again that although we have just shown that the average cost, and
hence the running time, of a stack operation is O.1/, we did not use probabilistic reasoning. We actually showed a worst-case bound of O.n/ on a sequence of n operations. Dividing this total cost by n yielded the average cost per operation, or the amortized cost.
Incrementing a binary counter
As another example of aggregate analysis, consider the problem of implementing
a k-bit binary counter that counts upward from 0. We use an array AŒ0 : : k 􏳣 1􏳩 of
bits, where A:length D k, as the counter. A binary number x that is stored in the
counter has its lowest-order bit in AŒ0􏳩 and its highest-order bit in AŒk 􏳣 1􏳩, so that
x D Pk􏳣1 AŒi􏳩 􏳵 2i . Initially, x D 0, and thus AŒi􏳩 D 0 for i D 0; 1; : : : ; k 􏳣 1. To iD0
add 1 (modulo 2k ) to the value in the counter, we use the following procedure.
INCREMENT.A/ 1iD0
2 3 4 5 6
while i < A:length and AŒi􏳩 == 1 AŒi􏳩 D 0 iDiC1 ifi0,thenbi Dbi􏳣1􏳣ti C1. Ineithercase,bi 􏳥bi􏳣1􏳣ti C1,andthe potential difference is
ˆ.Di/􏳣ˆ.Di􏳣1/ 􏳥 .bi􏳣1 􏳣ti C1/􏳣bi􏳣1 D 1􏳣ti :
The amortized cost is therefore
cy D c C ˆ . D / 􏳣 ˆ . D / i i i i􏳣1
􏳥 .ti C1/C.1􏳣ti/ D2:
If the counter starts at zero, then ˆ.D0/ D 0. Since ˆ.Di/ 􏳦 0 for all i, the total amortized cost of a sequence of n INCREMENT operations is an upper bound on the total actual cost, and so the worst-case cost of n INCREMENT operations is O.n/.
The potential method gives us an easy way to analyze the counter even when it does not start at zero. The counter starts with b0 1s, and after n INCREMENT

462 Chapter 17 Amortized Analysis
operations it has bn 1s, where 0 􏳥 b0; bn 􏳥 k. (Recall that k is the number of bits in the counter.) We can rewrite equation (17.3) as
Xn
iD1 iD1
Xn iin0
c D
Wehavecy 􏳥2forall1􏳥i 􏳥n. Sinceˆ.D /Db andˆ.D /Db ,thetotal
cy 􏳣 ˆ . D / C ˆ . D / : ( 1 7 . 4 )
i 00nn
actual cost of n INCREMENT operations is
Xn iD1
ci
Xn
􏳥 2 􏳣 bn C b0
iD1
D 2n􏳣bnCb0:
Note in particular that since b0 􏳥 k, as long as k D O.n/, the total actual cost is O.n/. In other words, if we execute at least n D 􏳫.k/ INCREMENT operations, the total actual cost is O.n/, no matter what initial value the counter contains.
Exercises
17.3-1
Suppose we have a potential function ˆ such that ˆ.Di/ 􏳦 ˆ.D0/ for all i, but ˆ.D0/ ¤ 0. Show that there exists a potential function ˆ0 such that ˆ0.D0/ D 0, ˆ0.Di/ 􏳦 0 for all i 􏳦 1, and the amortized costs using ˆ0 are the same as the amortized costs using ˆ.
17.3-2
Redo Exercise 17.1-3 using a potential method of analysis.
17.3-3
Consider an ordinary binary min-heap data structure with n elements supporting the instructions INSERT and EXTRACT-MIN in O.lgn/ worst-case time. Give a potential function ˆ such that the amortized cost of INSERT is O.lgn/ and the amortized cost of EXTRACT-MIN is O.1/, and show that it works.
17.3-4
What is the total cost of executing n of the stack operations PUSH, POP, and MULTIPOP, assuming that the stack begins with s0 objects and finishes with sn objects?
17.3-5
Suppose that a counter begins at a number with b 1s in its binary representa- tion, rather than at 0. Show that the cost of performing n INCREMENT operations is O.n/ if n D 􏳫.b/. (Do not assume that b is constant.)

17.4 Dynamic tables 463
17.3-6
Show how to implement a queue with two ordinary stacks (Exercise 10.1-6) so that the amortized cost of each ENQUEUE and each DEQUEUE operation is O.1/.
17.3-7
Design a data structure to support the following two operations for a dynamic multiset S of integers, which allows duplicate values:
INSERT.S; x/ inserts x into S.
DELETE-LARGER-HALF.S/ deletes the largest djSj=2e elements from S.
Explain how to implement this data structure so that any sequence of m INSERT and DELETE-LARGER-HALF operations runs in O.m/ time. Your implementation should also include a way to output the elements of S in O.jSj/ time.
17.4 Dynamic tables
We do not always know in advance how many objects some applications will store in a table. We might allocate space for a table, only to find out later that it is not enough. We must then reallocate the table with a larger size and copy all objects stored in the original table over into the new, larger table. Similarly, if many objects have been deleted from the table, it may be worthwhile to reallocate the table with a smaller size. In this section, we study this problem of dynamically expanding and contracting a table. Using amortized analysis, we shall show that the amortized cost of insertion and deletion is only O.1/, even though the actual cost of an operation is large when it triggers an expansion or a contraction. Moreover, we shall see how to guarantee that the unused space in a dynamic table never exceeds a constant fraction of the total space.
We assume that the dynamic table supports the operations TABLE-INSERT and TABLE-DELETE. TABLE-INSERT inserts into the table an item that occupies a sin- gle slot, that is, a space for one item. Likewise, TABLE-DELETE removes an item from the table, thereby freeing a slot. The details of the data-structuring method used to organize the table are unimportant; we might use a stack (Section 10.1), a heap (Chapter 6), or a hash table (Chapter 11). We might also use an array or collection of arrays to implement object storage, as we did in Section 10.3.
We shall find it convenient to use a concept introduced in our analysis of hashing (Chapter 11). We define the load factor ̨.T / of a nonempty table T to be the number of items stored in the table divided by the size (number of slots) of the table. We assign an empty table (one with no items) size 0, and we define its load factor to be 1. If the load factor of a dynamic table is bounded below by a constant,

464 Chapter 17 Amortized Analysis
the unused space in the table is never more than a constant fraction of the total amount of space.
We start by analyzing a dynamic table in which we only insert items. We then consider the more general case in which we both insert and delete items.
17.4.1 Table expansion
Let us assume that storage for a table is allocated as an array of slots. A table fills upwhenallslotshavebeenusedor,equivalently,whenitsloadfactoris1.1 Insome software environments, upon attempting to insert an item into a full table, the only alternative is to abort with an error. We shall assume, however, that our software environment, like many modern ones, provides a memory-management system that can allocate and free blocks of storage on request. Thus, upon inserting an item into a full table, we can expand the table by allocating a new table with more slots than the old table had. Because we always need the table to reside in contiguous memory, we must allocate a new array for the larger table and then copy items from the old table into the new table.
A common heuristic allocates a new table with twice as many slots as the old one. If the only table operations are insertions, then the load factor of the table is always at least 1=2, and thus the amount of wasted space never exceeds half the total space in the table.
In the following pseudocode, we assume that T is an object representing the table. The attribute T:table contains a pointer to the block of storage representing the table, T: num contains the number of items in the table, and T: size gives the total number of slots in the table. Initially, the table is empty: T:num D T:size D 0.
TABLE-INSERT.T;x/
1 ifT:size==0
2 allocate T:table with 1 slot
3 T:size D 1
4 if T:num == T:size
5 allocate new-table with 2 􏳵 T: size slots
6 insert all items in T:table into new-table
7 free T:table
8 T:table D new-table
9 T:size D 2 􏳵 T:size
10 insert x into T: table
11 T:numDT:numC1
1In some situations, such as an open-address hash table, we may wish to consider a table to be full if its load factor equals some constant strictly less than 1. (See Exercise 17.4-1.)

17.4 Dynamic tables 465
Notice that we have two “insertion” procedures here: the TABLE-INSERT proce- dure itself and the elementary insertion into a table in lines 6 and 10. We can analyze the running time of TABLE-INSERT in terms of the number of elementary insertions by assigning a cost of 1 to each elementary insertion. We assume that the actual running time of TABLE-INSERT is linear in the time to insert individual items, so that the overhead for allocating an initial table in line 2 is constant and the overhead for allocating and freeing storage in lines 5 and 7 is dominated by the cost of transferring items in line 6. We call the event in which lines 5–9 are executed an expansion.
Let us analyze a sequence of n TABLE-INSERT operations on an initially empty table. What is the cost ci of the ith operation? If the current table has room for the new item (or if this is the first operation), then ci D 1, since we need only perform the one elementary insertion in line 10. If the current table is full, however, and an expansion occurs, then ci D i: the cost is 1 for the elementary insertion in line 10 plus i 􏳣 1 for the items that we must copy from the old table to the new table in line 6. If we perform n operations, the worst-case cost of an operation is O.n/, which leads to an upper bound of O.n2/ on the total running time for n operations.
This bound is not tight, because we rarely expand the table in the course of n TABLE-INSERT operations. Specifically, the ith operation causes an expansion only when i 􏳣 1 is an exact power of 2. The amortized cost of an operation is in fact O.1/, as we can show using aggregate analysis. The cost of the ith operation is
(
i ifi􏳣1isanexactpowerof2; 1 otherwise :
ci D
The total cost of n TABLE-INSERT operations is therefore
n blgnc XXj
ci 􏳥 nC 2 iD1 jD0
< nC2n D 3n; because at most n operations cost 1 and the costs of the remaining operations form a geometric series. Since the total cost of n TABLE-INSERT operations is bounded by 3n, the amortized cost of a single operation is at most 3. By using the accounting method, we can gain some feeling for why the amor- tized cost of a TABLE-INSERT operation should be 3. Intuitively, each item pays for 3 elementary insertions: inserting itself into the current table, moving itself when the table expands, and moving another item that has already been moved once when the table expands. For example, suppose that the size of the table is m immediately after an expansion. Then the table holds m=2 items, and it contains 466 Chapter 17 Amortized Analysis no credit. We charge 3 dollars for each insertion. The elementary insertion that occurs immediately costs 1 dollar. We place another dollar as credit on the item inserted. We place the third dollar as credit on one of the m=2 items already in the table. The table will not fill again until we have inserted another m=2 􏳣 1 items, and thus, by the time the table contains m items and is full, we will have placed a dollar on each item to pay to reinsert it during the expansion. We can use the potential method to analyze a sequence of n TABLE-INSERT operations, and we shall use it in Section 17.4.2 to design a TABLE-DELETE op- eration that has an O.1/ amortized cost as well. We start by defining a potential function ˆ that is 0 immediately after an expansion but builds to the table size by the time the table is full, so that we can pay for the next expansion by the potential. The function ˆ.T / D 2 􏳵 T:num 􏳣 T:size (17.5) is one possibility. Immediately after an expansion, we have T:num D T:size=2, and thus ˆ.T/ D 0, as desired. Immediately before an expansion, we have T: num D T: size, and thus ˆ.T / D T: num, as desired. The initial value of the potential is 0, and since the table is always at least half full, T:num 􏳦 T:size=2, which implies that ˆ.T / is always nonnegative. Thus, the sum of the amortized costs of n TABLE-INSERT operations gives an upper bound on the sum of the actual costs. To analyze the amortized cost of the ith TABLE-INSERT operation, we let numi denote the number of items stored in the table after the ith operation, sizei denote the total size of the table after the ith operation, and ˆi denote the potential after the ith operation. Initially, we have num0 D 0, size0 D 0, and ˆ0 D 0. If the ith TABLE-INSERT operation does not trigger an expansion, then we have sizei D sizei􏳣1 and the amortized cost of the operation is cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D 1C.2􏳵numi 􏳣sizei/􏳣.2􏳵numi􏳣1 􏳣sizei􏳣1/ D 1C.2􏳵numi 􏳣sizei/􏳣.2.numi 􏳣1/􏳣sizei/ D3: If the i th operation does trigger an expansion, then we have sizei D 2 􏳵 sizei 􏳣1 and sizei􏳣1 D numi􏳣1 D numi 􏳣 1, which implies that sizei D 2 􏳵 .numi 􏳣 1/. Thus, the amortized cost of the operation is cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D numi C.2􏳵numi 􏳣sizei/􏳣.2􏳵numi􏳣1 􏳣sizei􏳣1/ D numi C.2􏳵numi 􏳣2􏳵.numi 􏳣1//􏳣.2.numi 􏳣1/􏳣.numi 􏳣1// D numi C2􏳣.numi 􏳣1/ D3: 17.4 Dynamic tables 467 32 24 16 8 0i 0 8 16 24 32 Figure 17.3 The effect of a sequence of n TABLE-INSERT operations on the number numi of items in the table, the number sizei of slots in the table, and the potential ˆi D 2 􏳵 numi 􏳣 sizei , each being measured after the i th operation. The thin line shows numi , the dashed line shows sizei , and the thick line shows ˆi . Notice that immediately before an expansion, the potential has built up to the number of items in the table, and therefore it can pay for moving all the items to the new table. Afterwards, the potential drops to 0, but it is immediately increased by 2 upon inserting the item that caused the expansion. Figure 17.3 plots the values of numi , sizei , and ˆi against i . Notice how the potential builds to pay for expanding the table. 17.4.2 Table expansion and contraction To implement a TABLE-DELETE operation, it is simple enough to remove the spec- ified item from the table. In order to limit the amount of wasted space, however, we might wish to contract the table when the load factor becomes too small. Table contraction is analogous to table expansion: when the number of items in the table drops too low, we allocate a new, smaller table and then copy the items from the old table into the new one. We can then free the storage for the old table by return- ing it to the memory-management system. Ideally, we would like to preserve two properties: the load factor of the dynamic table is bounded below by a positive constant, and the amortized cost of a table operation is bounded above by a constant. sizei numi Φi 􏳮 􏳮 468 Chapter 17 Amortized Analysis We assume that we measure the cost in terms of elementary insertions and dele- tions. You might think that we should double the table size upon inserting an item into a full table and halve the size when a deleting an item would cause the table to become less than half full. This strategy would guarantee that the load factor of the table never drops below 1=2, but unfortunately, it can cause the amortized cost of an operation to be quite large. Consider the following scenario. We perform n operations on a table T , where n is an exact power of 2. The first n=2 operations are insertions, which by our previous analysis cost a total of ‚.n/. At the end of this sequence of insertions, T:num D T:size D n=2. For the second n=2 operations, we perform the following sequence: insert, delete, delete, insert, insert, delete, delete, insert, insert, . . . . The first insertion causes the table to expand to size n. The two following deletions cause the table to contract back to size n=2. Two further insertions cause another expansion, and so forth. The cost of each expansion and contraction is ‚.n/, and there are ‚.n/ of them. Thus, the total cost of the n operations is ‚.n2/, making the amortized cost of an operation ‚.n/. The downside of this strategy is obvious: after expanding the table, we do not delete enough items to pay for a contraction. Likewise, after contracting the table, we do not insert enough items to pay for an expansion. We can improve upon this strategy by allowing the load factor of the table to drop below 1=2. Specifically, we continue to double the table size upon inserting an item into a full table, but we halve the table size when deleting an item causes the table to become less than 1=4 full, rather than 1=2 full as before. The load factor of the table is therefore bounded below by the constant 1=4. Intuitively, we would consider a load factor of 1=2 to be ideal, and the table’s potential would then be 0. As the load factor deviates from 1=2, the potential increases so that by the time we expand or contract the table, the table has garnered sufficient potential to pay for copying all the items into the newly allocated table. Thus, we will need a potential function that has grown to T:num by the time that the load factor has either increased to 1 or decreased to 1=4. After either expanding or contracting the table, the load factor goes back to 1=2 and the table’s potential reduces back to 0. We omit the code for TABLE-DELETE, since it is analogous to TABLE-INSERT. For our analysis, we shall assume that whenever the number of items in the table drops to 0, we free the storage for the table. That is, if T:num D 0, then T:size D 0. We can now use the potential method to analyze the cost of a sequence of n TABLE-INSERT and TABLE-DELETE operations. We start by defining a poten- tial function ˆ that is 0 immediately after an expansion or contraction and builds as the load factor increases to 1 or decreases to 1=4. Let us denote the load fac- 17.4 Dynamic tables 469 32 24 16 8 0i 0 8 16 24 32 40 48 Figure 17.4 The effect of a sequence of n TABLE-INSERT and TABLE-DELETE operations on the number numi of items in the table, the number sizei of slots in the table, and the potential 􏳴 ˆi D each measured after the i th operation. The thin line shows numi , the dashed line shows sizei , and the thick line shows ˆi . Notice that immediately before an expansion, the potential has built up to the number of items in the table, and therefore it can pay for moving all the items to the new table. Likewise, immediately before a contraction, the potential has built up to the number of items in the table. tor of a nonempty table T by ̨.T/ D T:num=T:size. Since for an empty table, T:num D T:size D 0 and ̨.T/ D 1, we always have T:num D ̨.T/ 􏳵 T:size, whether the table is empty or not. We shall use as our potential function ( ˆ.T/D 2􏳵T:num􏳣T:size if ̨.T/􏳦1=2; (17.6) T:size=2􏳣T:num if ̨.T/<1=2: Observe that the potential of an empty table is 0 and that the potential is never negative. Thus, the total amortized cost of a sequence of operations with respect to ˆ provides an upper bound on the actual cost of the sequence. Before proceeding with a precise analysis, we pause to observe some properties of the potential function, as illustrated in Figure 17.4. Notice that when the load factor is 1=2, the potential is 0. When the load factor is 1, we have T:size D T:num, which implies ˆ.T / D T: num, and thus the potential can pay for an expansion if an item is inserted. When the load factor is 1=4, we have T:size D 4􏳵T:num, which sizei numi Φi 2􏳵numi 􏳣sizei if ̨i 􏳦1=2; sizei=2􏳣numi if ̨i <1=2; 470 Chapter 17 Amortized Analysis implies ˆ.T / D T: num, and thus the potential can pay for a contraction if an item is deleted. To analyze a sequence of n TABLE-INSERT and TABLE-DELETE operations, we let c denote the actual cost of the ith operation, cy denote its amortized cost ii with respect to ˆ, numi denote the number of items stored in the table after the ith operation, sizei denote the total size of the table after the ith operation, ̨i denote the load factor of the table after the ith operation, and ˆi denote the potential after the ith operation. Initially, num0 D 0, size0 D 0, ̨0 D 1, and ˆ0 D 0. We start with the case in which the ith operation is TABLE-INSERT. The analy- sis is identical to that for table expansion in Section 17.4.1 if ̨i􏳣1 􏳦 1=2. Whether the table expands or not, the amortized cost cy of the operation is at most 3. i If ̨i􏳣1 < 1=2, the table cannot expand as a result of the operation, since the ta- ble expands only when ̨i􏳣1 D 1. If ̨i < 1=2 as well, then the amortized cost of the ith operation is cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D 1C.sizei=2􏳣numi/􏳣.sizei􏳣1=2􏳣numi􏳣1/ D 1C.sizei=2􏳣numi/􏳣.sizei=2􏳣.numi 􏳣1// D0: If ̨i􏳣1 <1=2but ̨i 􏳦1=2,then cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D 1 C .2 􏳵 numi 􏳣 sizei / 􏳣 .sizei􏳣1=2 􏳣 numi􏳣1/ D 1 C .2.numi􏳣1 C 1/ 􏳣 sizei􏳣1/ 􏳣 .sizei􏳣1=2 􏳣 numi􏳣1/ D 3􏳵numi􏳣1􏳣3sizei􏳣1C3 2 D 3 ̨i􏳣1sizei􏳣1 􏳣 3sizei􏳣1 C 3 2 < 3sizei􏳣1 􏳣 3sizei􏳣1 C 3 22 D3: Thus, the amortized cost of a TABLE-INSERT operation is at most 3. We now turn to the case in which the ith operation is TABLE-DELETE. In this case, numi D numi􏳣1 􏳣 1. If ̨i􏳣1 < 1=2, then we must consider whether the operation causes the table to contract. If it does not, then sizei D sizei􏳣1 and the amortized cost of the operation is cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D 1C.sizei=2􏳣numi/􏳣.sizei􏳣1=2􏳣numi􏳣1/ D 1C.sizei=2􏳣numi/􏳣.sizei=2􏳣.numi C1// D2: 17.4 Dynamic tables 471 If ̨i􏳣1 < 1=2 and the ith operation does trigger a contraction, then the actual cost of the operation is ci D numi C 1, since we delete one item and move numi items. We have sizei =2 D sizei􏳣1=4 D numi􏳣1 D numi C 1, and the amortized cost of the operation is cy D c C ˆ 􏳣 ˆ i i i i􏳣1 D .numi C1/C.sizei=2􏳣numi/􏳣.sizei􏳣1=2􏳣numi􏳣1/ D .numi C1/C..numi C1/􏳣numi/􏳣..2􏳵numi C2/􏳣.numi C1// D1: When the ith operation is a TABLE-DELETE and ̨i􏳣1 􏳦 1=2, the amortized cost is also bounded above by a constant. We leave the analysis as Exercise 17.4-2. In summary, since the amortized cost of each operation is bounded above by a constant, the actual time for any sequence of n operations on a dynamic table is O.n/. Exercises 17.4-1 Suppose that we wish to implement a dynamic, open-address hash table. Why might we consider the table to be full when its load factor reaches some value ̨ that is strictly less than 1? Describe briefly how to make insertion into a dynamic, open-address hash table run in such a way that the expected value of the amortized cost per insertion is O.1/. Why is the expected value of the actual cost per insertion not necessarily O.1/ for all insertions? 17.4-2 Show that if ̨i􏳣1 􏳦 1=2 and the ith operation on a dynamic table is TABLE- DELETE, then the amortized cost of the operation with respect to the potential function (17.6) is bounded above by a constant. 17.4-3 Suppose that instead of contracting a table by halving its size when its load factor drops below 1=4, we contract it by multiplying its size by 2=3 when its load factor drops below 1=3. Using the potential function ˆ.T/Dj2􏳵T:num􏳣T:sizej ; show that the amortized cost of a TABLE-DELETE that uses this strategy is bounded above by a constant. 472 Chapter 17 Amortized Analysis Problems 17-1 Bit-reversed binary counter Chapter 30 examines an important algorithm called the fast Fourier transform, or FFT. The first step of the FFT algorithm performs a bit-reversal permutation on aninputarrayAŒ0::n􏳣1􏳩whoselengthisnD2k forsomenonnegativeintegerk. This permutation swaps elements whose indices have binary representations that are the reverse of each other. We can express each index a as a k-bit sequence hak􏳣1; ak􏳣2; : : : ; a0i, where aDPk􏳣1ai 2i.Wedefine iD0 revk.hak􏳣1;ak􏳣2;:::;a0i/ D ha0;a1;:::;ak􏳣1i I thus, revk.a/ D For example, if n D 16 (or, equivalently, k D 4), then revk.3/ D 12, since the 4-bit representation of 3 is 0011, which when reversed gives 1100, the 4-bit representation of 12. a. Given a function revk that runs in ‚.k/ time, write an algorithm to perform the bit-reversal permutation on an array of length n D 2k in O.nk/ time. We can use an algorithm based on an amortized analysis to improve the running time of the bit-reversal permutation. We maintain a “bit-reversed counter” and a procedure BIT-REVERSED-INCREMENT that, when given a bit-reversed-counter value a, produces revk .revk .a/ C 1/. If k D 4, for example, and the bit-reversed counter starts at 0, then successive calls to BIT-REVERSED-INCREMENT produce the sequence 0000;1000;0100;1100;0010;1010;::: D 0;8;4;12;2;10;::: : b. Assume that the words in your computer store k-bit values and that in unit time, your computer can manipulate the binary values with operations such as shifting left or right by arbitrary amounts, bitwise-AND, bitwise-OR, etc. Describe an implementation of the BIT-REVERSED-INCREMENT procedure that allows the bit-reversal permutation on an n-element array to be performed in a total of O.n/ time. c. Suppose that you can shift a word left or right by only one bit in unit time. Is it still possible to implement an O.n/-time bit-reversal permutation? k􏳣1 Xi iD0 ak􏳣i􏳣12 : Problems for Chapter 17 473 17-2 Making binary search dynamic Binary search of a sorted array takes logarithmic search time, but the time to insert a new element is linear in the size of the array. We can improve the time for insertion by keeping several sorted arrays. Specifically, suppose that we wish to support SEARCH and INSERT on a set of n elements. Let k D dlg.n C 1/e, and let the binary representation of n be hnk􏳣1; nk􏳣2; :::; n0i. We have k sorted arrays A0;A1;:::;Ak􏳣1, where for iD0;1;:::;k􏳣1,thelengthofarrayAi is2i.Eacharrayiseitherfullorempty, depending on whether ni D 1 or ni D 0, respectively. The total number of ele- ments held in all k arrays is therefore Pk􏳣1 ni 2i D n. Although each individual iD0 array is sorted, elements in different arrays bear no particular relationship to each other. a. DescribehowtoperformtheSEARCHoperationforthisdatastructure.Analyze its worst-case running time. b. Describe how to perform the INSERT operation. Analyze its worst-case and amortized running times. c. Discuss how to implement DELETE. 17-3 Amortized weight-balanced trees Consider an ordinary binary search tree augmented by adding to each node x the attribute x:size giving the number of keys stored in the subtree rooted at x. Let ̨ be a constant in the range 1=2 􏳥 ̨ < 1. We say that a given node x is ̨-balanced if x:left:size 􏳥 ̨ 􏳵 x:size and x:right:size 􏳥 ̨ 􏳵 x:size. The tree as a whole is ̨-balanced if every node in the tree is ̨-balanced. The following amortized approach to maintaining weight-balanced trees was suggested by G. Varghese. a. A 1=2-balanced tree is, in a sense, as balanced as it can be. Given a node x in an arbitrary binary search tree, show how to rebuild the subtree rooted at x so that it becomes 1=2-balanced. Your algorithm should run in time ‚.x:size/, and it can use O.x:size/ auxiliary storage. b. Show that performing a search in an n-node ̨-balanced binary search tree takes O.lg n/ worst-case time. For the remainder of this problem, assume that the constant ̨ is strictly greater than 1=2. Suppose that we implement INSERT and DELETE as usual for an n-node binary search tree, except that after every such operation, if any node in the tree is no longer ̨-balanced, then we “rebuild” the subtree rooted at the highest such node in the tree so that it becomes 1=2-balanced. 474 Chapter 17 Amortized Analysis We shall analyze this rebuilding scheme using the potential method. For a node x in a binary search tree T , we define 􏳱.x/ D jx:left:size 􏳣 x:right:sizej ; and we define the potential of T as X ˆ.T / D c x2T W􏳱.x/􏳦2 where c is a sufficiently large constant that depends on ̨. c. Argue that any binary search tree has nonnegative potential and that a 1=2- balanced tree has potential 0. d. Suppose that m units of potential can pay for rebuilding an m-node subtree. How large must c be in terms of ̨ in order for it to take O.1/ amortized time to rebuild a subtree that is not ̨-balanced? e. Show that inserting a node into or deleting a node from an n-node ̨-balanced tree costs O.lg n/ amortized time. 17-4 The cost of restructuring red-black trees There are four basic operations on red-black trees that perform structural modi- fications: node insertions, node deletions, rotations, and color changes. We have seen that RB-INSERT and RB-DELETE use only O.1/ rotations, node insertions, and node deletions to maintain the red-black properties, but they may make many more color changes. a. Describe a legal red-black tree with n nodes such that calling RB-INSERT to add the .n C 1/st node causes 􏳫.lg n/ color changes. Then describe a legal red-black tree with n nodes for which calling RB-DELETE on a particular node causes 􏳫.lg n/ color changes. Although the worst-case number of color changes per operation can be logarithmic, we shall prove that any sequence of m RB-INSERT and RB-DELETE operations on an initially empty red-black tree causes O.m/ structural modifications in the worst case. Note that we count each color change as a structural modification. b. Some of the cases handled by the main loop of the code of both RB-INSERT- FIXUP and RB-DELETE-FIXUP are terminating: once encountered, they cause the loop to terminate after a constant number of additional operations. For each of the cases of RB-INSERT-FIXUP and RB-DELETE-FIXUP, specify which are terminating and which are not. (Hint: Look at Figures 13.5, 13.6, and 13.7.) 􏳱.x/ ; Problems for Chapter 17 475 We shall first analyze the structural modifications when only insertions are per- formed. Let T be a red-black tree, and define ˆ.T / to be the number of red nodes in T . Assume that 1 unit of potential can pay for the structural modifications per- formed by any of the three cases of RB-INSERT-FIXUP. c. Let T 0 be the result of applying Case 1 of RB-INSERT-FIXUP to T . Argue that ˆ.T 0/ D ˆ.T / 􏳣 1. d. When we insert a node into a red-black tree using RB-INSERT, we can break the operation into three parts. List the structural modifications and potential changes resulting from lines 1–16 of RB-INSERT, from nonterminating cases of RB-INSERT-FIXUP, and from terminating cases of RB-INSERT-FIXUP. e. Using part (d), argue that the amortized number of structural modifications per- formed by any call of RB-INSERT is O.1/. We now wish to prove that there are O.m/ structural modifications when there are both inse„rtions and deletions. Let us define, for each node x, w.x/ D 0 ifxisred; 1 if x is black and has no red children ; 0 ifxisblackandhasoneredchild; 2 if x is black and has two red children : Now we redefine the potential of a red-black tree T as X w.x/ ; and let T 0 be the tree that results from applying any nonterminating case of RB- INSERT-FIXUP or RB-DELETE-FIXUP to T . f. Show that ˆ.T 0/ 􏳥 ˆ.T / 􏳣 1 for all nonterminating cases of RB-INSERT- FIXUP. Argue that the amortized number of structural modifications performed by any call of RB-INSERT-FIXUP is O.1/. g. Show that ˆ.T 0/ 􏳥 ˆ.T / 􏳣 1 for all nonterminating cases of RB-DELETE- FIXUP. Argue that the amortized number of structural modifications performed by any call of RB-DELETE-FIXUP is O.1/. h. Complete the proof that in the worst case, any sequence of m RB-INSERT and RB-DELETE operations performs O.m/ structural modifications. ˆ.T / D x2T 476 Chapter 17 Amortized Analysis 17-5 Competitive analysis of self-organizing lists with move-to-front A self-organizing list is a linked list of n elements, in which each element has a unique key. When we search for an element in the list, we are given a key, and we want to find an element with that key. A self-organizing list has two important properties: 1. To find an element in the list, given its key, we must traverse the list from the beginning until we encounter the element with the given key. If that element is the kth element from the start of the list, then the cost to find the element is k. 2. We may reorder the list elements after any operation, according to a given rule with a given cost. We may choose any heuristic we like to decide how to reorder the list. Assume that we start with a given list of n elements, and we are given an access sequence 􏳯 D h􏳯1; 􏳯2; : : : ; 􏳯mi of keys to find, in order. The cost of the sequence is the sum of the costs of the individual accesses in the sequence. Out of the various possible ways to reorder the list after an operation, this prob- lem focuses on transposing adjacent list elements—switching their positions in the list—with a unit cost for each transpose operation. You will show, by means of a potential function, that a particular heuristic for reordering the list, move-to-front, entails a total cost no worse than 4 times that of any other heuristic for maintaining the list order—even if the other heuristic knows the access sequence in advance! We call this type of analysis a competitive analysis. For a heuristic H and a given initial ordering of the list, denote the access cost of sequence 􏳯 by CH .􏳯 /. Let m be the number of accesses in 􏳯 . a. Argue that if heuristic H does not know the access sequence in advance, then the worst-case cost for H on an access sequence 􏳯 is CH .􏳯/ D 􏳫.mn/. With the move-to-front heuristic, immediately after searching for an element x, we move x to the first position on the list (i.e., the front of the list). Let rankL.x/ denote the rank of element x in list L, that is, the position of x in list L. For example, if x is the fourth element in L, then rankL.x/ D 4. Let ci denote the cost of access 􏳯i using the move-to-front heuristic, which includes the cost of finding the element in the list and the cost of moving it to the front of the list by a series of transpositions of adjacent list elements. b. Show that if 􏳯i accesses element x in list L using the move-to-front heuristic, thenci D2􏳵rankL.x/􏳣1. Now we compare move-to-front with any other heuristic H that processes an access sequence according to the two properties above. Heuristic H may transpose Problems for Chapter 17 477 elements in the list in any way it wants, and it might even know the entire access sequence in advance. Let Li be the list after access 􏳯i using move-to-front, and let L􏳤i be the list after access 􏳯i using heuristic H. We denote the cost of access 􏳯i by ci for move-to- front and by ci􏳤 for heuristic H. Suppose that heuristic H performs ti􏳤 transpositions during access 􏳯i . c. In part (b), you showed that ci D 2 􏳵 rankLi􏳣1 .x/ 􏳣 1. Now show that ci􏳤 D r a n k L 􏳤i 􏳣 1 . x / C t i 􏳤 . We define an inversion in list Li as a pair of elements y and ́ such that y precedes ́ in Li and ́ precedes y in list L􏳤i . Suppose that list Li has qi inversions after processing the access sequence h􏳯1; 􏳯2; : : : ; 􏳯i i. Then, we define a potential function ˆ that maps Li to a real number by ˆ.Li / D 2qi . For example, if Li has the elements he; c; a; d; bi and L􏳤i has the elements hc; a; b; d; ei, then Li has 5 inversions (.e;c/;.e;a/;.e;d/;.e;b/;.d;b/), and so ˆ.Li/ D 10. Observe that ˆ.Li / 􏳦 0 for all i and that, if move-to-front and heuristic H start with the same list L0, then ˆ.L0/ D 0. d. Argue that a transposition either increases the potential by 2 or decreases the potential by 2. Suppose that access 􏳯i finds the element x. To understand how the potential changes due to 􏳯i , let us partition the elements other than x into four sets, depend- ing on where they are in the lists just before the ith access: Set A consists of elements that precede x in both Li􏳣1 and L􏳤i􏳣1. Set B consists of elements that precede x in Li􏳣1 and follow x in L􏳤i􏳣1. Set C consists of elements that follow x in Li􏳣1 and precede x in L􏳤i􏳣1. Set D consists of elements that follow x in both Li􏳣1 and L􏳤i􏳣1. e. A r g u e t h a t r a n k L i 􏳣 1 . x / D j A j C j B j C 1 a n d r a n k L 􏳤i 􏳣 1 . x / D j A j C j C j C 1 . f. Show that access 􏳯i causes a change in potential of ˆ . L i / 􏳣 ˆ . L i 􏳣 1 / 􏳥 2 . j A j 􏳣 j B j C t i􏳤 / ; where, as before, heuristic H performs ti􏳤 transpositions during access 􏳯i . Definetheamortizedcostcy ofaccess􏳯 bycy Dc Cˆ.L/􏳣ˆ.L /. i i i i i i􏳣1 g. Show that the amortized cost cy of access 􏳯 is bounded from above by 4c􏳤. h. Conclude that the cost CMTF.􏳯/ of access sequence 􏳯 with move-to-front is at most 4 times the cost CH.􏳯/ of 􏳯 with any other heuristic H, assuming that both heuristics start with the same list. 􏳮 􏳮 􏳮 􏳮 ii i 478 Chapter 17 Amortized Analysis Chapter notes Aho, Hopcroft, and Ullman [5] used aggregate analysis to determine the running time of operations on a disjoint-set forest; we shall analyze this data structure us- ing the potential method in Chapter 21. Tarjan [331] surveys the accounting and potential methods of amortized analysis and presents several applications. He at- tributes the accounting method to several authors, including M. R. Brown, R. E. Tarjan, S. Huddleston, and K. Mehlhorn. He attributes the potential method to D. D. Sleator. The term “amortized” is due to D. D. Sleator and R. E. Tarjan. Potential functions are also useful for proving lower bounds for certain types of problems. For each configuration of the problem, we define a potential function that maps the configuration to a real number. Then we determine the potential ˆinit of the initial configuration, the potential ˆfinal of the final configuration, and the maximum change in potential 􏳱ˆmax due to any step. The number of steps must therefore be at least jˆfinal 􏳣ˆinitj=j􏳱ˆmaxj. Examples of potential functions to prove lower bounds in I/O complexity appear in works by Cormen, Sundquist, and Wisniewski [79]; Floyd [107]; and Aggarwal and Vitter [3]. Krumme, Cybenko, and Venkataraman [221] applied potential functions to prove lower bounds on gos- siping: communicating a unique item from each vertex in a graph to every other vertex. The move-to-front heuristic from Problem 17-5 works quite well in practice. Moreover, if we recognize that when we find an element, we can splice it out of its position in the list and relocate it to the front of the list in constant time, we can show that the cost of move-to-front is at most twice the cost of any other heuristic including, again, one that knows the entire access sequence in advance. V Advanced Data Structures Introduction This part returns to studying data structures that support operations on dynamic sets, but at a more advanced level than Part III. Two of the chapters, for example, make extensive use of the amortized analysis techniques we saw in Chapter 17. Chapter 18 presents B-trees, which are balanced search trees specifically de- signed to be stored on disks. Because disks operate much more slowly than random-access memory, we measure the performance of B-trees not only by how much computing time the dynamic-set operations consume but also by how many disk accesses they perform. For each B-tree operation, the number of disk accesses increases with the height of the B-tree, but B-tree operations keep the height low. Chapter 19 gives an implementation of a mergeable heap, which supports the operations INSERT, MINIMUM, EXTRACT-MIN, and UNION.1 The UNION oper- ation unites, or merges, two heaps. Fibonacci heaps—the data structure in Chap- ter 19—also support the operations DELETE and DECREASE-KEY. We use amor- tized time bounds to measure the performance of Fibonacci heaps. The opera- tions INSERT, MINIMUM, and UNION take only O.1/ actual and amortized time on Fibonacci heaps, and the operations EXTRACT-MIN and DELETE take O.lg n/ amortized time. The most significant advantage of Fibonacci heaps, however, is that DECREASE-KEY takes only O.1/ amortized time. Because the DECREASE- 1As in Problem 10-2, we have defined a mergeable heap to support MINIMUM and EXTRACT-MIN, and so we can also refer to it as a mergeable min-heap. Alternatively, if it supported MAXIMUM and EXTRACT-MAX, it would be a mergeable max-heap. Unless we specify otherwise, mergeable heaps will be by default mergeable min-heaps. 482 Part V Advanced Data Structures KEY operation takes constant amortized time, Fibonacci heaps are key components of some of the asymptotically fastest algorithms to date for graph problems. Noting that we can beat the 􏳫.n lg n/ lower bound for sorting when the keys are integers in a restricted range, Chapter 20 asks whether we can design a data structure that supports the dynamic-set operations SEARCH, INSERT, DELETE, MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR in o.lgn/ time when the keys are integers in a restricted range. The answer turns out to be that we can, by using a recursive data structure known as a van Emde Boas tree. If the keys are unique integers drawn from the set f0; 1; 2; : : : ; u 􏳣 1g, where u is an exact power of 2, then van Emde Boas trees support each of the above operations in O.lg lg u/ time. Finally, Chapter 21 presents data structures for disjoint sets. We have a universe of n elements that are partitioned into dynamic sets. Initially, each element belongs to its own singleton set. The operation UNION unites two sets, and the query FIND- SET identifies the unique set that contains a given element at the moment. By representing each set as a simple rooted tree, we obtain surprisingly fast operations: a sequence of m operations runs in O.m ̨.n// time, where ̨.n/ is an incredibly slowly growing function— ̨.n/ is at most 4 in any conceivable application. The amortized analysis that proves this time bound is as complex as the data structure is simple. The topics covered in this part are by no means the only examples of “advanced” data structures. Other advanced data structures include the following: Dynamic trees, introduced by Sleator and Tarjan [319] and discussed by Tarjan [330], maintain a forest of disjoint rooted trees. Each edge in each tree has a real-valued cost. Dynamic trees support queries to find parents, roots, edge costs, and the minimum edge cost on a simple path from a node up to a root. Trees may be manipulated by cutting edges, updating all edge costs on a simple path from a node up to a root, linking a root into another tree, and making a node the root of the tree it appears in. One implementation of dynamic trees gives an O.lg n/ amortized time bound for each operation; a more complicated implementation yields O.lg n/ worst-case time bounds. Dynamic trees are used in some of the asymptotically fastest network-flow algorithms. Splay trees, developed by Sleator and Tarjan [320] and, again, discussed by Tarjan [330], are a form of binary search tree on which the standard search- tree operations run in O.lg n/ amortized time. One application of splay trees simplifies dynamic trees. Persistent data structures allow queries, and sometimes updates as well, on past versions of a data structure. Driscoll, Sarnak, Sleator, and Tarjan [97] present techniques for making linked data structures persistent with only a small time 􏳮 􏳮 􏳮 Part V Advanced Data Structures 483 and space cost. Problem 13-1 gives a simple example of a persistent dynamic set. As in Chapter 20, several data structures allow a faster implementation of dic- tionary operations (INSERT, DELETE, and SEARCH) for a restricted universe of keys. By taking advantage of these restrictions, they are able to achieve bet- ter worst-case asymptotic running times than comparison-based data structures. Fredman and Willard introduced fusion trees [115], which were the first data structure to allow faster dictionary operations when the universe is restricted to integers. They showed how to implement these operations in O.lg n= lg lg n/ time. Several subsequent data structures, including exponential search trees [16], have also given improved bounds on some or all of the dictionary opera- tions and are mentioned in the chapter notes throughout this book. Dynamic graph data structures support various queries while allowing the structure of a graph to change through operations that insert or delete vertices or edges. Examples of the queries that they support include vertex connectivity [166], edge connectivity, minimum spanning trees [165], biconnectivity, and transitive closure [164]. Chapter notes throughout this book mention additional data structures. 􏳮 􏳮 18 B-Trees B-trees are balanced search trees designed to work well on disks or other direct- access secondary storage devices. B-trees are similar to red-black trees (Chap- ter 13), but they are better at minimizing disk I/O operations. Many database sys- tems use B-trees, or variants of B-trees, to store information. B-trees differ from red-black trees in that B-tree nodes may have many children, from a few to thousands. That is, the “branching factor” of a B-tree can be quite large, although it usually depends on characteristics of the disk unit used. B-trees are similar to red-black trees in that every n-node B-tree has height O.lg n/. The exact height of a B-tree can be considerably less than that of a red-black tree, however, because its branching factor, and hence the base of the logarithm that expresses its height, can be much larger. Therefore, we can also use B-trees to implement many dynamic-set operations in time O.lg n/. B-trees generalize binary search trees in a natural manner. Figure 18.1 shows a simple B-tree. If an internal B-tree node x contains x:n keys, then x has x:n C 1 children. The keys in node x serve as dividing points separating the range of keys handled by x into x:n C 1 subranges, each handled by one child of x. When searching for a key in a B-tree, we make an .x:n C 1/-way decision based on comparisons with the x:n keys stored at node x. The structure of leaf nodes differs from that of internal nodes; we will examine these differences in Section 18.1. Section 18.1 gives a precise definition of B-trees and proves that the height of a B-tree grows only logarithmically with the number of nodes it contains. Sec- tion 18.2 describes how to search for a key and insert a key into a B-tree, and Section 18.3 discusses deletion. Before proceeding, however, we need to ask why we evaluate data structures designed to work on a disk differently from data struc- tures designed to work in main random-access memory. Data structures on secondary storage Computer systems take advantage of various technologies that provide memory capacity. The primary memory (or main memory) of a computer system normally Chapter 18 B-Trees 485 T: root M DH QTX BCFGJKL NPRSVWYZ Figure 18.1 A B-tree whose keys are the consonants of English. An internal node x containing x: n keys has x: n C 1 children. All leaves are at the same depth in the tree. The lightly shaded nodes are examined in a search for the letter R. spindle platter track read/write head arms Figure 18.2 A typical disk drive. It comprises one or more platters (two platters are shown here) that rotate around a spindle. Each platter is read and written with a head at the end of an arm. Arms rotate around a common pivot axis. A track is the surface that passes beneath the read/write head when the head is stationary. consists of silicon memory chips. This technology is typically more than an order of magnitude more expensive per bit stored than magnetic storage technology, such as tapes or disks. Most computer systems also have secondary storage based on magnetic disks; the amount of such secondary storage often exceeds the amount of primary memory by at least two orders of magnitude. Figure 18.2 shows a typical disk drive. The drive consists of one or more plat- ters, which rotate at a constant speed around a common spindle. A magnetizable material covers the surface of each platter. The drive reads and writes each platter by a head at the end of an arm. The arms can move their heads toward or away 486 Chapter 18 B-Trees from the spindle. When a given head is stationary, the surface that passes under- neath it is called a track. Multiple platters increase only the disk drive’s capacity and not its performance. Although disks are cheaper and have higher capacity than main memory, they are much,muchslowerbecausetheyhavemovingmechanicalparts.1 Themechanical motion has two components: platter rotation and arm movement. As of this writing, commodity disks rotate at speeds of 5400–15,000 revolutions per minute (RPM). We typically see 15,000 RPM speeds in server-grade drives, 7200 RPM speeds in drives for desktops, and 5400 RPM speeds in drives for laptops. Although 7200 RPM may seem fast, one rotation takes 8.33 milliseconds, which is over 5 orders of magnitude longer than the 50 nanosecond access times (more or less) commonly found for silicon memory. In other words, if we have to wait a full rota- tion for a particular item to come under the read/write head, we could access main memory more than 100,000 times during that span. On average we have to wait for only half a rotation, but still, the difference in access times for silicon memory compared with disks is enormous. Moving the arms also takes some time. As of this writing, average access times for commodity disks are in the range of 8 to 11 milliseconds. In order to amortize the time spent waiting for mechanical movements, disks access not just one item but several at a time. Information is divided into a number of equal-sized pages of bits that appear consecutively within tracks, and each disk read or write is of one or more entire pages. For a typical disk, a page might be 211 to 214 bytes in length. Once the read/write head is positioned correctly and the disk has rotated to the beginning of the desired page, reading or writing a magnetic disk is entirely electronic (aside from the rotation of the disk), and the disk can quickly read or write large amounts of data. Often, accessing a page of information and reading it from a disk takes longer than examining all the information read. For this reason, in this chapter we shall look separately at the two principal components of the running time: the number of disk accesses, and the CPU (computing) time. We measure the number of disk accesses in terms of the number of pages of infor- mation that need to be read from or written to the disk. We note that disk-access time is not constant—it depends on the distance between the current track and the desired track and also on the initial rotational position of the disk. We shall 1As of this writing, solid-state drives have recently come onto the consumer market. Although they are faster than mechanical disk drives, they cost more per gigabyte and have lower capacities than mechanical disk drives. 􏳮 􏳮 Chapter 18 B-Trees 487 nonetheless use the number of pages read or written as a first-order approximation of the total time spent accessing the disk. In a typical B-tree application, the amount of data handled is so large that all the data do not fit into main memory at once. The B-tree algorithms copy selected pages from disk into main memory as needed and write back onto disk the pages that have changed. B-tree algorithms keep only a constant number of pages in main memory at any time; thus, the size of main memory does not limit the size of B-trees that can be handled. We model disk operations in our pseudocode as follows. Let x be a pointer to an object. If the object is currently in the computer’s main memory, then we can refer to the attributes of the object as usual: x:key, for example. If the object referred to by x resides on disk, however, then we must perform the operation DISK-READ.x/ to read object x into main memory before we can refer to its attributes. (We as- sume that if x is already in main memory, then DISK-READ.x/ requires no disk accesses; it is a “no-op.”) Similarly, the operation DISK-WRITE.x/ is used to save any changes that have been made to the attributes of object x. That is, the typical pattern for working with an object is as follows: x D a pointer to some object DISK-READ.x/ operations that access and/or modify the attributes of x DISK-WRITE.x/ //omitted if no attributes of x were changed other operations that access but do not modify attributes of x The system can keep only a limited number of pages in main memory at any one time. We shall assume that the system flushes from main memory pages no longer in use; our B-tree algorithms will ignore this issue. Since in most systems the running time of a B-tree algorithm depends primar- ily on the number of DISK-READ and DISK-WRITE operations it performs, we typically want each of these operations to read or write as much information as possible. Thus, a B-tree node is usually as large as a whole disk page, and this size limits the number of children a B-tree node can have. For a large B-tree stored on a disk, we often see branching factors between 50 and 2000, depending on the size of a key relative to the size of a page. A large branching factor dramatically reduces both the height of the tree and the number of disk accesses required to find any key. Figure 18.3 shows a B-tree with a branching factor of 1001 and height 2 that can store over one billion keys; nevertheless, since we can keep the root node permanently in main memory, we can find any key in this tree by making at most only two disk accesses. 488 Chapter 18 B-Trees 1000 1001 1000 1000 T: root 1000 1001 ... ... 1000 1 node, 1000 keys 1001 nodes, 1,001,000 keys 1,002,001 nodes, 1,002,001,000 keys 1000 1001 1000 1001 A B-tree of height 2 containing over one billion keys. Shown inside each node x is x:n, the number of keys in x. Each internal node and leaf contains 1000 keys. This B-tree has 1001 nodes at depth 1 and over one million leaves at depth 2. Definition of B-trees To keep things simple, we assume, as we have for binary search trees and red-black trees, that any “satellite information” associated with a key resides in the same node as the key. In practice, one might actually store with each key just a pointer to another disk page containing the satellite information for that key. The pseudocode in this chapter implicitly assumes that the satellite information associated with a key, or the pointer to such satellite information, travels with the key whenever the key is moved from node to node. A common variant on a B-tree, known as a BC-tree, stores all the satellite information in the leaves and stores only keys and child pointers in the internal nodes, thus maximizing the branching factor of the internal nodes. A B-tree T is a rooted tree (whose root is T:root) having the following proper- ties: 1. Every node x has the following attributes: a. x:n, the number of keys currently stored in node x, b. the x:n keys themselves, x:key1;x:key2;:::;x:keyx:n, stored in nondecreas- ing order, so that x:key1 􏳥 x:key2 􏳥 􏳵􏳵􏳵 􏳥 x:keyx:n, c. x:leaf , a boolean value that is TRUE if x is a leaf and FALSE if x is an internal node. 2. Each internal node x also contains x:nC1 pointers x:c1;x:c2;:::;x:cx:nC1 to its children. Leaf nodes have no children, and so their ci attributes are unde- fined. Figure 18.3 18.1 18.1 Definition of B-trees 489 3. The keys x:keyi separate the ranges of keys stored in each subtree: if ki is any key stored in the subtree with root x:ci, then k1 􏳥 x:key1 􏳥 k2 􏳥 x:key2 􏳥 􏳵􏳵􏳵 􏳥 x:keyx:n 􏳥 kx:nC1 : 4. All leaves have the same depth, which is the tree’s height h. 5. Nodes have lower and upper bounds on the number of keys they can contain. We express these bounds in terms of a fixed integer t 􏳦 2 called the minimum degree of the B-tree: a. Every node other than the root must have at least t 􏳣 1 keys. Every internal node other than the root thus has at least t children. If the tree is nonempty, the root must have at least one key. b. Every node may contain at most 2t 􏳣 1 keys. Therefore, an internal node may have at most 2t children. We say that a node is full if it contains exactly 2t 􏳣 1 keys.2 The simplest B-tree occurs when t D 2. Every internal node then has either 2, 3, or 4 children, and we have a 2-3-4 tree. In practice, however, much larger values of t yield B-trees with smaller height. The height of a B-tree The number of disk accesses required for most operations on a B-tree is propor- tional to the height of the B-tree. We now analyze the worst-case height of a B-tree. Theorem 18.1 If n 􏳦 1, then for any n-key B-tree T of height h and minimum degree t 􏳦 2, h􏳥log nC1: Proof The root of a B-tree T contains at least one key, and all other nodes contain atleastt􏳣1keys. Thus,T,whoseheightish,hasatleast2nodesatdepth1,at least 2t nodes at depth 2, at least 2t2 nodes at depth 3, and so on, until at depth h it has at least 2th􏳣1 nodes. Figure 18.4 illustrates such a tree for h D 3. Thus, the 2Another common variant on a B-tree, known as a B􏳤-tree, requires each internal node to be at least 2=3 full, rather than at least half full, as a B-tree requires. t2 490 Chapter 18 B-Trees T: root t –1 t –1 1 2 tt depth 101 number of nodes ... t – 1 t – 1 ... t – 1 2 2t ... t – 1 t – 1 ... t – 1 t – 1 ... t – 1 t – 1 ... t – 1 3 2t2 t – 1 tttt t – 1 Figure 18.4 A B-tree of height 3 containing a minimum possible number of keys. Shown inside each node x is x:n. number n of keys satisfies the inequality Xh n 􏳦 1C.t􏳣1/ 2ti􏳣1 iD1 􏳧th 􏳣1􏳹 D 1C2.t􏳣1/ t􏳣1 D 2th􏳣1: By simple algebra, we get th 􏳥 .n C 1/=2. Taking base-t logarithms of both sides proves the theorem. Here we see the power of B-trees, as compared with red-black trees. Although the height of the tree grows as O.lg n/ in both cases (recall that t is a constant), for B-trees the base of the logarithm can be many times larger. Thus, B-trees save a factor of about lg t over red-black trees in the number of nodes examined for most tree operations. Because we usually have to access the disk to examine an arbitrary node in a tree, B-trees avoid a substantial number of disk accesses. Exercises 18.1-1 Why don’t we allow a minimum degree of t D 1? 18.1-2 For what values of t is the tree of Figure 18.1 a legal B-tree? 18.2 Basic operations on B-trees 491 18.1-3 Show all legal B-trees of minimum degree 2 that represent f1; 2; 3; 4; 5g. 18.1-4 As a function of the minimum degree t, what is the maximum number of keys that can be stored in a B-tree of height h? 18.1-5 Describe the data structure that would result if each black node in a red-black tree were to absorb its red children, incorporating their children with its own. 18.2 Basic operations on B-trees In this section, we present the details of the operations B-TREE-SEARCH, B- TREE-CREATE, and B-TREE-INSERT. In these procedures, we adopt two con- ventions: The root of the B-tree is always in main memory, so that we never need to perform a DISK-READ on the root; we do have to perform a DISK-WRITE of the root, however, whenever the root node is changed. Any nodes that are passed as parameters must already have had a DISK-READ operation performed on them. The procedures we present are all “one-pass” algorithms that proceed downward from the root of the tree, without having to back up. Searching a B-tree Searching a B-tree is much like searching a binary search tree, except that instead of making a binary, or “two-way,” branching decision at each node, we make a multiway branching decision according to the number of the node’s children. More precisely, at each internal node x, we make an .x:n C 1/-way branching decision. B-TREE-SEARCH is a straightforward generalization of the TREE-SEARCH pro- cedure defined for binary search trees. B-TREE-SEARCH takes as input a pointer to the root node x of a subtree and a key k to be searched for in that subtree. The top-level call is thus of the form B-TREE-SEARCH.T:root; k/. If k is in the B-tree, B-TREE-SEARCH returns the ordered pair .y;i/ consisting of a node y and an index i such that y:keyi D k. Otherwise, the procedure returns NIL. 􏳮 􏳮 492 Chapter 18 B-Trees B-TREE-SEARCH.x; k/ 1iD1 2 3 4 5 6 7 8 9 whilei􏳥x:nandk>x:keyi iDiC1
ifi􏳥x:nandk==x:keyi return .x;i/
elseif x : leaf return NIL
else DISK-READ.x:ci /
return B-TREE-SEARCH.x:ci;k/
Using a linear-search procedure, lines 1–3 find the smallest index i such that k 􏳥 x:keyi , or else they set i to x:n C 1. Lines 4–5 check to see whether we have now discovered the key, returning if we have. Otherwise, lines 6–9 either ter- minate the search unsuccessfully (if x is a leaf) or recurse to search the appropriate subtree of x, after performing the necessary DISK-READ on that child.
Figure 18.1 illustrates the operation of B-TREE-SEARCH. The procedure exam- ines the lightly shaded nodes during a search for the key R.
As in the TREE-SEARCH procedure for binary search trees, the nodes encoun- tered during the recursion form a simple path downward from the root of the tree. The B-TREE-SEARCH procedure therefore accesses O.h/ D O.logt n/ disk pages, where h is the height of the B-tree and n is the number of keys in the B-tree. Since x:n < 2t, the while loop of lines 2–3 takes O.t/ time within each node, and the total CPU time is O.th/ D O.t logt n/. Creating an empty B-tree To build a B-tree T , we first use B-TREE-CREATE to create an empty root node and then call B-TREE-INSERT to add new keys. Both of these procedures use an auxiliary procedure ALLOCATE-NODE, which allocates one disk page to be used as a new node in O.1/ time. We can assume that a node created by ALLOCATE- NODE requires no DISK-READ, since there is as yet no useful information stored on the disk for that node. B-TREE-CREATE.T / 1 x D ALLOCATE-NODE./ 2 x:leaf D TRUE 3 x:nD0 4 DISK-WRITE.x/ 5 T:rootDx B-TREE-CREATE requires O.1/ disk operations and O.1/ CPU time. 18.2 Basic operations on B-trees 493 Inserting a key into a B-tree Inserting a key into a B-tree is significantly more complicated than inserting a key into a binary search tree. As with binary search trees, we search for the leaf position at which to insert the new key. With a B-tree, however, we cannot simply create a new leaf node and insert it, as the resulting tree would fail to be a valid B-tree. Instead, we insert the new key into an existing leaf node. Since we cannot insert a key into a leaf node that is full, we introduce an operation that splits a full node y (having 2t 􏳣1 keys) around its median key y:keyt into two nodes having only t 􏳣1 keys each. The median key moves up into y’s parent to identify the dividing point between the two new trees. But if y’s parent is also full, we must split it before we can insert the new key, and thus we could end up splitting full nodes all the way up the tree. As with a binary search tree, we can insert a key into a B-tree in a single pass down the tree from the root to a leaf. To do so, we do not wait to find out whether we will actually need to split a full node in order to do the insertion. Instead, as we travel down the tree searching for the position where the new key belongs, we split each full node we come to along the way (including the leaf itself). Thus whenever we want to split a full node y, we are assured that its parent is not full. Splitting a node in a B-tree The procedure B-TREE-SPLIT-CHILD takes as input a nonfull internal node x (as- sumed to be in main memory) and an index i such that x:ci (also assumed to be in main memory) is a full child of x. The procedure then splits this child in two and adjusts x so that it has an additional child. To split a full root, we will first make the root a child of a new empty root node, so that we can use B-TREE-SPLIT-CHILD. The tree thus grows in height by one; splitting is the only means by which the tree grows. Figure 18.5 illustrates this process. We split the full node y D x:ci about its median key S, which moves up into y’s parent node x. Those keys in y that are greater than the median key move into a new node ́, which becomes a new child of x. 494 Chapter 18 B-Trees xx ...NW... ...NSW... y D x:ci y D x:ci ́ D x:ciC1 PQRSTUV PQR TUV T1 T2 T3 T4 T5 T6 T7 T8 T1 T2 T3 T4 T5 T6 T7 T8 Figure 18.5 Splitting a node with t D 4. Node y D x:ci splits into two nodes, y and ́, and the median key S of y moves up into y’s parent. B-TREE-SPLIT-CHILD.x;i/ 1 ́ D ALLOCATE-NODE./ 2 yDx:ci 3 ́:leaf D y:leaf 4 ́:nDt􏳣1 5 forjD1tot􏳣1 6 ́:keyj D y:keyjCt 7 if not y:leaf 8 for j D 1 to t 9 ́:cj Dy:cjCt 10 y:nDt􏳣1 11 forjDx:nC1downtoiC1 12 x:cjC1 Dx:cj 13 x:ciC1D ́ 14 forjDx:ndowntoi 15 x:keyjC1 D x:keyj 16 x:keyi D y:keyt 17 x:nDx:nC1 18 DISK-WRITE.y/ 19 DISK-WRITE. ́/ 20 DISK-WRITE.x/ B-TREE-SPLIT-CHILD works by straightforward “cutting and pasting.” Here, x is the node being split, and y is x’s ith child (set in line 2). Node y originally has 2t children (2t 􏳣 1 keys) but is reduced to t children (t 􏳣 1 keys) by this operation. Node ́ takes the t largest children (t 􏳣 1 keys) from y, and ́ becomes a new child x:keyi􏳣1 x:keyi x:keyi􏳣1 x:keyi x:keyiC1 18.2 Basic operations on B-trees 495 of x, positioned just after y in x’s table of children. The median key of y moves up to become the key in x that separates y and ́. Lines 1–9 create node ́ and give it the largest t 􏳣 1 keys and corresponding t children of y. Line 10 adjusts the key count for y. Finally, lines 11–17 insert ́ as a child of x, move the median key from y up to x in order to separate y from ́, and adjust x’s key count. Lines 18–20 write out all modified disk pages. The CPU time used by B-TREE-SPLIT-CHILD is ‚.t/, due to the loops on lines 5–6 and 8–9. (The other loops run for O.t/ iterations.) The procedure performs O.1/ disk operations. Inserting a key into a B-tree in a single pass down the tree We insert a key k into a B-tree T of height h in a single pass down the tree, re- quiring O.h/ disk accesses. The CPU time required is O.th/ D O.t logt n/. The B-TREE-INSERT procedure uses B-TREE-SPLIT-CHILD to guarantee that the re- cursion never descends to a full node. B-TREE-INSERT .T; k/ 1 rDT:root 2 ifr:n==2t􏳣1 3 4 5 6 7 8 9 10 else s D ALLOCATE-NODE./ T:rootDs s:leaf D FALSE s:nD0 s:c1Dr B-TREE-SPLIT-CHILD.s;1/ B-TREE-INSERT-NONFULL .s; k/ B-TREE-INSERT-NONFULL .r; k/ Lines 3–9 handle the case in which the root node r is full: the root splits and a new node s (having two children) becomes the root. Splitting the root is the only way to increase the height of a B-tree. Figure 18.6 illustrates this case. Unlike a binary search tree, a B-tree increases in height at the top instead of at the bottom. The procedure finishes by calling B-TREE-INSERT-NONFULL to insert key k into the tree rooted at the nonfull root node. B-TREE-INSERT-NONFULL recurses as necessary down the tree, at all times guaranteeing that the node to which it recurses is not full by calling B-TREE-SPLIT-CHILD as necessary. The auxiliary recursive procedure B-TREE-INSERT-NONFULL inserts key k into node x, which is assumed to be nonfull when the procedure is called. The operation of B-TREE-INSERT and the recursive operation of B-TREE-INSERT-NONFULL guarantee that this assumption is true. 496 Chapter 18 B-Trees T: root s H T: root rr ADFHLNP ADF LNP T1 T2 T3 T4 T5 T6 T7 T8 T1 T2 T3 T4 T5 T6 T7 T8 Figure 18.6 Splitting the root with t D 4. Root node r splits in two, and a new root node s is created. The new root contains the median key of r and has the two halves of r as children. The B-tree grows in height by one when the root is split. B-TREE-INSERT-NONFULL.x;k/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 iDx:n if x:leaf whilei􏳦1andk x:keyi
iDiC1 B-TREE-INSERT-NONFULL.x:ci;k/
The B-TREE-INSERT-NONFULL procedure works as follows. Lines 3–8 handle thecaseinwhichxisaleafnodebyinsertingkeykintox. Ifxisnotaleaf node, then we must insert k into the appropriate leaf node in the subtree rooted at internal node x. In this case, lines 9–11 determine the child of x to which the recursion descends. Line 13 detects whether the recursion would descend to a full child, in which case line 14 uses B-TREE-SPLIT-CHILD to split that child into two nonfull children, and lines 15–16 determine which of the two children is now the

18.2 Basic operations on B-trees 497
correct one to descend to. (Note that there is no need for a DISK-READ.x:ci/ after line 16 increments i, since the recursion will descend in this case to a child that was just created by B-TREE-SPLIT-CHILD.) The net effect of lines 13–16 is thus to guarantee that the procedure never recurses to a full node. Line 17 then recurses to insert k into the appropriate subtree. Figure 18.7 illustrates the various cases of inserting into a B-tree.
For a B-tree of height h, B-TREE-INSERT performs O.h/ disk accesses, since only O.1/ DISK-READ and DISK-WRITE operations occur between calls to B-TREE-INSERT-NONFULL . The total CPU time used is O.th/ D O.t logt n/. Since B-TREE-INSERT-NONFULL is tail-recursive, we can alternatively imple- ment it as a while loop, thereby demonstrating that the number of pages that need to be in main memory at any time is O.1/.
Exercises
18.2-1
Show the results of inserting the keys
F;S;Q;K;C;L;H;T;V;W;M;R;N;P;A;B;X;Y;D;Z;E
in order into an empty B-tree with minimum degree 2. Draw only the configura- tions of the tree just before some node must split, and also draw the final configu- ration.
18.2-2
Explain under what circumstances, if any, redundant DISK-READ or DISK-WRITE operations occur during the course of executing a call to B-TREE-INSERT. (A redundant DISK-READ is a DISK-READ for a page that is already in memory. A redundant DISK-WRITE writes to disk a page of information that is identical to what is already stored there.)
18.2-3
Explain how to find the minimum key stored in a B-tree and how to find the prede- cessor of a given key stored in a B-tree.
18.2-4 ?
Suppose that we insert the keys f1; 2; : : : ; ng into an empty B-tree with minimum degree 2. How many nodes does the final B-tree have?
18.2-5
Since leaf nodes require no pointers to children, they could conceivably use a dif- ferent (larger) t value than internal nodes for the same disk page size. Show how to modify the procedures for creating and inserting into a B-tree to handle this variation.

498 Chapter 18 B-Trees
(a) initial tree G M P X
ACDE JK NO RSTUV YZ
(b) Binserted G M P X
ABCDE JK NO RSTUV YZ
(c) Qinserted G M P T X
ABCDE JK NO QRS UV YZ
(d) L inserted P
GM TX
ABCDE JKL NO QRS UV YZ
(e) F inserted P
CGM TX
ABDEFJKLNOQRSUVYZ
Figure 18.7 Inserting keys into a B-tree. The minimum degree t for this B-tree is 3, so a node can hold at most 5 keys. Nodes that are modified by the insertion process are lightly shaded. (a) The initial tree for this example. (b) The result of inserting B into the initial tree; this is a simple insertion into a leaf node. (c) The result of inserting Q into the previous tree. The node RS T U V splits into two nodes containing RS and U V , the key T moves up to the root, and Q is inserted in the leftmost of the two halves (the RS node). (d) The result of inserting L into the previous tree. The root splits right away, since it is full, and the B-tree grows in height by one. Then L is inserted into the leaf containing JK. (e) The result of inserting F into the previous tree. The node ABCDE splits before F is inserted into the rightmost of the two halves (the DE node).

18.3 Deleting a key from a B-tree 499
18.2-6
Suppose that we were to implement B-TREE-SEARCH to use binary search rather than linear search within each node. Show that this change makes the CPU time required O.lg n/, independently of how t might be chosen as a function of n.
18.2-7
Suppose that disk hardware allows us to choose the size of a disk page arbitrarily, but that the time it takes to read the disk page is aCbt, where a and b are specified constants and t is the minimum degree for a B-tree using pages of the selected size. Describe how to choose t so as to minimize (approximately) the B-tree search time. Suggest an optimal value of t for the case in which a D 5 milliseconds and b D 10 microseconds.
18.3 Deleting a key from a B-tree
Deletion from a B-tree is analogous to insertion but a little more complicated, be- cause we can delete a key from any node—not just a leaf—and when we delete a key from an internal node, we will have to rearrange the node’s children. As in insertion, we must guard against deletion producing a tree whose structure violates the B-tree properties. Just as we had to ensure that a node didn’t get too big due to insertion, we must ensure that a node doesn’t get too small during deletion (except that the root is allowed to have fewer than the minimum number t 􏳣 1 of keys). Just as a simple insertion algorithm might have to back up if a node on the path to where the key was to be inserted was full, a simple approach to deletion might have to back up if a node (other than the root) along the path to where the key is to be deleted has the minimum number of keys.
The procedure B-TREE-DELETE deletes the key k from the subtree rooted at x. We design this procedure to guarantee that whenever it calls itself recursively on a node x, the number of keys in x is at least the minimum degree t. Note that this condition requires one more key than the minimum required by the usual B-tree conditions, so that sometimes a key may have to be moved into a child node before recursion descends to that child. This strengthened condition allows us to delete a key from the tree in one downward pass without having to “back up” (with one ex- ception, which we’ll explain). You should interpret the following specification for deletion from a B-tree with the understanding that if the root node x ever becomes an internal node having no keys (this situation can occur in cases 2c and 3b on pages 501–502), then we delete x, and x’s only child x:c1 becomes the new root of the tree, decreasing the height of the tree by one and preserving the property that the root of the tree contains at least one key (unless the tree is empty).

500 Chapter 18 B-Trees
(a) initial tree P
CGM TX
ABDEFJKLNOQRSUVYZ
(b) F deleted: case 1 P
CGM TX
ABDEJKLNO QRSUVYZ
(c) M deleted: case 2a P
CGL TX
ABDEJKNO QRSUVYZ
(d) G deleted: case 2c P
CL TX
ABDEJKNOQRSUVYZ
Figure 18.8 Deleting keys from a B-tree. The minimum degree for this B-tree is t D 3, so a node (other than the root) cannot have fewer than 2 keys. Nodes that are modified are lightly shaded. (a) The B-tree of Figure 18.7(e). (b) Deletion of F . This is case 1: simple deletion from a leaf. (c) Deletion of M . This is case 2a: the predecessor L of M moves up to take M ’s position. (d) Dele- tion of G. This is case 2c: we push G down to make node DEGJK and then delete G from this leaf (case 1).
We sketch how deletion works instead of presenting the pseudocode. Figure 18.8 illustrates the various cases of deleting keys from a B-tree.
1. Ifthekeykisinnodexandxisaleaf,deletethekeykfromx.
2. If the key k is in node x and x is an internal node, do the following:

18.3 Deleting a key from a B-tree 501
(e) D deleted: case 3b
CLPTX ABEJKNOQRSUVYZ
(e′) tree shrinks C L P T X in height
ABEJKNOQRSUVYZ
(f) B deleted: case 3a E L P T X ACJKNOQRSUVYZ
Figure 18.8, continued (e) Deletion of D. This is case 3b: the recursion cannot descend to node CL because it has only 2 keys, so we push P down and merge it with CL and TX to form CLP TX; then we delete D from a leaf (case 1). (e0) After (e), we delete the root and the tree shrinks in height by one. (f) Deletion of B. This is case 3a: C moves to fill B’s position and E moves to fill C ’s position.
a. If the child y that precedes k in node x has at least t keys, then find the predecessor k0 of k in the subtree rooted at y. Recursively delete k0, and replace k by k0 in x. (We can find k0 and delete it in a single downward pass.)
b. If y has fewer than t keys, then, symmetrically, examine the child ́ that follows k in node x. If ́ has at least t keys, then find the successor k0 of k in the subtree rooted at ́. Recursively delete k0, and replace k by k0 in x. (We can find k0 and delete it in a single downward pass.)
c. Otherwise,ifbothyand ́haveonlyt􏳣1keys,mergekandallof ́intoy, so that x loses both k and the pointer to ́, and y now contains 2t 􏳣 1 keys. Then free ́ and recursively delete k from y.
3. If the key k is not present in internal node x, determine the root x:ci of the appropriate subtree that must contain k, if k is in the tree at all. If x:ci has only t 􏳣 1 keys, execute step 3a or 3b as necessary to guarantee that we descend to a node containing at least t keys. Then finish by recursing on the appropriate child of x.

502 Chapter 18 B-Trees
Problems
a. If x:ci has only t 􏳣 1 keys but has an immediate sibling with at least t keys, give x:ci an extra key by moving a key from x down into x:ci, moving a key from x:ci’s immediate left or right sibling up into x, and moving the appropriate child pointer from the sibling into x:ci.
b. If x:ci and both of x:ci ’s immediate siblings have t 􏳣 1 keys, merge x:ci with one sibling, which involves moving a key from x down into the new merged node to become the median key for that node.
Since most of the keys in a B-tree are in the leaves, we may expect that in practice, deletion operations are most often used to delete keys from leaves. The B-TREE-DELETE procedure then acts in one downward pass through the tree, without having to back up. When deleting a key in an internal node, however, the procedure makes a downward pass through the tree but may have to return to the node from which the key was deleted to replace the key with its predecessor or successor (cases 2a and 2b).
Although this procedure seems complicated, it involves only O.h/ disk oper- ations for a B-tree of height h, since only O.1/ calls to DISK-READ and DISK- WRITE are made between recursive invocations of the procedure. The CPU time required is O.th/ D O.t logt n/.
Exercises
18.3-1
Show the results of deleting C , P , and V , in order, from the tree of Figure 18.8(f). 18.3-2
Write pseudocode for B-TREE-DELETE.
18-1 Stacks on secondary storage
Consider implementing a stack in a computer that has a relatively small amount of fast primary memory and a relatively large amount of slower disk storage. The operations PUSH and POP work on single-word values. The stack we wish to support can grow to be much larger than can fit in memory, and thus most of it must be stored on disk.
A simple, but inefficient, stack implementation keeps the entire stack on disk. We maintain in memory a stack pointer, which is the disk address of the top element on the stack. If the pointer has value p, the top element is the .p mod m/th word on page bp=mc of the disk, where m is the number of words per page.

Problems for Chapter 18 503
To implement the PUSH operation, we increment the stack pointer, read the ap- propriate page into memory from disk, copy the element to be pushed to the ap- propriate word on the page, and write the page back to disk. A POP operation is similar. We decrement the stack pointer, read in the appropriate page from disk, and return the top of the stack. We need not write back the page, since it was not modified.
Because disk operations are relatively expensive, we count two costs for any implementation: the total number of disk accesses and the total CPU time. Any disk access to a page of m words incurs charges of one disk access and ‚.m/ CPU time.
a. Asymptotically, what is the worst-case number of disk accesses for n stack operations using this simple implementation? What is the CPU time for n stack operations? (Express your answer in terms of m and n for this and subsequent parts.)
Now consider a stack implementation in which we keep one page of the stack in memory. (We also maintain a small amount of memory to keep track of which page is currently in memory.) We can perform a stack operation only if the relevant disk page resides in memory. If necessary, we can write the page currently in memory to the disk and read in the new page from the disk to memory. If the relevant disk page is already in memory, then no disk accesses are required.
b. What is the worst-case number of disk accesses required for n PUSH opera- tions? What is the CPU time?
c. What is the worst-case number of disk accesses required for n stack operations? What is the CPU time?
Suppose that we now implement the stack by keeping two pages in memory (in addition to a small number of words for bookkeeping).
d. Describe how to manage the stack pages so that the amortized number of disk accesses for any stack operation is O.1=m/ and the amortized CPU time for any stack operation is O.1/.
18-2 Joining and splitting 2-3-4 trees
The join operation takes two dynamic sets S0 and S00 and an element x such that for any x0 2 S0 and x00 2 S00, we have x0:key < x:key < x00:key. It returns a set S D S0 [ fxg [ S00. The split operation is like an “inverse” join: given a dynamic set S and an element x 2 S, it creates a set S0 that consists of all elements in S 􏳣 fxg whose keys are less than x:key and a set S00 that consists of all elements in S 􏳣 fxg whose keys are greater than x:key. In this problem, we investigate 504 Chapter 18 B-Trees how to implement these operations on 2-3-4 trees. We assume for convenience that elements consist only of keys and that all key values are distinct. a. Show how to maintain, for every node x of a 2-3-4 tree, the height of the subtree rooted at x as an attribute x:height. Make sure that your implementation does not affect the asymptotic running times of searching, insertion, and deletion. b. Show how to implement the join operation. Given two 2-3-4 trees T 0 and T 00 and a key k, the join operation should run in O.1 C jh0 􏳣 h00j/ time, where h0 and h00 are the heights of T 0 and T 00 , respectively. c. Consider the simple path p from the root of a 2-3-4 tree T to a given key k, thesetS0 ofkeysinT thatarelessthank,andthesetS00 ofkeysinT thatare greater than k. Show that p breaks S0 into a set of trees fT0;T10;:::;Tm0 g and a set of keys fk10 ;k20 ;:::;km0 g, where, for i D 1;2;:::;m, we have y < ki0 < ́ for any keys y 2 T 0 and ́ 2 T 0. What is the relationship between the heights i􏳣1 i of T 0 and T 0? Describe how p breaks S00 into sets of trees and keys. i􏳣1 i d. Show how to implement the split operation on T . Use the join operation to assemble the keys in S0 into a single 2-3-4 tree T0 and the keys in S00 into a single 2-3-4 tree T 00. The running time of the split operation should be O.lg n/, where n is the number of keys in T . (Hint: The costs for joining should tele- scope.) Chapter notes Knuth [211], Aho, Hopcroft, and Ullman [5], and Sedgewick [306] give further discussions of balanced-tree schemes and B-trees. Comer [74] provides a compre- hensive survey of B-trees. Guibas and Sedgewick [155] discuss the relationships among various kinds of balanced-tree schemes, including red-black trees and 2-3-4 trees. In 1970, J. E. Hopcroft invented 2-3 trees, a precursor to B-trees and 2-3-4 trees, in which every internal node has either two or three children. Bayer and McCreight [35] introduced B-trees in 1972; they did not explain their choice of name. Bender, Demaine, and Farach-Colton [40] studied how to make B-trees perform well in the presence of memory-hierarchy effects. Their cache-oblivious algo- rithms work efficiently without explicitly knowing the data transfer sizes within the memory hierarchy. 19 Fibonacci Heaps The Fibonacci heap data structure serves a dual purpose. First, it supports a set of operations that constitutes what is known as a “mergeable heap.” Second, several Fibonacci-heap operations run in constant amortized time, which makes this data structure well suited for applications that invoke these operations frequently. Mergeable heaps A mergeable heap is any data structure that supports the following five operations, in which each element has a key: MAKE-HEAP./ creates and returns a new heap containing no elements. INSERT.H; x/ inserts element x, whose key has already been filled in, into heap H . MINIMUM.H/ returns a pointer to the element in heap H whose key is minimum. EXTRACT-MIN.H/ deletes the element from heap H whose key is minimum, re- turning a pointer to the element. UNION.H1;H2/ creates and returns a new heap that contains all the elements of heaps H1 and H2. Heaps H1 and H2 are “destroyed” by this operation. In addition to the mergeable-heap operations above, Fibonacci heaps also support the following two operations: DECREASE-KEY.H;x;k/ assigns to element x within heap H the new key value k, which we assume to be no greater than its current key value.1 DELETE.H; x/ deletes element x from heap H . 1As mentioned in the introduction to Part V, our default mergeable heaps are mergeable min- heaps, and so the operations MINIMUM, EXTRACT-MIN, and DECREASE-KEY apply. Alterna- tively, we could define a mergeable max-heap with the operations MAXIMUM, EXTRACT-MAX, and INCREASE-KEY. 506 Chapter 19 Fibonacci Heaps Binary heap Fibonacci heap Procedure (worst-case) (amortized) MAKE-HEAP ‚.1/ ‚.1/ INSERT MINIMUM EXTRACT-MIN UNION DECREASE-KEY DELETE ‚.lg n/ ‚.1/ ‚.lg n/ ‚.n/ ‚.lg n/ ‚.lg n/ ‚.1/ ‚.1/ O.lg n/ ‚.1/ ‚.1/ O.lg n/ Figure 19.1 Running times for operations on two implementations of mergeable heaps. The num- ber of items in the heap(s) at the time of an operation is denoted by n. As the table in Figure 19.1 shows, if we don’t need the UNION operation, ordi- nary binary heaps, as used in heapsort (Chapter 6), work fairly well. Operations other than UNION run in worst-case time O.lg n/ on a binary heap. If we need to support the UNION operation, however, binary heaps perform poorly. By con- catenating the two arrays that hold the binary heaps to be merged and then running BUILD-MIN-HEAP (see Section 6.3), the UNION operation takes ‚.n/ time in the worst case. Fibonacci heaps, on the other hand, have better asymptotic time bounds than binary heaps for the INSERT, UNION, and DECREASE-KEY operations, and they have the same asymptotic running times for the remaining operations. Note, how- ever, that the running times for Fibonacci heaps in Figure 19.1 are amortized time bounds, not worst-case per-operation time bounds. The UNION operation takes only constant amortized time in a Fibonacci heap, which is significantly better than the linear worst-case time required in a binary heap (assuming, of course, that an amortized time bound suffices). Fibonacci heaps in theory and practice From a theoretical standpoint, Fibonacci heaps are especially desirable when the number of EXTRACT-MIN and DELETE operations is small relative to the number of other operations performed. This situation arises in many applications. For example, some algorithms for graph problems may call DECREASE-KEY once per edge. For dense graphs, which have many edges, the ‚.1/ amortized time of each call of DECREASE-KEY adds up to a big improvement over the ‚.lg n/ worst-case time of binary heaps. Fast algorithms for problems such as computing minimum spanning trees (Chapter 23) and finding single-source shortest paths (Chapter 24) make essential use of Fibonacci heaps. 19.1 Structure of Fibonacci heaps 507 From a practical point of view, however, the constant factors and program- ming complexity of Fibonacci heaps make them less desirable than ordinary binary (or k-ary) heaps for most applications, except for certain applications that manage large amounts of data. Thus, Fibonacci heaps are predominantly of theoretical in- terest. If a much simpler data structure with the same amortized time bounds as Fibonacci heaps were developed, it would be of practical use as well. Both binary heaps and Fibonacci heaps are inefficient in how they support the operation SEARCH; it can take a while to find an element with a given key. For this reason, operations such as DECREASE-KEY and DELETE that refer to a given ele- ment require a pointer to that element as part of their input. As in our discussion of priority queues in Section 6.5, when we use a mergeable heap in an application, we often store a handle to the corresponding application object in each mergeable-heap element, as well as a handle to the corresponding mergeable-heap element in each application object. The exact nature of these handles depends on the application and its implementation. Like several other data structures that we have seen, Fibonacci heaps are based on rooted trees. We represent each element by a node within a tree, and each node has a key attribute. For the remainder of this chapter, we shall use the term “node” instead of “element.” We shall also ignore issues of allocating nodes prior to insertion and freeing nodes following deletion, assuming instead that the code calling the heap procedures deals with these details. Section 19.1 defines Fibonacci heaps, discusses how we represent them, and presents the potential function used for their amortized analysis. Section 19.2 shows how to implement the mergeable-heap operations and achieve the amortized time bounds shown in Figure 19.1. The remaining two operations, DECREASE- KEY and DELETE, form the focus of Section 19.3. Finally, Section 19.4 finishes a key part of the analysis and also explains the curious name of the data structure. 19.1 Structure of Fibonacci heaps A Fibonacci heap is a collection of rooted trees that are min-heap ordered. That is, each tree obeys the min-heap property: the key of a node is greater than or equal to the key of its parent. Figure 19.2(a) shows an example of a Fibonacci heap. As Figure 19.2(b) shows, each node x contains a pointer x:p to its parent and a pointer x:child to any one of its children. The children of x are linked together in a circular, doubly linked list, which we call the child list of x. Each child y in a child list has pointers y:left and y:right that point to y’s left and right siblings, respectively. If node y is an only child, then y:left D y:right D y. Siblings may appear in a child list in any order. 508 Chapter 19 Fibonacci Heaps H:min (a)237 3 1724 18 52 38 30 26 46 39 41 35 H:min (b)237 3 1724 18 52 38 30 26 46 39 41 35 Figure 19.2 (a) A Fibonacci heap consisting of five min-heap-ordered trees and 14 nodes. The dashed line indicates the root list. The minimum node of the heap is the node containing the key 3. Black nodes are marked. The potential of this particular Fibonacci heap is 5 C 2 􏳵 3 D 11. (b) A more complete representation showing pointers p (up arrows), child (down arrows), and left and right (sideways arrows). The remaining figures in this chapter omit these details, since all the information shown here can be determined from what appears in part (a). Circular, doubly linked lists (see Section 10.2) have two advantages for use in Fibonacci heaps. First, we can insert a node into any location or remove a node from anywhere in a circular, doubly linked list in O.1/ time. Second, given two such lists, we can concatenate them (or “splice” them together) into one circular, doubly linked list in O.1/ time. In the descriptions of Fibonacci heap operations, we shall refer to these operations informally, letting you fill in the details of their implementations if you wish. Each node has two other attributes. We store the number of children in the child list of node x in x:degree. The boolean-valued attribute x:mark indicates whether node x has lost a child since the last time x was made the child of another node. Newly created nodes are unmarked, and a node x becomes unmarked whenever it is made the child of another node. Until we look at the DECREASE-KEY operation in Section 19.3, we will just set all mark attributes to FALSE. We access a given Fibonacci heap H by a pointer H:min to the root of a tree containing the minimum key; we call this node the minimum node of the Fibonacci 19.1 Structure of Fibonacci heaps 509 heap. If more than one root has a key with the minimum value, then any such root may serve as the minimum node. When a Fibonacci heap H is empty, H:min is NIL. The roots of all the trees in a Fibonacci heap are linked together using their left and right pointers into a circular, doubly linked list called the root list of the Fibonacci heap. The pointer H:min thus points to the node in the root list whose key is minimum. Trees may appear in any order within a root list. We rely on one other attribute for a Fibonacci heap H: H:n, the number of nodes currently in H . Potential function As mentioned, we shall use the potential method of Section 17.3 to analyze the performance of Fibonacci heap operations. For a given Fibonacci heap H, we indicate by t .H / the number of trees in the root list of H and by m.H / the number of marked nodes in H. We then define the potential ˆ.H/ of Fibonacci heap H by ˆ.H / D t .H / C 2 m.H / : (19.1) (We will gain some intuition for this potential function in Section 19.3.) For exam- ple, the potential of the Fibonacci heap shown in Figure 19.2 is 5 C 2 􏳵 3 D 11. The potential of a set of Fibonacci heaps is the sum of the potentials of its constituent Fibonacci heaps. We shall assume that a unit of potential can pay for a constant amount of work, where the constant is sufficiently large to cover the cost of any of the specific constant-time pieces of work that we might encounter. We assume that a Fibonacci heap application begins with no heaps. The initial potential, therefore, is 0, and by equation (19.1), the potential is nonnegative at all subsequent times. From equation (17.3), an upper bound on the total amortized cost provides an upper bound on the total actual cost for the sequence of operations. Maximum degree The amortized analyses we shall perform in the remaining sections of this chapter assume that we know an upper bound D.n/ on the maximum degree of any node in an n-node Fibonacci heap. We won’t prove it, but when only the mergeable- heap operations are supported, D.n/ 􏳥 blg nc. (Problem 19-2(d) asks you to prove this property.) In Sections 19.3 and 19.4, we shall show that when we support DECREASE-KEY and DELETE as well, D.n/ D O.lg n/. 510 Chapter 19 Fibonacci Heaps 19.2 Mergeable-heap operations The mergeable-heap operations on Fibonacci heaps delay work as long as possible. The various operations have performance trade-offs. For example, we insert a node by adding it to the root list, which takes just constant time. If we were to start with an empty Fibonacci heap and then insert k nodes, the Fibonacci heap would consist of just a root list of k nodes. The trade-off is that if we then perform an EXTRACT-MIN operation on Fibonacci heap H, after removing the node that H: min points to, we would have to look through each of the remaining k 􏳣 1 nodes in the root list to find the new minimum node. As long as we have to go through the entire root list during the EXTRACT-MIN operation, we also consolidate nodes into min-heap-ordered trees to reduce the size of the root list. We shall see that, no matter what the root list looks like before a EXTRACT-MIN operation, afterward each node in the root list has a degree that is unique within the root list, which leads to a root list of size at most D.n/ C 1. Creating a new Fibonacci heap To make an empty Fibonacci heap, the MAKE-FIB-HEAP procedure allocates and returns the Fibonacci heap object H, where H:n D 0 and H:min D NIL; there are no trees in H. Because t.H/ D 0 and m.H/ D 0, the potential of the empty Fibonacci heap is ˆ.H/ D 0. The amortized cost of MAKE-FIB-HEAP is thus equal to its O.1/ actual cost. Inserting a node The following procedure inserts node x into Fibonacci heap H , assuming that the node has already been allocated and that x:key has already been filled in. FIB-HEAP-INSERT.H;x/ 1 2 3 4 5 6 7 8 9 10 11 x:degree D 0 x:p D NIL x:child D NIL x:mark D FALSE if H:min == NIL create a root list for H containing just x H:min D x else insert x into H ’s root list if x:key < H:min:key H:min D x H:nDH:nC1 237 H: min 3 18 52 38 39 41 (a) 17 24 23721 H: min 3 18 52 38 39 41 (b) 17 24 30 26 46 35 19.2 Mergeable-heap operations 511 30 26 35 46 Inserting a node into a Fibonacci heap. (a) A Fibonacci heap H . (b) Fibonacci heap H after inserting the node with key 21. The node becomes its own min-heap-ordered tree and is then added to the root list, becoming the left sibling of the root. Lines 1–4 initialize some of the structural attributes of node x. Line 5 tests to see whether Fibonacci heap H is empty. If it is, then lines 6–7 make x be the only node in H’s root list and set H:min to point to x. Otherwise, lines 8–10 insert x into H’s root list and update H:min if necessary. Finally, line 11 increments H:n to reflect the addition of the new node. Figure 19.3 shows a node with key 21 inserted into the Fibonacci heap of Figure 19.2. To determine the amortized cost of FIB-HEAP-INSERT, let H be the input Fi- bonacci heap and H0 be the resulting Fibonacci heap. Then, t.H0/ D t.H/ C 1 and m.H0/ D m.H/, and the increase in potential is ..t .H / C 1/ C 2 m.H // 􏳣 .t .H / C 2 m.H // D 1 : Since the actual cost is O.1/, the amortized cost is O.1/ C 1 D O.1/. Finding the minimum node The minimum node of a Fibonacci heap H is given by the pointer H:min, so we can find the minimum node in O.1/ actual time. Because the potential of H does not change, the amortized cost of this operation is equal to its O.1/ actual cost. Uniting two Fibonacci heaps The following procedure unites Fibonacci heaps H1 and H2, destroying H1 and H2 in the process. It simply concatenates the root lists of H1 and H2 and then deter- mines the new minimum node. Afterward, the objects representing H1 and H2 will never be used again. Figure 19.3 512 Chapter 19 Fibonacci Heaps FIB-HEAP-UNION.H1;H2/ 1 H D MAKE-FIB-HEAP./ 2 H:min D H1:min 3 concatenate the root list of H2 with the root list of H 4 if .H1:min == NIL/ or .H2:min ¤ NIL and H2:min:key < H1:min:key/ 5 H:min D H2:min 6 H:n D H1:n C H2:n 7 return H Lines 1–3 concatenate the root lists of H1 and H2 into a new root list H. Lines 2, 4, and 5 set the minimum node of H, and line 6 sets H:n to the total number of nodes. Line 7 returns the resulting Fibonacci heap H. As in the FIB-HEAP- INSERT procedure, all roots remain roots. The change in potential is ˆ.H/ 􏳣 .ˆ.H1/ C ˆ.H2// D .t.H/ C 2m.H// 􏳣 ..t.H1/ C 2m.H1// C .t.H2/ C 2m.H2/// D0; because t.H/ D t.H1/ C t.H2/ and m.H/ D m.H1/ C m.H2/. The amortized cost of FIB-HEAP-UNION is therefore equal to its O.1/ actual cost. Extracting the minimum node The process of extracting the minimum node is the most complicated of the oper- ations presented in this section. It is also where the delayed work of consolidating trees in the root list finally occurs. The following pseudocode extracts the mini- mum node. The code assumes for convenience that when a node is removed from a linked list, pointers remaining in the list are updated, but pointers in the extracted node are left unchanged. It also calls the auxiliary procedure C O N S O L I D A T E , which we shall see shortly. 19.2 Mergeable-heap operations 513 FIB-HEAP-EXTRACT-MIN.H/ 1 2 3 4 5 6 7 8 9 10 11 12 ́ D H:min if ́¤NIL for each child x of ́ add x to the root list of H x:p D NIL remove ́ from the root list of H if ́ == ́:right H:min D NIL else H: min D ́: right CONSOLIDATE.H / H:nDH:n􏳣1 return ́ As Figure 19.4 illustrates, FIB-HEAP-EXTRACT-MIN works by first making a root out of each of the minimum node’s children and removing the minimum node from the root list. It then consolidates the root list by linking roots of equal degree until at most one root remains of each degree. We start in line 1 by saving a pointer ́ to the minimum node; the procedure returns this pointer at the end. If ́ is NIL, then Fibonacci heap H is already empty and we are done. Otherwise, we delete node ́ from H by making all of ́’s chil- dren roots of H in lines 3–5 (putting them into the root list) and removing ́ from the root list in line 6. If ́ is its own right sibling after line 6, then ́ was the only node on the root list and it had no children, so all that remains is to make the Fibonacci heap empty in line 8 before returning ́. Otherwise, we set the pointer H:min into the root list to point to a root other than ́ (in this case, ́’s right sibling), which is not necessarily going to be the new minimum node when FIB-HEAP-EXTRACT-MIN is done. Figure 19.4(b) shows the Fibonacci heap of Figure 19.4(a) after executing line 9. The next step, in which we reduce the number of trees in the Fibonacci heap, is consolidating the root list of H, which the call CONSOLIDATE.H/ accomplishes. Consolidating the root list consists of repeatedly executing the following steps until every root in the root list has a distinct degree value: 1. Find two roots x and y in the root list with the same degree. Without loss of generality, let x:key 􏳥 y:key. 2. Linkytox:removeyfromtherootlist,andmakeyachildofxbycallingthe FIB-HEAP-LINK procedure. This procedure increments the attribute x:degree and clears the mark on y. 514 Chapter 19 Fibonacci Heaps (a) (c) w,x (e) (g) 23 7 21 H: min 3 17 18 52 38 30 24 H: min (b) 23 7 21 18 52 38 17 39 41 30 26 46 24 26 46 35 w,x 21 18 52 38 17 39 41 30 26 46 39 41 0123 0123 AA w,x 35 23 7 23 7 w,x 7 17 23 30 21 18 52 38 17 39 41 30 26 46 (d) 23 7 24 24 35 0123 0123 AA w,x 35 24 46 38 41 21 18 52 38 17 24 (f) 39 41302646 23 39 413026 35 35 0123 0123 AA w,x 21185238 24 (h) 7 211852 39 41 26 46 24 17 23 39 35 26 46 30 35 7 21 18 52 38 17 The action of FIB-HEAP-EXTRACT-MIN. (a) A Fibonacci heap H. (b) The situa- tion after removing the minimum node ́ from the root list and adding its children to the root list. (c)–(e) The array A and the trees after each of the first three iterations of the for loop of lines 4–14 of the procedure CONSOLIDATE. The procedure processes the root list by starting at the node pointed to by H:min and following right pointers. Each part shows the values of w and x at the end of an iteration. (f)–(h) The next iteration of the for loop, with the values of w and x shown at the end of each iteration of the while loop of lines 7–13. Part (f) shows the situation after the first time through the while loop. The node with key 23 has been linked to the node with key 7, which x now points to. In part (g), the node with key 17 has been linked to the node with key 7, which x still points to. In part (h), the node with key 24 has been linked to the node with key 7. Since no node was previously pointed to by AŒ3􏳩, at the end of the for loop iteration, AŒ3􏳩 is set to point to the root of the resulting tree. Figure 19.4 19.2 Mergeable-heap operations 515 0123 0123 AA w,x (i) w,x (j) 7 24 17 23 39 41 7 24 17 23 39 21 18 52 38 21 18 52 38 41 0123 0123 AA x 26 46 30 35 7 24 17 23 46 30 H:min 26 46 30 35 (k) 18 38 (l) 7 24 17 23 w,x 18 38 21 39 41 21 52w 39 41 26 35 26 46 30 52 35 (m) 7 18 38 24 17 23 21 39 41 26 46 30 52 35 Figure 19.4, continued (i)–(l) The situation after each of the next four iterations of the for loop. (m) Fibonacci heap H after reconstructing the root list from the array A and determining the new H:min pointer. The procedure CONSOLIDATE uses an auxiliary array AŒ0::D.H:n/􏳩 to keep track of roots according to their degrees. If AŒi􏳩 D y, then y is currently a root with y:degree D i. Of course, in order to allocate the array we have to know how to calculate the upper bound D.H:n/ on the maximum degree, but we will see how to do so in Section 19.4. 516 Chapter 19 Fibonacci Heaps CONSOLIDATE.H/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 1 2 3 let AŒ0 : : D.H:n/􏳩 be a new array foriD0toD.H:n/ AŒi􏳩 D NIL foreachnodewintherootlistofH xDw d D x:degree while AŒd􏳩 ¤ NIL y D AŒd 􏳩 // another node with the same degree as x if x:key > y:key
exchange x with y FIB-HEAP-LINK.H;y;x/ AŒd􏳩DNIL
dDdC1
AŒd􏳩 D x H:min D NIL
foriD0toD.H:n/ if AŒi􏳩 ¤ NIL
if H:min == NIL
create a root list for H containing just AŒi􏳩 H:min D AŒi􏳩
else insert AŒi 􏳩 into H ’s root list if AŒi􏳩:key < H:min:key H:min D AŒi􏳩 FIB-HEAP-LINK.H;y;x/ remove y from the root list of H make y a child of x, incrementing x:degree y:mark D FALSE In detail, the CONSOLIDATE procedure works as follows. Lines 1–3 allocate and initialize the array A by making each entry NIL. The for loop of lines 4–14 processes each root w in the root list. As we link roots together, w may be linked to some other node and no longer be a root. Nevertheless, w is always in a tree rooted at some node x, which may or may not be w itself. Because we want at most one root with each degree, we look in the array A to see whether it contains a root y with the same degree as x. If it does, then we link the roots x and y but guaranteeing that x remains a root after linking. That is, we link y to x after first exchanging the pointers to the two roots if y’s key is smaller than x’s key. After we link y to x, the degree of x has increased by 1, and so we continue this process, linking x and another root whose degree equals x’s new degree, until no other root 19.2 Mergeable-heap operations 517 that we have processed has the same degree as x. We then set the appropriate entry of A to point to x, so that as we process roots later on, we have recorded that x is the unique root of its degree that we have already processed. When this for loop terminates, at most one root of each degree will remain, and the array A will point to each remaining root. The while loop of lines 7–13 repeatedly links the root x of the tree containing node w to another tree whose root has the same degree as x, until no other root has the same degree. This while loop maintains the following invariant: At the start of each iteration of the while loop, d D x:degree. We use this loop invariant as follows: Initialization: Line 6 ensures that the loop invariant holds the first time we enter the loop. Maintenance: In each iteration of the while loop, AŒd􏳩 points to some root y. Because d D x:degree D y:degree, we want to link x and y. Whichever of x and y has the smaller key becomes the parent of the other as a result of the link operation, and so lines 9–10 exchange the pointers to x and y if necessary. Next, we link y to x by the call FIB-HEAP-LINK.H;y;x/ in line 11. This call increments x:degree but leaves y:degree as d. Node y is no longer a root, and so line 12 removes the pointer to it in array A. Because the call of FIB- HEAP-LINK increments the value of x:degree, line 13 restores the invariant that d D x:degree. Termination: We repeat the while loop until AŒd􏳩 D NIL, in which case there is no other root with the same degree as x. After the while loop terminates, we set AŒd􏳩 to x in line 14 and perform the next iteration of the for loop. Figures 19.4(c)–(e) show the array A and the resulting trees after the first three iterations of the for loop of lines 4–14. In the next iteration of the for loop, three links occur; their results are shown in Figures 19.4(f)–(h). Figures 19.4(i)–(l) show the result of the next four iterations of the for loop. All that remains is to clean up. Once the for loop of lines 4–14 completes, line 15 empties the root list, and lines 16–23 reconstruct it from the array A. The resulting Fibonacci heap appears in Figure 19.4(m). After consolidating the root list, FIB-HEAP-EXTRACT-MIN finishes up by decrementing H:n in line 11 and returning a pointer to the deleted node ́ in line 12. We are now ready to show that the amortized cost of extracting the minimum node of an n-node Fibonacci heap is O.D.n//. Let H denote the Fibonacci heap just prior to the FIB-HEAP-EXTRACT-MIN operation. We start by accounting for the actual cost of extracting the minimum node. An O.D.n// contribution comes from FIB-HEAP-EXTRACT-MIN processing at 518 Chapter 19 Fibonacci Heaps most D.n/ children of the minimum node and from the work in lines 2–3 and 16–23 of CONSOLIDATE. It remains to analyze the contribution from the for loop of lines 4–14 in CONSOLIDATE, for which we use an aggregate analysis. The size of the root list upon calling CONSOLIDATE is at most D.n/ C t.H/ 􏳣 1, since it consists of the original t.H/ root-list nodes, minus the extracted root node, plus the children of the extracted node, which number at most D.n/. Within a given iteration of the for loop of lines 4–14, the number of iterations of the while loop of lines 7–13 depends on the root list. But we know that every time through the while loop, one of the roots is linked to another, and thus the total number of iterations of the while loop over all iterations of the for loop is at most the number of roots in the root list. Hence, the total amount of work performed in the for loop is at most proportional to D.n/ C t.H/. Thus, the total actual work in extracting the minimum node is O.D.n/ C t.H//. The potential before extracting the minimum node is t .H / C 2 m.H /, and the potential afterward is at most .D.n/ C 1/ C 2 m.H /, since at most D.n/ C 1 roots remain and no nodes become marked during the operation. The amortized cost is thus at most O.D.n/Ct.H//C..D.n/C1/C2m.H//􏳣.t.H/C2m.H// D O.D.n// C O.t.H// 􏳣 t.H/ D O.D.n// ; since we can scale up the units of potential to dominate the constant hidden in O.t.H//. Intuitively, the cost of performing each link is paid for by the re- duction in potential due to the link’s reducing the number of roots by one. We shall see in Section 19.4 that D.n/ D O.lg n/, so that the amortized cost of extracting the minimum node is O.lg n/. Exercises 19.2-1 Show the Fibonacci heap that results from calling FIB-HEAP-EXTRACT-MIN on the Fibonacci heap shown in Figure 19.4(m). 19.3 Decreasing a key and deleting a node In this section, we show how to decrease the key of a node in a Fibonacci heap in O.1/ amortized time and how to delete any node from an n-node Fibonacci heap in O.D.n// amortized time. In Section 19.4, we will show that the maxi- 19.3 Decreasing a key and deleting a node 519 mum degree D.n/ is O.lgn/, which will imply that FIB-HEAP-EXTRACT-MIN and FIB-HEAP-DELETE run in O.lg n/ amortized time. Decreasing a key In the following pseudocode for the operation FIB-HEAP-DECREASE-KEY, we assume as before that removing a node from a linked list does not change any of the structural attributes in the removed node. FIB-HEAP-DECREASE-KEY.H;x;k/ ifk>x:key
error “new key is greater than current key”
x:keyDk
yDx:p ify¤NILandx:key

19.4 Bounding the maximum degree 525
Lemma 19.4
Let x be any node in a Fibonacci heap, and let k D x:degree. Then size.x/ 􏳦 FkC2 􏳦􏳭k,where􏳭D.1Cp5/=2.
Proof Let sk denote the minimum possible size of any node of degree k in any Fibonacci heap. Trivially, s0 D 1 and s1 D 2. The number sk is at most size.x/ and, because adding children to a node cannot decrease the node’s size, the value of sk increases monotonically with k. Consider some node ́, in any Fibonacci heap, such that ́:degree D k and size. ́/ D sk. Because sk 􏳥 size.x/, we compute a lower bound on size.x/ by computing a lower bound on sk. As in Lemma19.1,lety1;y2;:::;yk denotethechildrenof ́intheorderinwhichthey were linked to ́. To bound sk , we count one for ́ itself and one for the first child y1 (for which size.y1/ 􏳦 1), giving
size.x/ 􏳦 sk
Xk
􏳦 2C syi:degree iD2
Xk 􏳦2C si􏳣2;
iD2
where the last line follows from Lemma 19.1 (so that yi : degree 􏳦 i 􏳣 2) and the monotonicityofsk (sothatsyi:degree 􏳦si􏳣2).
We now show by induction on k that sk 􏳦 FkC2 for all nonnegative integers k. The bases, for k D 0 and k D 1, are trivial. For the inductive step, we assume that k􏳦2andthatsi 􏳦FiC2 foriD0;1;:::;k􏳣1.Wehave
Xk
sk 􏳦 2C si􏳣2
iD2 Xk
􏳦2C Fi iD2
Xk D1C Fi
iD0 D FkC2
(by Lemma 19.2) (by Lemma 19.3) .
􏳦 􏳭k
Thus, we have shown that size.x/ 􏳦 sk 􏳦 FkC2 􏳦 􏳭k.

526 Chapter 19 Fibonacci Heaps
Problems
Corollary 19.5
The maximum degree D.n/ of any node in an n-node Fibonacci heap is O.lg n/. Proof Let x be any node in an n-node Fibonacci heap, and let k D x:degree.
By Lemma 19.4, we have n 􏳦 size.x/ 􏳦 􏳭k. Taking base-􏳭 logarithms gives 􏳼 ̆
us k 􏳥 log􏳭 n. (In fact, because k is an integer, k 􏳥 log􏳭 n .) The maximum degree D.n/ of any node is thus O.lg n/.
Exercises
19.4-1
Professor Pinocchio claims that the height of an n-node Fibonacci heap is O.lg n/. Show that the professor is mistaken by exhibiting, for any positive integer n, a sequence of Fibonacci-heap operations that creates a Fibonacci heap consisting of just one tree that is a linear chain of n nodes.
19.4-2
Suppose we generalize the cascading-cut rule to cut a node x from its parent as soon as it loses its kth child, for some integer constant k. (The rule in Section 19.3 uses k D 2.) For what values of k is D.n/ D O.lg n/?
19-1 Alternative implementation of deletion
Professor Pisano has proposed the following variant of the FIB-HEAP-DELETE procedure, claiming that it runs faster when the node being deleted is not the node pointed to by H:min.
PISANO-DELETE.H;x/
1 2 3 4 5 6 7 8
ifx==H:min FIB-HEAP-EXTRACT-MIN.H/
elseyDx:p if y ¤ NIL
CUT.H;x;y/
CASCADING-CUT.H; y/
add x’s child list to the root list of H remove x from the root list of H

Problems for Chapter 19 527
a. The professor’s claim that this procedure runs faster is based partly on the as- sumption that line 7 can be performed in O.1/ actual time. What is wrong with this assumption?
b. Give a good upper bound on the actual time of PISANO-DELETE when x is not H:min. Your bound should be in terms of x:degree and the number c of calls to the CASCADING-CUT procedure.
c. Suppose that we call PISANO-DELETE.H;x/, and let H0 be the Fibonacci heap that results. Assuming that node x is not a root, bound the potential of H0 in terms of x:degree, c, t.H/, and m.H/.
d. Conclude that the amortized time for PISANO-DELETE is asymptotically no better than for FIB-HEAP-DELETE, even when x ¤ H:min.
19-2 Binomial trees and binomial heaps
The binomial tree Bk is an ordered tree (see Section B.5.2) defined recursively. As shown in Figure 19.6(a), the binomial tree B0 consists of a single node. The binomial tree Bk consists of two binomial trees Bk􏳣1 that are linked together so that the root of one is the leftmost child of the root of the other. Figure 19.6(b) shows the binomial trees B0 through B4.
a. ShowthatforthebinomialtreeBk,
1. there are 2k nodes,
3. there are exactly 􏳣k􏳵 nodes at depth i for i D 0;1;:::;k, and i
4. the root has degree k, which is greater than that of any other node; moreover, as Figure 19.6(c) shows, if we number the children of the root from left to rightbyk􏳣1;k􏳣2;:::;0,thenchildi istherootofasubtreeBi.
A binomial heap H is a set of binomial trees that satisfies the following proper- ties:
1. Eachnodehasakey(likeaFibonacciheap).
2. EachbinomialtreeinHobeysthemin-heapproperty.
3. For any nonnegative integer k, there is at most one binomial tree in H whose root has degree k.
b. Suppose that a binomial heap H has a total of n nodes. Discuss the relationship between the binomial trees that H contains and the binary representation of n. Conclude that H consists of at most blg nc C 1 binomial trees.
2. the height of the tree is k,

528 Chapter 19
Fibonacci Heaps
(a)
(b)
B0
Bk–1 Bk–1
Bk
depth 0
1
2
3
4
B0B1B2B3 B4
(c)
Figure 19.6
trees. (b) The binomial trees B0 through B4. Node depths in B4 are shown. (c) Another way of looking at the binomial tree Bk .
Suppose that we represent a binomial heap as follows. The left-child, right- sibling scheme of Section 10.4 represents each binomial tree within a binomial heap. Each node contains its key; pointers to its parent, to its leftmost child, and to the sibling immediately to its right (these pointers are NIL when appropriate); and its degree (as in Fibonacci heaps, how many children it has). The roots form a singly linked root list, ordered by the degrees of the roots (from low to high), and we access the binomial heap by a pointer to the first node on the root list.
c. Complete the description of how to represent a binomial heap (i.e., name the attributes, describe when attributes have the value NIL, and define how the root list is organized), and show how to implement the same seven operations on binomial heaps as this chapter implemented on Fibonacci heaps. Each opera- tion should run in O.lg n/ worst-case time, where n is the number of nodes in
Bk–1
Bk–2
Bk
B2
B0 B1
(a) The recursive definition of the binomial tree Bk. Triangles represent rooted sub-

Problems for Chapter 19 529
the binomial heap (or in the case of the UNION operation, in the two binomial heaps that are being united). The MAKE-HEAP operation should take constant time.
d. Suppose that we were to implement only the mergeable-heap operations on a Fibonacci heap (i.e., we do not implement the DECREASE-KEY or DELETE op- erations). How would the trees in a Fibonacci heap resemble those in a binomial heap? How would they differ? Show that the maximum degree in an n-node Fibonacci heap would be at most blg nc.
e. Professor McGee has devised a new data structure based on Fibonacci heaps. A McGee heap has the same structure as a Fibonacci heap and supports just the mergeable-heap operations. The implementations of the operations are the same as for Fibonacci heaps, except that insertion and union consolidate the root list as their last step. What are the worst-case running times of operations on McGee heaps?
19-3 More Fibonacci-heap operations
We wish to augment a Fibonacci heap H to support two new operations without changing the amortized running time of any other Fibonacci-heap operations.
a. The operation FIB-HEAP-CHANGE-KEY.H;x;k/ changes the key of node x to the value k. Give an efficient implementation of FIB-HEAP-CHANGE-KEY, and analyze the amortized running time of your implementation for the cases in which k is greater than, less than, or equal to x:key.
b. Give an efficient implementation of FIB-HEAP-PRUNE.H;r/, which deletes q D min.r; H: n/ nodes from H . You may choose any q nodes to delete. Ana- lyze the amortized running time of your implementation. (Hint: You may need to modify the data structure and potential function.)
19-4 2-3-4 heaps
Chapter 18 introduced the 2-3-4 tree, in which every internal node (other than pos- sibly the root) has two, three, or four children and all leaves have the same depth. In this problem, we shall implement 2-3-4 heaps, which support the mergeable-heap operations.
The 2-3-4 heaps differ from 2-3-4 trees in the following ways. In 2-3-4 heaps, only leaves store keys, and each leaf x stores exactly one key in the attribute x:key. The keys in the leaves may appear in any order. Each internal node x contains a value x:small that is equal to the smallest key stored in any leaf in the subtree rooted at x. The root r contains an attribute r:height that gives the height of the

530 Chapter 19 Fibonacci Heaps
tree. Finally, 2-3-4 heaps are designed to be kept in main memory, so that disk reads and writes are not needed.
Implement the following 2-3-4 heap operations. In parts (a)–(e), each operation should run in O.lg n/ time on a 2-3-4 heap with n elements. The UNION operation in part (f) should run in O.lg n/ time, where n is the number of elements in the two input heaps.
a. MINIMUM, which returns a pointer to the leaf with the smallest key.
b. DECREASE-KEY, which decreases the key of a given leaf x to a given value
k 􏳥 x:key.
c. INSERT, which inserts leaf x with key k.
d. DELETE, which deletes a given leaf x.
e. EXTRACT-MIN, which extracts the leaf with the smallest key.
f. UNION, which unites two 2-3-4 heaps, returning a single 2-3-4 heap and de- stroying the input heaps.
Chapter notes
Fredman and Tarjan [114] introduced Fibonacci heaps. Their paper also describes the application of Fibonacci heaps to the problems of single-source shortest paths, all-pairs shortest paths, weighted bipartite matching, and the minimum-spanning- tree problem.
Subsequently, Driscoll, Gabow, Shrairman, and Tarjan [96] developed “relaxed heaps” as an alternative to Fibonacci heaps. They devised two varieties of re- laxed heaps. One gives the same amortized time bounds as Fibonacci heaps. The other allows DECREASE-KEY to run in O.1/ worst-case (not amortized) time and EXTRACT-MIN and DELETE to run in O.lgn/ worst-case time. Relaxed heaps also have some advantages over Fibonacci heaps in parallel algorithms.
See also the chapter notes for Chapter 6 for other data structures that support fast DECREASE-KEY operations when the sequence of values returned by EXTRACT- MIN calls are monotonically increasing over time and the data are integers in a specific range.

20 van Emde Boas Trees
In previous chapters, we saw data structures that support the operations of a priority queue—binary heaps in Chapter 6, red-black trees in Chapter 13,1 and Fibonacci heaps in Chapter 19. In each of these data structures, at least one important op- eration took O.lg n/ time, either worst case or amortized. In fact, because each of these data structures bases its decisions on comparing keys, the 􏳫.n lg n/ lower bound for sorting in Section 8.1 tells us that at least one operation will have to take 􏳫.lg n/ time. Why? If we could perform both the INSERT and EXTRACT-MIN operations in o.lg n/ time, then we could sort n keys in o.n lg n/ time by first per- forming n INSERT operations, followed by n EXTRACT-MIN operations.
We saw in Chapter 8, however, that sometimes we can exploit additional infor- mation about the keys to sort in o.n lg n/ time. In particular, with counting sort we can sort n keys, each an integer in the range 0 to k, in time ‚.n C k/, which is ‚.n/ when k D O.n/.
Since we can circumvent the 􏳫.n lg n/ lower bound for sorting when the keys are integers in a bounded range, you might wonder whether we can perform each of the priority-queue operations in o.lg n/ time in a similar scenario. In this chapter, we shall see that we can: van Emde Boas trees support the priority-queue operations, and a few others, each in O.lg lg n/ worst-case time. The hitch is that the keys must be integers in the range 0 to n 􏳣 1, with no duplicates allowed.
Specifically, van Emde Boas trees support each of the dynamic set operations listed on page 230—SEARCH, INSERT, DELETE, MINIMUM, MAXIMUM, SUC- CESSOR, and PREDECESSOR—in O.lg lg n/ time. In this chapter, we will omit discussion of satellite data and focus only on storing keys. Because we concentrate on keys and disallow duplicate keys to be stored, instead of describing the SEARCH
1Chapter 13 does not explicitly discuss how to implement EXTRACT-MIN and DECREASE-KEY, but we can easily build these operations for any data structure that supports MINIMUM, DELETE, and INSERT.

532 Chapter 20 van Emde Boas Trees
operation, we will implement the simpler operation MEMBER.S; x/, which returns a boolean indicating whether the value x is currently in dynamic set S.
So far, we have used the parameter n for two distinct purposes: the number of elements in the dynamic set, and the range of the possible values. To avoid any further confusion, from here on we will use n to denote the number of elements currently in the set and u as the range of possible values, so that each van Emde Boas tree operation runs in O.lglgu/ time. We call the set f0;1;2;:::;u􏳣1g the universe of values that can be stored and u the universe size. We assume throughout this chapter that u is an exact power of 2, i.e., u D 2k for some integer k 􏳦 1.
Section 20.1 starts us out by examining some simple approaches that will get us going in the right direction. We enhance these approaches in Section 20.2, introducing proto van Emde Boas structures, which are recursive but do not achieve our goal of O.lg lg u/-time operations. Section 20.3 modifies proto van Emde Boas structures to develop van Emde Boas trees, and it shows how to implement each operation in O.lg lg u/ time.
20.1 Preliminary approaches
In this section, we shall examine various approaches for storing a dynamic set. Although none will achieve the O.lg lg u/ time bounds that we desire, we will gain insights that will help us understand van Emde Boas trees when we see them later in this chapter.
Direct addressing
Direct addressing, as we saw in Section 11.1, provides the simplest approach to storing a dynamic set. Since in this chapter we are concerned only with storing keys, we can simplify the direct-addressing approach to store the dynamic set as a bit vector, as discussed in Exercise 11.1-2. To store a dynamic set of values from theuniversef0;1;2;:::;u􏳣1g,wemaintainanarrayAŒ0::u􏳣1􏳩ofubits. The entry AŒx􏳩 holds a 1 if the value x is in the dynamic set, and it holds a 0 otherwise. Although we can perform each of the INSERT, DELETE, and MEMBER operations in O.1/ time with a bit vector, the remaining operations—MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR—each take ‚.u/ time in the worst case because

20.1
Preliminary approaches
533
1 11 1101
01110001
A
Figure 20.1 A binary tree of bits superimposed on top of a bit vector representing the set f2; 3; 4; 5; 7; 14; 15g when u D 16. Each internal node contains a 1 if and only if some leaf in its subtree contains a 1. The arrows show the path followed to determine the predecessor of 14 in the set.
wemighthavetoscanthrough‚.u/elements.2 Forexample,ifasetcontainsonly the values 0 and u 􏳣 1, then to find the successor of 0, we would have to scan entries 1 through u 􏳣 2 before finding a 1 in AŒu 􏳣 1􏳩.
Superimposing a binary tree structure
We can short-cut long scans in the bit vector by superimposing a binary tree of bits on top of it. Figure 20.1 shows an example. The entries of the bit vector form the leaves of the binary tree, and each internal node contains a 1 if and only if any leaf in its subtree contains a 1. In other words, the bit stored in an internal node is the logical-or of its two children.
The operations that took ‚.u/ worst-case time with an unadorned bit vector now use the tree structure:
To find the minimum value in the set, start at the root and head down toward the leaves, always taking the leftmost node containing a 1.
To find the maximum value in the set, start at the root and head down toward the leaves, always taking the rightmost node containing a 1.
2We assume throughout this chapter that MINIMUM and MAXIMUM return NIL if the dynamic set is empty and that SUCCESSOR and PREDECESSOR return NIL if the element they are given has no successor or predecessor, respectively.
0
0
1
1
1
1
0
1
0
0
0
0
0
0
1
1
􏳮
􏳮
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

534 Chapter 20 van Emde Boas Trees
To find the successor of x, start at the leaf indexed by x, and head up toward the root until we enter a node from the left and this node has a 1 in its right child ́. Then head down through node ́, always taking the leftmost node containing a 1 (i.e., find the minimum value in the subtree rooted at the right child ́).
To find the predecessor of x, start at the leaf indexed by x, and head up toward the root until we enter a node from the right and this node has a 1 in its left child ́. Then head down through node ́, always taking the rightmost node containing a 1 (i.e., find the maximum value in the subtree rooted at the left child ́).
Figure 20.1 shows the path taken to find the predecessor, 7, of the value 14.
We also augment the INSERT and DELETE operations appropriately. When in- serting a value, we store a 1 in each node on the simple path from the appropriate leaf up to the root. When deleting a value, we go from the appropriate leaf up to the root, recomputing the bit in each internal node on the path as the logical-or of
its two children.
Since the height of the tree is lg u and each of the above operations makes at
most one pass up the tree and at most one pass down, each operation takes O.lg u/ time in the worst case.
This approach is only marginally better than just using a red-black tree. We can still perform the MEMBER operation in O.1/ time, whereas searching a red-black tree takes O.lg n/ time. Then again, if the number n of elements stored is much smaller than the size u of the universe, a red-black tree would be faster for all the other operations.
Superimposing a tree of constant height
What happens if we superimpose a tree with greater degree? Let us assume that the size of the universe is u D 22k for some integer k, so that pu is an integer. Instead of superimposing a binary tree on top of the bit vector, we superimpose a tree of degree pu. Figure 20.2(a) shows such a tree for the same bit vector as in Figure 20.1. The height of the resulting tree is always 2.
As before, each internal node stores the logical-or of the bits within its sub- tree, so that the pu internal nodes at depth 1 summarize each group of pu val- ues. As Figure 20.2(b) demonstrates, we can think of these nodes as an array summaryŒ0 : : pu 􏳣 1􏳩, where summaryŒi 􏳩 contains a 1 if and only if the subar- ray AŒi pu : : .i C 1/pu 􏳣 1􏳩 contains a 1. We call this pu-bit subarray of A the ith cluster. For a given value of x, the bit AŒx􏳩 appears in cluster num- ber bx=puc. Now INSERT becomes an O.1/-time operation: to insert x, set both AŒx􏳩 and summaryŒbx=puc􏳩 to 1. We can use the summary array to perform
􏳮
􏳮

20.1 Preliminary approaches
535
0123 1p
1
1
0
1
summary u bits
1101
AA
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (a)
p
Figure 20.2 (a) A tree of degree
Each internal node stores the logical-or of the bits in its subtree. (b) A view of the same structure,
u bits 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
(b)
p
0
0
1
1
1
1
0
1
0
0
0
0
0
0
1
1
0
0
1
1
1
1
0
1
0
0
0
0
0
0
1
1
u superimposed on top of the same bit vector as in Figure 20.1.
but with the internal nodes at depth 1 treated as an array summaryŒ0 : : pp
p
u 􏳣 1􏳩, where summaryŒi 􏳩 is
thelogical-orofthesubarrayAŒi u::.iC1/ u􏳣1􏳩.
each of the operations MINIMUM, MAXIMUM, SUCCESSOR, PREDECESSOR, and
To find the minimum (maximum) value, find the leftmost (rightmost) entry in summary that contains a 1, say summaryŒi􏳩, and then do a linear search within the ith cluster for the leftmost (rightmost) 1.
To find the successor (predecessor) of x, first search to the right (left) within its cluster. If we find a 1, that position gives the result. Otherwise, let i D bx=puc and search to the right (left) within the summary array from index i. The first position that holds a 1 gives the index of a cluster. Search within that cluster for the leftmost (rightmost) 1. That position holds the successor (predecessor).
To delete the value x, let i D bx=puc􏳩. Set AŒx􏳩 to 0 and then set summaryŒi􏳩 to the logical-or of the bits in the ith cluster.
In each of the above operations, we search through at most two clusters of pu bits plus the summary array, and so each operation takes O.pu/ time.
At first glance, it seems as though we have made negative progress. Superimpos- ing a binary tree gave us O.lg u/-time operations, which are asymptotically faster than O.pu/ time. Using a tree of degree pu will turn out to be a key idea of van Emde Boas trees, however. We continue down this path in the next section.
Exercises
20.1-1
Modify the data structures in this section to support duplicate keys.
DELETE in O.pu/ time:
􏳮
􏳮
􏳮

536 Chapter 20 van Emde Boas Trees
20.1-2
Modify the data structures in this section to support keys that have associated satel- lite data.
20.1-3
Observe that, using the structures in this section, the way we find the successor and predecessor of a value x does not depend on whether x is in the set at the time. Show how to find the successor of x in a binary search tree when x is not stored in the tree.
20.1-4 p
Suppose that instead of superimposing a tree of degree
pose a tree of degree u1= k , where k > 1 is a constant. What would be the height of such a tree, and how long would each of the operations take?
20.2 A recursive structure
In this section, we modify the idea of superimposing a tree of degree pu on top of a bit vector. In the previous section, we used a summary structure of size pu, with each entry pointing to another stucture of size pu. Now, we make the structure recursive, shrinking the universe size by the square root at each level of recursion. Starting with a universe of size u, we make structures holding pu D u1=2 items, which themselves hold structures of u1=4 items, which hold structures of u1=8 items, and so on, down to a base size of 2.
For simplicity, in this section, we assume that u D 22k for some integer k, so that u; u1=2; u1=4; : : : are integers. This restriction would be quite severe in practice, allowing only values of u in the sequence 2; 4; 16; 256; 65536; : : :. We shall see in the next section how to relax this assumption and assume only that u D 2k for some integer k. Since the structure we examine in this section is only a precursor to the true van Emde Boas tree structure, we tolerate this restriction in favor of aiding our understanding.
Recalling that our goal is to achieve running times of O.lg lg u/ for the oper- ations, let’s think about how we might obtain such running times. At the end of Section 4.3, we saw that by changing variables, we could show that the recurrence
u, we were to superim-
􏳣􏳼p ̆􏳵
T .n/ D 2T n C lg n
has the solution T .n/ D O.lg n lg lg n/. recurrence:
(20.1) Let’s consider a similar, but simpler,
T.u/ D T.
p
u/ C O.1/ :
(20.2)

20.2 A recursive structure 537
If we use the same technique, changing variables, we can show that recur- rence (20.2) has the solution T.u/ D O.lglgu/. Let m D lgu, so that u D 2m and we have
T.2m/ D T.2m=2/ C O.1/ :
Now we rename S.m/ D T.2m/, giving the new recurrence S.m/ D S.m=2/ C O.1/ :
By case 2 of the master method, this recurrence has the solution S.m/ D O.lg m/. We change back from S.m/ to T .u/, giving T .u/ D T .2m/ D S.m/ D O.lg m/ D O.lg lg u/.
Recurrence (20.2) will guide our search for a data structure. We will design a recursive data structure that shrinks by a factor of pu in each level of its recursion. When an operation traverses this data structure, it will spend a constant amount of time at each level before recursing to the level below. Recurrence (20.2) will then characterize the running time of the operation.
Here is another way to think of how the term lg lg u ends up in the solution to recurrence (20.2). As we look at the universe size in each level of the recursive data structure, we see the sequence u; u1=2; u1=4; u1=8; : : :. If we consider how many bits we need to store the universe size at each level, we need lg u at the top level, and each level needs half the bits of the previous level. In general, if we start with b bits and halve the number of bits at each level, then after lg b levels, we get down to just one bit. Since b D lg u, we see that after lg lg u levels, we have a universe size of 2.
Looking back at the data structure in Figure 20.2, a given value x resides in cluster number bx=puc. If we view x as a lgu-bit binary integer, that cluster number, bx=puc, is given by the most significant .lgu/=2 bits of x. Within its cluster, x appears in position x mod pu, which is given by the least significant .lgu/=2 bits of x. We will need to index in this way, and so let us define some functions that will help us do so:
􏳼p high.x/ D x= u ;
̆
p low.x/ D xmod u;
p index.x;y/ D x uCy:
The function high.x/ gives the most significant .lg u/=2 bits of x, producing the number of x’s cluster. The function low.x/ gives the least significant .lg u/=2 bits of x and provides x’s position within its cluster. The function index.x; y/ builds an element number from x and y, treating x as the most significant .lg u/=2 bits of the element number and y as the least significant .lg u/=2 bits. We have the identity x D index.high.x/; low.x//. The value of u used by each of these functions will

538 Chapter 20 van Emde Boas Trees
u
proto-􏳪EB.u/ summary
proto-􏳪EB.
0 1 2 3 … pu􏳣1 cluster
p
u/ structure
pp
u proto-􏳪EB. u/ structures
Figure 20.3 The information in a proto-􏳪EB.u/ structure when u 􏳦 4. The structure contains the pp
universe size u, a pointer summary to a proto-􏳪EB. u/ structure, and an array clusterŒ0 : : u 􏳣 1􏳩 pp
of u pointers to proto-􏳪EB. u/ structures.
always be the universe size of the data structure in which we call the function,
which changes as we descend into the recursive structure.
20.2.1 Proto van Emde Boas structures
Taking our cue from recurrence (20.2), let us design a recursive data structure to support the operations. Although this data structure will fail to achieve our goal of O.lg lg u/ time for some operations, it serves as a basis for the van Emde Boas tree structure that we will see in Section 20.3.
For the universe f0;1;2;:::;u􏳣1g, we define a proto van Emde Boas struc- ture, or proto-vEB structure, which we denote as proto-􏳪EB.u/, recursively as follows. Each proto-􏳪EB.u/ structure contains an attribute u giving its universe size. In addition, it contains the following:
If u D 2, then it is the base size, and it contains an array AŒ0::1􏳩 of two bits.
Otherwise, u D 22k for some integer k 􏳦 1, so that u 􏳦 4. In addition to the universe size u, the data structure proto-􏳪EB.u/ contains the following attributes, illustrated in Figure 20.3:
􏳮 a pointer named summary to a proto-􏳪EB.pu/ structure and
􏳮 an array clusterŒ0 : : pu􏳣1􏳩 of pu pointers, each to a proto-􏳪EB.pu/ struc-
ture.
The element x, where 0 􏳥 x < u, is recursively stored in the cluster numbered high.x/ as element low.x/ within that cluster. In the two-level structure of the previous section, each node stores a summary array of size pu, in which each entry contains a bit. From the index of each entry, we can compute the starting index of the subarray of size pu that the bit summarizes. In the proto-vEB structure, we use explicit pointers rather than index 􏳮 􏳮 20.2 A recursive structure 539 proto-vEB(16) u 16 summary 0 1 2 3 cluster proto-vEB(4) u summary 01 u summary 01 u summary 01 444 uuuuuuuuu 222222222 AAAAAAAAA 000000000 111111111 cluster proto-vEB(4) cluster proto-vEB(4) cluster 1 1 1 1 0 1 0 1 0 0 1 1 1 1 1 1 0 1 clusters 0,1 clusters 2,3 elements 0,1 elements 2,3 elements 4,5 elements 6,7 proto-vEB(4) cluster proto-vEB(4) cluster usummary01 usummary01 44 uuuuuu 222222 AAAAAA 000000 111111 elements 8,9 elements 10,11 elements 12,13 elements 14,15 0 0 0 0 0 0 0 1 0 0 1 1 A proto-􏳪EB.16/ structure representing the set f2; 3; 4; 5; 7; 14; 15g. It points to four proto-􏳪EB.4/ structures in clusterŒ0 : : 3􏳩, and to a summary structure, which is also a proto-􏳪EB.4/. Each proto-􏳪EB.4/ structure points to two proto-􏳪EB.2/ structures in clusterŒ0::1􏳩, and to a proto-􏳪EB.2/ summary. Each proto-􏳪EB.2/ structure contains just an array AŒ0 : : 1􏳩 of two bits. The proto-􏳪EB.2/ structures above “elements i,j” store bits i and j of the actual dynamic set, and the proto-􏳪EB.2/ structures above “clusters i,j” store the summary bits for clusters i and j in the top-level proto-􏳪EB.16/ structure. For clarity, heavy shading indicates the top level of a proto-vEB structure that stores summary information for its parent structure; such a proto-vEB structure is otherwise identical to any other proto-vEB structure with the same universe size. Figure 20.4 proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) proto-vEB(2) 540 Chapter 20 van Emde Boas Trees calculations. The array summary contains the summary bits stored recursively in a proto-vEB structure, and the array cluster contains pu pointers. Figure 20.4 shows a fully expanded proto-􏳪EB.16/ structure representing the set f2; 3; 4; 5; 7; 14; 15g. If the value i is in the proto-vEB structure pointed to by summary, then the ith cluster contains some value in the set being represented. As in the tree of constant height, clusterŒi􏳩 represents the values ipu through .i C 1/pu 􏳣 1, which form the i th cluster. At the base level, the elements of the actual dynamic sets are stored in some of the proto-􏳪EB.2/ structures, and the remaining proto-􏳪EB.2/ structures store summary bits. Beneath each of the non-summary base structures, the figure in- dicates which bits it stores. For example, the proto-􏳪EB.2/ structure labeled “elements 6,7” stores bit 6 (0, since element 6 is not in the set) in its AŒ0􏳩 and bit 7 (1, since element 7 is in the set) in its AŒ1􏳩. p Like the clusters, each summary is just a dynamic set with universe size u , and so we represent each summary as a proto-􏳪EB.pu/ structure. The four sum- mary bits for the main proto-􏳪EB.16/ structure are in the leftmost proto-􏳪EB.4/ structure, and they ultimately appear in two proto-􏳪EB.2/ structures. For exam- ple, the proto-􏳪EB.2/ structure labeled “clusters 2,3” has AŒ0􏳩 D 0, indicating that cluster 2 of the proto-􏳪EB.16/ structure (containing elements 8; 9; 10; 11) is all 0, and AŒ1􏳩 D 1, telling us that cluster 3 (containing elements 12; 13; 14; 15) has at least one 1. Each proto-􏳪EB.4/ structure points to its own summary, which is itself stored as a proto-􏳪EB.2/ structure. For example, look at the proto-􏳪EB.2/ struc- ture just to the left of the one labeled “elements 0,1.” Because its AŒ0􏳩 is 0, it tells us that the “elements 0,1” structure is all 0, and because its AŒ1􏳩 is 1, we know that the “elements 2,3” structure contains at least one 1. 20.2.2 Operations on a proto van Emde Boas structure We shall now describe how to perform operations on a proto-vEB structure. We first examine the query operations—MEMBER, MINIMUM, MAXIMUM, and SUCCESSOR—which do not change the proto-vEB structure. We then discuss INSERT and DELETE. We leave MAXIMUM and PREDECESSOR, which are sym- metric to MINIMUM and SUCCESSOR, respectively, as Exercise 20.2-1. Each of the MEMBER, SUCCESSOR, PREDECESSOR, INSERT, and DELETE op- erations takes a parameter x, along with a proto-vEB structure V . Each of these operations assumes that 0 􏳥 x < V:u. Determining whether a value is in the set To perform MEMBER.x/, we need to find the bit corresponding to x within the appropriate proto-􏳪EB.2/ structure. We can do so in O.lg lg u/ time, bypassing 20.2 A recursive structure 541 the summary structures altogether. The following procedure takes a proto-􏳪EB structure V and a value x, and it returns a bit indicating whether x is in the dynamic set held by V . PROTO-VEB-MEMBER.V; x/ 1 ifV:u==2 2 return V:AŒx􏳩 3 else return PROTO-VEB-MEMBER.V:clusterŒhigh.x/􏳩;low.x// The PROTO-VEB-MEMBER procedure works as follows. Line 1 tests whether we are in a base case, where V is a proto-􏳪EB.2/ structure. Line 2 handles the base case, simply returning the appropriate bit of array A. Line 3 deals with the recursive case, “drilling down” into the appropriate smaller proto-vEB structure. The value high.x/ says which proto-􏳪EB.pu/ structure we visit, and low.x/ de- termines which element within that proto-􏳪EB.pu/ structure we are querying. Let’s see what happens when we call PROTO-VEB-MEMBER.V;6/ on the proto-􏳪EB.16/ structure in Figure 20.4. Since high.6/ D 1 when u D 16, we recurse into the proto-􏳪EB.4/ structure in the upper right, and we ask about ele- ment low.6/ D 2 of that structure. In this recursive call, u D 4, and so we recurse again. With u D 4, we have high.2/ D 1 and low.2/ D 0, and so we ask about element 0 of the proto-􏳪EB.2/ structure in the upper right. This recursive call turns out to be a base case, and so it returns AŒ0􏳩 D 0 back up through the chain of re- cursive calls. Thus, we get the result that PROTO-VEB-MEMBER.V;6/ returns 0, indicating that 6 is not in the set. To determine the running time of PROTO-VEB-MEMBER, let T.u/ denote its running time on a proto-􏳪EB.u/ structure. Each recursive call takes con- stant time, not including the time taken by the recursive calls that it makes. When PROTO-VEB-MEMBER makes a recursive call, it makes a call on a proto-􏳪EB.pu/ structure. Thus, we can characterize the running time by the recur- rence T .u/ D T .pu/ C O.1/, which we have already seen as recurrence (20.2). Its solution is T .u/ D O.lg lg u/, and so we conclude that PROTO-VEB-MEMBER runs in time O.lg lg u/. Finding the minimum element Now we examine how to perform the MINIMUM operation. The procedure PROTO-VEB-MINIMUM.V / returns the minimum element in the proto-vEB struc- ture V , or NIL if V represents an empty set. 542 Chapter 20 van Emde Boas Trees PROTO-VEB-MINIMUM.V / 1 2 3 4 5 6 7 8 9 10 11 ifV:u==2 if V:AŒ0􏳩 == 1 return 0 elseif V:AŒ1􏳩 == 1 return 1 else return N I L else min-cluster D PROTO-VEB-MINIMUM.V:summary/ if min-cluster == NIL return NIL else offset D PROTO-VEB-MINIMUM.V:clusterŒmin-cluster􏳩/ return index.min-cluster; offset/ This procedure works as follows. Line 1 tests for the base case, which lines 2–6 handle by brute force. Lines 7–11 handle the recursive case. First, line 7 finds the number of the first cluster that contains an element of the set. It does so by recur- sively calling PROTO-VEB-MINIMUM on V:summary, which is a proto-􏳪EB.pu/ structure. Line 7 assigns this cluster number to the variable min-cluster. If the set is empty, then the recursive call returned NIL, and line 9 returns NIL. Otherwise, the minimum element of the set is somewhere in cluster number min-cluster. The recursive call in line 10 finds the offset within the cluster of the minimum element in this cluster. Finally, line 11 constructs the value of the minimum element from the cluster number and offset, and it returns this value. Although querying the summary information allows us to quickly find the clus- ter containing the minimum element, because this procedure makes two recursive calls on proto-􏳪EB.pu/ structures, it does not run in O.lg lg u/ time in the worst case. Letting T.u/ denote the worst-case time for PROTO-VEB-MINIMUM on a proto-􏳪EB.u/ structure, we have the recurrence p Again, we use a change of variables to solve this recurrence, letting m D lg u, which gives T.2m/ D 2T.2m=2/ C O.1/ : Renaming S.m/ D T .2m/ gives S.m/ D 2S.m=2/ C O.1/ ; which, by case 1 of the master method, has the solution S.m/ D ‚.m/. By chang- ing back from S.m/ to T.u/, we have that T.u/ D T.2m/ D S.m/ D ‚.m/ D ‚.lgu/. Thus, we see that because of the second recursive call, PROTO-VEB- MINIMUM runs in ‚.lg u/ time rather than the desired O.lg lg u/ time. T.u/ D 2T. u/ C O.1/ : (20.3) 20.2 A recursive structure 543 Finding the successor The SUCCESSOR operation is even worse. In the worst case, it makes two recursive calls, along with a call to PROTO-VEB-MINIMUM. The procedure PROTO-VEB- SUCCESSOR.V;x/ returns the smallest element in the proto-vEB structure V that is greater than x, or NIL if no element in V is greater than x. It does not require x to be a member of the set, but it does assume that 0 􏳥 x < V:u. PROTO-VEB-SUCCESSOR.V; x/ 1 2 3 4 5 6 7 8 9 10 11 12 ifV:u==2 if x == 0 and V:AŒ1􏳩 == 1 return 1 else return NIL else offset D PROTO-VEB-SUCCESSOR.V:clusterŒhigh.x/􏳩; low.x// if offset ¤ NIL return index.high.x/; offset/ else succ-cluster D PROTO-VEB-SUCCESSOR.V:summary;high.x// if succ-cluster == NIL return NIL else offset D PROTO-VEB-MINIMUM.V:clusterŒsucc-cluster􏳩/ return index.succ-cluster; offset/ The PROTO-VEB-SUCCESSOR procedure works as follows. As usual, line 1 tests for the base case, which lines 2–4 handle by brute force: the only way that x can have a successor within a proto-􏳪EB.2/ structure is when x D 0 and AŒ1􏳩 is 1. Lines 5–12 handle the recursive case. Line 5 searches for a successor to x within x’s cluster, assigning the result to offset. Line 6 determines whether x has a successor within its cluster; if it does, then line 7 computes and returns the value of this successor. Otherwise, we have to search in other clusters. Line 8 assigns to succ-cluster the number of the next nonempty cluster, using the summary informa- tion to find it. Line 9 tests whether succ-cluster is NIL, with line 10 returning NIL if all succeeding clusters are empty. If succ-cluster is non-NIL, line 11 assigns the first element within that cluster to offset, and line 12 computes and returns the minimum element in that cluster. In the worst case, PROTO-VEB-SUCCESSOR calls itself recursively twice on proto-􏳪EB.pu/ structures, and it makes one call to PROTO-VEB-MINIMUM on a proto-􏳪EB.pu/ structure. Thus, the recurrence for the worst-case running time T .u/ of PROTO-VEB-SUCCESSOR is pp T.u/ D 2T.pu/ C ‚.lg u/ D 2T. u/C‚.lgu/: 544 Chapter 20 van Emde Boas Trees We can employ the same technique that we used for recurrence (20.1) to show that this recurrence has the solution T .u/ D ‚.lg u lg lg u/. Thus, PROTO-VEB- SUCCESSOR is asymptotically slower than PROTO-VEB-MINIMUM. Inserting an element To insert an element, we need to insert it into the appropriate cluster and also set the summary bit for that cluster to 1. The procedure PROTO-VEB-INSERT.V;x/ inserts the value x into the proto-vEB structure V . PROTO-VEB-INSERT.V;x/ 1 ifV:u==2 2 3 4 V:AŒx􏳩 D 1 else PROTO-VEB-INSERT.V:clusterŒhigh.x/􏳩; low.x// PROTO-VEB-INSERT.V:summary; high.x// In the base case, line 2 sets the appropriate bit in the array A to 1. In the recursive case, the recursive call in line 3 inserts x into the appropriate cluster, and line 4 sets the summary bit for that cluster to 1. Because PROTO-VEB-INSERT makes two recursive calls in the worst case, re- currence (20.3) characterizes its running time. Hence, PROTO-VEB-INSERT runs in ‚.lg u/ time. Deleting an element The DELETE operation is more complicated than insertion. Whereas we can always set a summary bit to 1 when inserting, we cannot always reset the same summary bit to 0 when deleting. We need to determine whether any bit in the appropriate cluster is 1. As we have defined proto-vEB structures, we would have to examine all pu bits within a cluster to determine whether any of them are 1. Alternatively, we could add an attribute n to the proto-vEB structure, counting how many el- ements it has. We leave implementation of PROTO-VEB-DELETE as Exercises 20.2-2 and 20.2-3. Clearly, we need to modify the proto-vEB structure to get each operation down to making at most one recursive call. We will see in the next section how to do so. Exercises 20.2-1 Write pseudocode for the procedures PROTO-VEB-MAXIMUM and PROTO-VEB- PREDECESSOR. 20.3 The van Emde Boas tree 545 20.2-2 Write pseudocode for PROTO-VEB-DELETE. It should update the appropriate summary bit by scanning the related bits within the cluster. What is the worst- case running time of your procedure? 20.2-3 Add the attribute n to each proto-vEB structure, giving the number of elements currently in the set it represents, and write pseudocode for PROTO-VEB-DELETE that uses the attribute n to decide when to reset summary bits to 0. What is the worst-case running time of your procedure? What other procedures need to change because of the new attribute? Do these changes affect their running times? 20.2-4 Modify the proto-vEB structure to support duplicate keys. 20.2-5 Modify the proto-vEB structure to support keys that have associated satellite data. 20.2-6 Write pseudocode for a procedure that creates a proto-􏳪EB.u/ structure. 20.2-7 Argue that if line 9 of PROTO-VEB-MINIMUM is executed, then the proto-vEB structure is empty. 20.2-8 Suppose that we designed a proto-vEB structure in which each cluster array had only u1=4 elements. What would the running times of each operation be? 20.3 The van Emde Boas tree The proto-vEB structure of the previous section is close to what we need to achieve O.lg lg u/ running times. It falls short because we have to recurse too many times in most of the operations. In this section, we shall design a data structure that is similar to the proto-vEB structure but stores a little more information, thereby removing the need for some of the recursion. In Section 20.2, we observed that the assumption that we made about the uni- verse size—that u D 22k for some integer k—is unduly restrictive, confining the possible values of u an overly sparse set. From this point on, therefore, we will allow the universe size u to be any exact power of 2, and when pu is not an inte- 546 Chapter 20 van Emde Boas Trees 􏳪EB.u/ u min max 0 1 2 3 ... p" u 􏳣 1 summary cluster 􏳪EB.p" u/ p" u􏳪EB.p# u/trees Figure 20.5 The information in a 􏳪EB.u/ tree when u > 2. The structure contains the uni- verse size u, elements min and max, a pointer summary to a 􏳪EB.p” u/ tree, and an array clusterŒ0 : : p” u 􏳣 1􏳩 of p” u pointers to 􏳪EB. p# u/ trees.
ger—that is, if u is an odd power of 2 (u D 22kC1 for some integer k 􏳦 0)—then we will divide the lg u bits of a number into the most significant d.lg u/=2e bits and the least significant b.lg u/=2c bits. For convenience, we denote 2d.lg u/=2e (the “up- per square root” of u) by p” u and 2b.lg u/=2c (the “lower square root” of u) by p# u, sothatuD p” u􏳵p# uand,whenuisanevenpowerof2(uD22k forsome integerk), p” uD p# uDpu. Becausewenowallowutobeanoddpowerof2, we must redefine our helpful functions from Section 20.2:
high.x/ D 􏳼x=p# u ̆ ;
l o w . x / D x m o d p# u ;
index.x;y/ D xp# uCy: 20.3.1 van Emde Boas trees
The van Emde Boas tree, or vEB tree, modifies the proto-vEB structure. We denote a vEB tree with a universe size of u as 􏳪EB.u/ and, unless u equals the base size of 2, the attribute summary points to a 􏳪EB.p” u/ tree and the array clusterŒ0 : : p” u 􏳣 1􏳩 points to p” u 􏳪EB. p# u/ trees. As Figure 20.5 illustrates, a vEB tree contains two attributes not found in a proto-vEB structure:
min stores the minimum element in the vEB tree, and max stores the maximum element in the vEB tree.
Furthermore, the element stored in min does not appear in any of the recur- sive 􏳪EB.p# u/ trees that the cluster array points to. The elements stored in a 􏳪EB.u/ tree V , therefore, are V:min plus all the elements recursively stored in the 􏳪EB.p# u/ trees pointed to by V:clusterŒ0:: p” u 􏳣 1􏳩. Note that when a vEB tree contains two or more elements, we treat min and max differently: the element
􏳮 􏳮

20.3 The van Emde Boas tree 547
stored in min does not appear in any of the clusters, but the element stored in max does.
Since the base size is 2, a 􏳪EB.2/ tree does not need the array A that the cor- responding proto-􏳪EB.2/ structure has. Instead, we can determine its elements from its min and max attributes. In a vEB tree with no elements, regardless of its universe size u, both min and max are NIL.
Figure 20.6 shows a 􏳪EB.16/ tree V holding the set f2; 3; 4; 5; 7; 14; 15g. Be- cause the smallest element is 2, V:min equals 2, and even though high.2/ D 0, the element 2 does not appear in the 􏳪EB.4/ tree pointed to by V:clusterŒ0􏳩: notice that V:clusterŒ0􏳩:min equals 3, and so 2 is not in this vEB tree. Similarly, since V:clusterŒ0􏳩:min equals 3, and 2 and 3 are the only elements in V:clusterŒ0􏳩, the 􏳪EB.2/ clusters within V:clusterŒ0􏳩 are empty.
The min and max attributes will turn out to be key to reducing the number of recursive calls within the operations on vEB trees. These attributes will help us in four ways:
1. The MINIMUM and MAXIMUM operations do not even need to recurse, for they can just return the values of min or max.
2. The SUCCESSOR operation can avoid making a recursive call to determine whether the successor of a value x lies within high.x/. That is because x’s successor lies within its cluster if and only if x is strictly less than the max attribute of its cluster. A symmetric argument holds for P R E D E C E S S O R and min.
3. We can tell whether a vEB tree has no elements, exactly one element, or at least two elements in constant time from its min and max values. This ability will help in the INSERT and DELETE operations. If min and max are both NIL, then the vEB tree has no elements. If min and max are non-NIL but are equal to each other, then the vEB tree has exactly one element. Otherwise, both min and max are non-NIL but are unequal, and the vEB tree has two or more elements.
4. IfweknowthatavEBtreeisempty,wecaninsertanelementintoitbyupdating only its min and max attributes. Hence, we can insert into an empty vEB tree in constant time. Similarly, if we know that a vEB tree has only one element, we can delete that element in constant time by updating only min and max. These properties will allow us to cut short the chain of recursive calls.
Even if the universe size u is an odd power of 2, the difference in the sizes
of the summary vEB tree and the clusters will not turn out to affect the asymptotic running times of the vEB-tree operations. The recursive procedures that implement the vEB-tree operations will all have running times characterized by the recurrence
T.u/􏳥T.p” u/CO.1/: (20.4)

548 Chapter 20 van Emde Boas Trees
vEB(16) u 16 min 2 max 15 0123
summary cluster
vEB(4) u4 min0 max3 vEB(4) u4 min3 max3 vEB(4) u4 min0 max3 010101
summary cluster summary cluster summary cluster
vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) uuuuuuuuu
2
0
1
2
1
1
2
1
1
2
2
2
2
0
1
2
1
1
2
1
1
min max
min min max max
min min min max max max
min min min max max max
vEB(4) u4 min2 max3 summary cluster summary cluster
vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) vEB(2) uuuuuu min min min min min min max max max max max max
vEB(4) u4 min max
01 01
2
2
2
2
1
1
2
2
1
1
A 􏳪EB.16/ tree corresponding to the proto-vEB tree in Figure 20.4. It stores the set f2; 3; 4; 5; 7; 14; 15g. Slashes indicate NIL values. The value stored in the min attribute of a vEB tree does not appear in any of its clusters. Heavy shading serves the same purpose here as in Figure 20.4.
Figure 20.6

20.3 The van Emde Boas tree 549
This recurrence looks similar to recurrence (20.2), and we will solve it in a similar fashion. Letting m D lg u, we rewrite it as
T.2m/ 􏳥 T.2dm=2e/ C O.1/ :
Noting that dm=2e 􏳥 2m=3 for all m 􏳦 2, we have T.2m/ 􏳥 T.22m=3/ C O.1/ :
Letting S.m/ D T.2m/, we rewrite this last recurrence as S.m/ 􏳥 S.2m=3/ C O.1/ ;
which, by case 2 of the master method, has the solution S.m/ D O.lg m/. (In terms of the asymptotic solution, the fraction 2=3 does not make any difference compared with the fraction 1=2, because when we apply the master method, we find that log3=21 D log21 D 0:) Thus, we have T.u/ D T.2m/ D S.m/ D O.lg m/ D O.lg lg u/.
Before using a van Emde Boas tree, we must know the universe size u, so that we can create a van Emde Boas tree of the appropriate size that initially represents an empty set. As Problem 20-1 asks you to show, the total space requirement of a van Emde Boas tree is O.u/, and it is straightforward to create an empty tree in O.u/ time. In contrast, we can create an empty red-black tree in constant time. Therefore, we might not want to use a van Emde Boas tree when we perform only a small number of operations, since the time to create the data structure would exceed the time saved in the individual operations. This drawback is usually not significant, since we typically use a simple data structure, such as an array or linked list, to represent a set with only a few elements.
20.3.2 Operations on a van Emde Boas tree
We are now ready to see how to perform operations on a van Emde Boas tree. As we did for the proto van Emde Boas structure, we will consider the querying oper- ations first, and then INSERT and DELETE. Due to the slight asymmetry between the minimum and maximum elements in a vEB tree—when a vEB tree contains at least two elements, the minumum element does not appear within a cluster but the maximum element does—we will provide pseudocode for all five querying op- erations. As in the operations on proto van Emde Boas structures, the operations here that take parameters V and x, where V is a van Emde Boas tree and x is an element, assume that 0 􏳥 x < V:u. Finding the minimum and maximum elements Because we store the minimum and maximum in the attributes min and max, two of the operations are one-liners, taking constant time: 550 Chapter 20 van Emde Boas Trees VEB-TREE-MINIMUM.V / 1 return V:min VEB-TREE-MAXIMUM.V / 1 return V:max Determining whether a value is in the set The procedure VEB-TREE-MEMBER.V;x/ has a recursive case like that of PROTO-VEB-MEMBER, but the base case is a little different. We also check di- rectly whether x equals the minimum or maximum element. Since a vEB tree doesn’t store bits as a proto-vEB structure does, we design VEB-TREE-MEMBER to return TRUE or FALSE rather than 1 or 0. VEB-TREE-MEMBER.V;x/ 1 2 3 4 5 ifx==V:minorx==V:max return TRUE elseif V:u == 2 return FALSE else return VEB-TREE-MEMBER.V:clusterŒhigh.x/􏳩;low.x// Line 1 checks to see whether x equals either the minimum or maximum element. If it does, line 2 returns TRUE. Otherwise, line 3 tests for the base case. Since a 􏳪EB.2/ tree has no elements other than those in min and max, if it is the base case, line 4 returns FALSE. The other possibility—it is not a base case and x equals neither min nor max—is handled by the recursive call in line 5. Recurrence (20.4) characterizes the running time of the VEB-TREE-MEMBER procedure, and so this procedure takes O.lg lg u/ time. Finding the successor and predecessor Next we see how to implement the SUCCESSOR operation. Recall that the pro- cedure PROTO-VEB-SUCCESSOR.V;x/ could make two recursive calls: one to determine whether x’s successor resides in the same cluster as x and, if it does not, one to find the cluster containing x’s successor. Because we can access the maximum value in a vEB tree quickly, we can avoid making two recursive calls, and instead make one recursive call on either a cluster or on the summary, but not on both. 20.3 The van Emde Boas tree 551 VEB-TREE-SUCCESSOR.V;x/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ifV:u==2 if x == 0 and V:max == 1 return 1 else return NIL elseif V:min ¤ NIL and x < V:min return V:min else max-low D VEB-TREE-MAXIMUM.V:clusterŒhigh.x/􏳩/ if max-low ¤ NIL and low.x/ < max-low offset D VEB-TREE-SUCCESSOR.V:clusterŒhigh.x/􏳩;low.x// return index.high.x/; offset/ else succ-cluster D VEB-TREE-SUCCESSOR.V:summary;high.x// if succ-cluster == NIL return NIL else offset D VEB-TREE-MINIMUM.V:clusterŒsucc-cluster􏳩/ return index.succ-cluster; offset/ This procedure has six return statements and several cases. We start with the base case in lines 2–4, which returns 1 in line 3 if we are trying to find the successor of 0 and 1 is in the 2-element set; otherwise, the base case returns NIL in line 4. If we are not in the base case, we next check in line 5 whether x is strictly less than the minimum element. If so, then we simply return the minimum element in line 6. If we get to line 7, then we know that we are not in a base case and that x is greater than or equal to the minimum value in the vEB tree V . Line 7 assigns to max-low the maximum element in x’s cluster. If x’s cluster contains some element that is greater than x, then we know that x’s successor lies somewhere within x’s cluster. Line 8 tests for this condition. If x’s successor is within x’s cluster, then line 9 determines where in the cluster it is, and line 10 returns the successor in the same way as line 7 of PROTO-VEB-SUCCESSOR. We get to line 11 if x is greater than or equal to the greatest element in its cluster. In this case, lines 11–15 find x’s successor in the same way as lines 8–12 of PROTO-VEB-SUCCESSOR. It is easy to see how recurrence (20.4) characterizes the running time of VEB- TREE-SUCCESSOR. Depending on the result of the test in line 7, the procedure calls itself recursively in either line 9 (on a vEB tree with universe size p# u) or line 11 (on a vEB tree with universe size p" u). In either case, the one recursive call is on a vEB tree with universe size at most p" u. The remainder of the proce- dure, including the calls to VEB-TREE-MINIMUM and VEB-TREE-MAXIMUM, takes O.1/ time. Hence, VEB-TREE-SUCCESSOR runs in O.lg lg u/ worst-case time. 552 Chapter 20 van Emde Boas Trees The VEB-TREE-PREDECESSOR procedure is symmetric to the VEB-TREE- SUCCESSOR procedure, but with one additional case: VEB-TREE-PREDECESSOR.V;x/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ifV:u==2 if x == 1 and V:min == 0 return 0 else return NIL elseif V:max ¤ NIL and x > V:max return V:max
else min-low D VEB-TREE-MINIMUM.V:clusterŒhigh.x/􏳩/ if min-low ¤ NIL and low.x/ > min-low
offset D VEB-TREE-PREDECESSOR.V:clusterŒhigh.x/􏳩;low.x//
return index.high.x/; offset/
else pred-cluster D VEB-TREE-PREDECESSOR.V:summary; high.x//
if pred-cluster == NIL
if V:min ¤ NIL and x > V:min
return V:min else return NIL
else offset D VEB-TREE-MAXIMUM.V:clusterŒpred-cluster􏳩/ return index.pred-cluster; offset/
Lines 13–14 form the additional case. This case occurs when x’s predecessor, if it exists, does not reside in x’s cluster. In VEB-TREE-SUCCESSOR, we were assured that if x’s successor resides outside of x’s cluster, then it must reside in a higher-numbered cluster. But if x’s predecessor is the minimum value in vEB tree V , then the successor resides in no cluster at all. Line 13 checks for this condition, and line 14 returns the minimum value as appropriate.
This extra case does not affect the asymptotic running time of VEB-TREE- PREDECESSOR when compared with VEB-TREE-SUCCESSOR, and so VEB- TREE-PREDECESSOR runs in O.lg lg u/ worst-case time.
Inserting an element
Now we examine how to insert an element into a vEB tree. Recall that PROTO- VEB-INSERT made two recursive calls: one to insert the element and one to insert the element’s cluster number into the summary. The VEB-TREE-INSERT proce- dure will make only one recursive call. How can we get away with just one? When we insert an element, either the cluster that it goes into already has another element or it does not. If the cluster already has another element, then the cluster number is already in the summary, and so we do not need to make that recursive call. If

20.3 The van Emde Boas tree 553
the cluster does not already have another element, then the element being inserted becomes the only element in the cluster, and we do not need to recurse to insert an element into an empty vEB tree:
VEB-EMPTY-TREE-INSERT .V; x/
1 V:min D x
2 V:max D x
With this procedure in hand, here is the pseudocode for VEB-TREE-INSERT .V; x/, which assumes that x is not already an element in the set represented by vEB tree V :
VEB-TREE-INSERT .V; x/
1 2 3 4 5 6 7 8 9
10 11
if V:min == NIL VEB-EMPTY-TREE-INSERT .V; x/
else if x < V:min exchange x with V:min if V:u > 2
if VEB-TREE-MINIMUM.V:clusterŒhigh.x/􏳩/ == NIL
VEB-TREE-INSERT.V:summary;high.x//
VEB-EMPTY-TREE-INSERT.V:clusterŒhigh.x/􏳩;low.x// else VEB-TREE-INSERT.V:clusterŒhigh.x/􏳩;low.x//
if x > V:max V:max D x
This procedure works as follows. Line 1 tests whether V is an empty vEB tree and, if it is, then line 2 handles this easy case. Lines 3–11 assume that V is not empty, and therefore some element will be inserted into one of V ’s clusters. But that element might not necessarily be the element x passed to VEB-TREE-INSERT. If x < min, as tested in line 3, then x needs to become the new min. We don’t want to lose the original min, however, and so we need to insert it into one of V ’s clusters. In this case, line 4 exchanges x with min, so that we insert the original min into one of V ’s clusters. We execute lines 6–9 only if V is not a base-case vEB tree. Line 6 determines whether the cluster that x will go into is currently empty. If so, then line 7 in- serts x’s cluster number into the summary and line 8 handles the easy case of inserting x into an empty cluster. If x’s cluster is not currently empty, then line 9 inserts x into its cluster. In this case, we do not need to update the summary, since x’s cluster number is already a member of the summary. Finally, lines 10–11 take care of updating max if x > max. Note that if V is a base-case vEB tree that is not empty, then lines 3–4 and 10–11 update min and max properly.

554 Chapter 20 van Emde Boas Trees
Once again, we can easily see how recurrence (20.4) characterizes the running time. Depending on the result of the test in line 6, either the recursive call in line 7 (run on a vEB tree with universe size p” u) or the recursive call in line 9 (run on a vEB with universe size p# u) executes. In either case, the one recursive call is on a vEB tree with universe size at most p” u. Because the remainder of VEB- TREE-INSERT takes O.1/ time, recurrence (20.4) applies, and so the running time is O.lg lg u/.
Deleting an element
Finally, we look at how to delete an element from a vEB tree. The procedure VEB-TREE-DELETE.V;x/ assumes that x is currently an element in the set repre- sented by the vEB tree V .
VEB-TREE-DELETE.V;x/
1 2 3 4 5 6 7 8 9
10 11
12
13
14
15
16
17
18
19
20
21 22
if V:min == V:max V:min D NIL V:max D NIL
elseif V:u == 2 ifx==0
V:min D 1 elseV:minD0
V: max D V: min else if x == V:min
first-cluster D VEB-TREE-MINIMUM.V:summary/ x D index.first-cluster;
VEB-TREE-MINIMUM.V:clusterŒfirst-cluster􏳩// V:min D x
VEB-TREE-DELETE.V:clusterŒhigh.x/􏳩;low.x//
if VEB-TREE-MINIMUM.V:clusterŒhigh.x/􏳩/ == NIL
VEB-TREE-DELETE.V:summary;high.x// if x == V:max
summary-max D VEB-TREE-MAXIMUM.V:summary/ if summary-max == NIL
V:max D V:min
else V:max D index.summary-max;
VEB-TREE-MAXIMUM.V:clusterŒsummary-max􏳩//
elseif x == V:max
V:max D index.high.x/;
VEB-TREE-MAXIMUM.V:clusterŒhigh.x/􏳩//

20.3 The van Emde Boas tree 555
The VEB-TREE-DELETE procedure works as follows. If the vEB tree V con- tains only one element, then it’s just as easy to delete it as it was to insert an element into an empty vEB tree: just set min and max to NIL. Lines 1–3 handle this case. Otherwise, V has at least two elements. Line 4 tests whether V is a base-case vEB tree and, if so, lines 5–8 set min and max to the one remaining element.
Lines 9–22 assume that V has two or more elements and that u 􏳦 4. In this case, we will have to delete an element from a cluster. The element we delete from a cluster might not be x, however, because if x equals min, then once we have deleted x, some other element within one of V ’s clusters becomes the new min, and we have to delete that other element from its cluster. If the test in line 9 reveals that we are in this case, then line 10 sets first-cluster to the number of the cluster that contains the lowest element other than min, and line 11 sets x to the value of the lowest element in that cluster. This element becomes the new min in line 12 and, because we set x to its value, it is the element that will be deleted from its cluster.
When we reach line 13, we know that we need to delete element x from its cluster, whether x was the value originally passed to VEB-TREE-DELETE or x is the element becoming the new minimum. Line 13 deletes x from its cluster. That cluster might now become empty, which line 14 tests, and if it does, then we need to remove x’s cluster number from the summary, which line 15 handles. After updating the summary, we might need to update max. Line 16 checks to see whether we are deleting the maximum element in V and, if we are, then line 17 sets summary-max to the number of the highest-numbered nonempty cluster. (The call VEB-TREE-MAXIMUM.V:summary/ works because we have already recursively called VEB-TREE-DELETE on V:summary, and therefore V:summary:max has al- ready been updated as necessary.) If all of V ’s clusters are empty, then the only remaining element in V is min; line 18 checks for this case, and line 19 updates max appropriately. Otherwise, line 20 sets max to the maximum element in the highest-numbered cluster. (If this cluster is where the element has been deleted, we again rely on the recursive call in line 13 having already corrected that cluster’s max attribute.)
Finally, we have to handle the case in which x’s cluster did not become empty due to x being deleted. Although we do not have to update the summary in this case, we might have to update max. Line 21 tests for this case, and if we have to update max, line 22 does so (again relying on the recursive call to have corrected max in the cluster).
Now we show that VEB-TREE-DELETE runs in O.lg lg u/ time in the worst case. At first glance, you might think that recurrence (20.4) does not always apply, because a single call of VEB-TREE-DELETE can make two recursive calls: one on line 13 and one on line 15. Although the procedure can make both recursive calls, let’s think about what happens when it does. In order for the recursive call on

556 Chapter 20 van Emde Boas Trees
line 15 to occur, the test on line 14 must show that x’s cluster is empty. The only way that x’s cluster can be empty is if x was the only element in its cluster when we made the recursive call on line 13. But if x was the only element in its cluster, then that recursive call took O.1/ time, because it executed only lines 1–3. Thus, we have two mutually exclusive possibilities:
The recursive call on line 13 took constant time. The recursive call on line 15 did not occur.
In either case, recurrence (20.4) characterizes the running time of VEB-TREE- DELETE, and hence its worst-case running time is O.lg lg u/.
Exercises
20.3-1
Modify vEB trees to support duplicate keys.
20.3-2
Modify vEB trees to support keys that have associated satellite data.
20.3-3
Write pseudocode for a procedure that creates an empty van Emde Boas tree.
20.3-4
What happens if you call VEB-TREE-INSERT with an element that is already in the vEB tree? What happens if you call VEB-TREE-DELETE with an element that is not in the vEB tree? Explain why the procedures exhibit the behavior that they do. Show how to modify vEB trees and their operations so that we can check in constant time whether an element is present.
20.3-5 p” p#
Suppose that instead of u clusters, each with universe size u, we constructed vEB trees to have u1=k clusters, each with universe size u1􏳣1=k, where k > 1 is a constant. If we were to modify the operations appropriately, what would be their running times? For the purpose of analysis, assume that u1=k and u1􏳣1=k are always integers.
20.3-6
Creating a vEB tree with universe size u requires O.u/ time. Suppose we wish to explicitly account for that time. What is the smallest number of operations n for which the amortized time of each operation in a vEB tree is O.lg lg u/?
􏳮 􏳮

Problems for Chapter 20 557
Problems
20-1 Space requirements for van Emde Boas trees
This problem explores the space requirements for van Emde Boas trees and sug- gests a way to modify the data structure to make its space requirement depend on the number n of elements actually stored in the tree, rather than on the universe size u. For simplicity, assume that pu is always an integer.
a. ExplainwhythefollowingrecurrencecharacterizesthespacerequirementP.u/ of a van Emde Boas tree with universe size u:
ppp
P.u/D. uC1/P. u/C‚. u/: (20.5)
b. Prove that recurrence (20.5) has the solution P.u/ D O.u/.
In order to reduce the space requirements, let us define a reduced-space van Emde Boas tree, or RS-vEB tree, as a vEB tree V but with the following changes:
The attribute V:cluster, rather than being stored as a simple array of pointers to vEB trees with universe size pu, is a hash table (see Chapter 11) stored as a dy- namic table (see Section 17.4). Corresponding to the array version of V:cluster, the hash table stores pointers to RS-vEB trees with universe size pu. To find the ith cluster, we look up the key i in the hash table, so that we can find the ith cluster by a single search in the hash table.
The hash table stores only pointers to nonempty clusters. A search in the hash table for an empty cluster returns NIL, indicating that the cluster is empty.
The attribute V:summary is NIL if all clusters are empty. Otherwise, V:summary points to an RS-vEB tree with universe size pu.
Because the hash table is implemented with a dynamic table, the space it requires is proportional to the number of nonempty clusters.
When we need to insert an element into an empty RS-vEB tree, we create the RS- vEB tree by calling the following procedure, where the parameter u is the universe size of the RS-vEB tree:
CREATE-NEW-RS-VEB-TREE.u/
1 allocate a new vEB tree V
2 V:uDu
3 V:min D NIL
4 V:max D NIL
5 V:summary D NIL
6 create V:cluster as an empty dynamic hash table
7 return V
􏳮
􏳮
􏳮

558 Chapter 20 van Emde Boas Trees
c. Modify the VEB-TREE-INSERT procedure to produce pseudocode for the pro- cedure RS-VEB-TREE-INSERT .V; x/, which inserts x into the RS-vEB tree V , calling CREATE-NEW-RS-VEB-TREE as appropriate.
d. Modify the VEB-TREE-SUCCESSOR procedure to produce pseudocode for the procedure RS-VEB-TREE-SUCCESSOR.V;x/, which returns the successor ofxinRS-vEBtreeV,orNIL ifxhasnosuccessorinV.
e. Prove that, under the assumption of simple uniform hashing, your RS-VEB- TREE-INSERT and RS-VEB-TREE-SUCCESSOR procedures run in O.lg lg u/ expected time.
f. Assuming that elements are never deleted from a vEB tree, prove that the space requirement for the RS-vEB tree structure is O.n/, where n is the number of elements actually stored in the RS-vEB tree.
g. RS-vEB trees have another advantage over vEB trees: they require less time to create. How long does it take to create an empty RS-vEB tree?
20-2 y-fast tries
This problem investigates D. Willard’s “y-fast tries” which, like van Emde Boas trees, perform each of the operations MEMBER, MINIMUM, MAXIMUM, PRE- DECESSOR, and SUCCESSOR on elements drawn from a universe with size u in O.lg lg u/ worst-case time. The INSERT and DELETE operations take O.lg lg u/ amortized time. Like reduced-space van Emde Boas trees (see Problem 20-1), y- fast tries use only O.n/ space to store n elements. The design of y-fast tries relies on perfect hashing (see Section 11.5).
As a preliminary structure, suppose that we create a perfect hash table containing not only every element in the dynamic set, but every prefix of the binary represen- tation of every element in the set. For example, if u D 16, so that lg u D 4, and x D 13 is in the set, then because the binary representation of 13 is 1101, the perfect hash table would contain the strings 1, 11, 110, and 1101. In addition to the hash table, we create a doubly linked list of the elements currently in the set, in increasing order.
a. How much space does this structure require?
b. Show how to perform the MINIMUM and MAXIMUM operations in O.1/ time; the MEMBER, PREDECESSOR, and SUCCESSOR operations in O.lg lg u/ time; and the INSERT and DELETE operations in O.lg u/ time.
To reduce the space requirement to O.n/, we make the following changes to the data structure:

Notes for Chapter 20 559
We cluster the n elements into n= lg u groups of size lg u. (Assume for now that lg u divides n.) The first group consists of the lg u smallest elements in the set, the second group consists of the next lg u smallest elements, and so on.
We designate a “representative” value for each group. The representative of the ith group is at least as large as the largest element in the ith group, and it is smaller than every element of the .i C 1/st group. (The representative of the last group can be the maximum possible element u 􏳣 1.) Note that a representative might be a value not currently in the set.
We store the lg u elements of each group in a balanced binary search tree, such as a red-black tree. Each representative points to the balanced binary search tree for its group, and each balanced binary search tree points to its group’s representative.
The perfect hash table stores only the representatives, which are also stored in a doubly linked list in increasing order.
We call this structure a y-fast trie.
c. Show that a y-fast trie requires only O.n/ space to store n elements.
d. Show how to perform the MINIMUM and MAXIMUM operations in O.lg lg u/ time with a y-fast trie.
e. Show how to perform the MEMBER operation in O.lg lg u/ time.
f. Show how to perform the PREDECESSOR and SUCCESSOR operations in
O.lg lg u/ time.
g. ExplainwhytheINSERTandDELETEoperationstake􏳫.lglgu/time.
h. Show how to relax the requirement that each group in a y-fast trie has exactly lg u elements to allow INSERT and DELETE to run in O.lg lg u/ amortized time without affecting the asymptotic running times of the other operations.
Chapter notes
The data structure in this chapter is named after P. van Emde Boas, who described an early form of the idea in 1975 [339]. Later papers by van Emde Boas [340] and van Emde Boas, Kaas, and Zijlstra [341] refined the idea and the exposition. Mehlhorn and Na ̈her [252] subsequently extended the ideas to apply to universe
􏳮
􏳮
􏳮
􏳮

560 Chapter 20 van Emde Boas Trees
sizes that are prime. Mehlhorn’s book [249] contains a slightly different treatment of van Emde Boas trees than the one in this chapter.
Using the ideas behind van Emde Boas trees, Dementiev et al. [83] developed a nonrecursive, three-level search tree that ran faster than van Emde Boas trees in their own experiments.
Wang and Lin [347] designed a hardware-pipelined version of van Emde Boas trees, which achieves constant amortized time per operation and uses O.lg lg u/ stages in the pipeline.
A lower bound by Paˇtras ̧cu and Thorup [273, 274] for finding the predecessor shows that van Emde Boas trees are optimal for this operation, even if randomiza- tion is allowed.

21 Data Structures for Disjoint Sets
Some applications involve grouping n distinct elements into a collection of disjoint sets. These applications often need to perform two operations in particular: finding the unique set that contains a given element and uniting two sets. This chapter explores methods for maintaining a data structure that supports these operations.
Section 21.1 describes the operations supported by a disjoint-set data structure and presents a simple application. In Section 21.2, we look at a simple linked-list implementation for disjoint sets. Section 21.3 presents a more efficient represen- tation using rooted trees. The running time using the tree representation is theo- retically superlinear, but for all practical purposes it is linear. Section 21.4 defines and discusses a very quickly growing function and its very slowly growing inverse, which appears in the running time of operations on the tree-based implementation, and then, by a complex amortized analysis, proves an upper bound on the running time that is just barely superlinear.
21.1 Disjoint-set operations
A disjoint-set data structure maintains a collection S D fS1;S2;:::;Skg of dis- joint dynamic sets. We identify each set by a representative, which is some mem- ber of the set. In some applications, it doesn’t matter which member is used as the representative; we care only that if we ask for the representative of a dynamic set twice without modifying the set between the requests, we get the same answer both times. Other applications may require a prespecified rule for choosing the repre- sentative, such as choosing the smallest member in the set (assuming, of course, that the elements can be ordered).
As in the other dynamic-set implementations we have studied, we represent each element of a set by an object. Letting x denote an object, we wish to support the following operations:

562 Chapter 21 Data Structures for Disjoint Sets
MAKE-SET.x/ creates a new set whose only member (and thus representative) is x. Since the sets are disjoint, we require that x not already be in some other set.
UNION.x;y/ unites the dynamic sets that contain x and y, say Sx and Sy, into a new set that is the union of these two sets. We assume that the two sets are dis- joint prior to the operation. The representative of the resulting set is any member of Sx [ Sy , although many implementations of UNION specifically choose the representative of either Sx or Sy as the new representative. Since we require the sets in the collection to be disjoint, conceptually we destroy sets Sx and Sy , removing them from the collection S. In practice, we often absorb the elements of one of the sets into the other set.
FIND-SET.x/ returns a pointer to the representative of the (unique) set contain- ing x.
Throughout this chapter, we shall analyze the running times of disjoint-set data structures in terms of two parameters: n, the number of MAKE-SET operations, and m, the total number of MAKE-SET, UNION, and FIND-SET operations. Since the sets are disjoint, each UNION operation reduces the number of sets by one. After n 􏳣 1 UNION operations, therefore, only one set remains. The number of UNION operations is thus at most n 􏳣 1. Note also that since the MAKE-SET operations are included in the total number of operations m, we have m 􏳦 n. We assume that the n MAKE-SET operations are the first n operations performed.
An application of disjoint-set data structures
One of the many applications of disjoint-set data structures arises in determin- ing the connected components of an undirected graph (see Section B.4). Fig- ure 21.1(a), for example, shows a graph with four connected components.
The procedure CONNECTED-COMPONENTS that follows uses the disjoint-set operations to compute the connected components of a graph. Once CONNECTED- COMPONENTS has preprocessed the graph, the procedure SAME-COMPONENT answers queries about whether two vertices are in the same connected component.1 (In pseudocode, we denote the set of vertices of a graph G by G:V and the set of edges by G:E.)
1When the edges of the graph are static—not changing over time—we can compute the connected components faster by using depth-first search (Exercise 22.3-12). Sometimes, however, the edges are added dynamically and we need to maintain the connected components as each edge is added. In this case, the implementation given here can be more efficient than running a new depth-first search for each new edge.

21.1 Disjoint-set operations
563
abefhj
cdg i
(a)
Collection {b} {c} {d}
{b,d} {c} {b,d} {c} {b,d} {b,d}
(b)
CONNECTED-COMPONENTS.G/
Edge processed
initial sets {a}
(b,d) {a}
(e,g) {a}
(a,c) {a,c} (h,i) {a,c} (a,b) {a,b,c,d}
(e, f ) {a,b,c,d} (b,c) {a,b,c,d}
of disjoint sets {e} {f} {e} {f} {e,g} {f} {e,g} {f} {e,g} {f} {e,g} {f} {e, f,g}
{e, f,g}
{g} {g}
{h} {i} {h} {i} {h} {i} {h} {i} {h,i}
{h,i} {h,i} {h,i}
{j} {j} {j} {j} {j} {j} {j} {j}
1 2 3 4 5
1 2 3
for each vertex 􏳪 2 G:V MAKE-SET.􏳪/
for each edge .u; 􏳪/ 2 G:E
if FIND-SET.u/ ¤ FIND-SET.􏳪/
(a) A graph with four connected components: fa; b; c; d g, fe; f; gg, fh; i g, and fj g.
Figure 21.1
(b) The collection of disjoint sets after processing each edge.
UNION.u; 􏳪/ SAME-COMPONENT.u; 􏳪/
if FIND-SET.u/ == FIND-SET.􏳪/ return TRUE
else return FALSE
The procedure CONNECTED-COMPONENTS initially places each vertex 􏳪 in its own set. Then, for each edge .u;􏳪/, it unites the sets containing u and 􏳪. By Exercise 21.1-2, after processing all the edges, two vertices are in the same con- nected component if and only if the corresponding objects are in the same set. Thus, CONNECTED-COMPONENTS computes sets in such a way that the proce- dure SAME-COMPONENT can determine whether two vertices are in the same con-

564 Chapter 21 Data Structures for Disjoint Sets
nected component. Figure 21.1(b) illustrates how CONNECTED-COMPONENTS computes the disjoint sets.
In an actual implementation of this connected-components algorithm, the repre- sentations of the graph and the disjoint-set data structure would need to reference each other. That is, an object representing a vertex would contain a pointer to the corresponding disjoint-set object, and vice versa. These programming details depend on the implementation language, and we do not address them further here.
Exercises
21.1-1
Suppose that CONNECTED-COMPONENTS is run on the undirected graph G D .V;E/, where V D fa;b;c;d;e;f;g;h;i;j;kg and the edges of E are pro- cessed in the order .d;i/;.f;k/;.g;i/;.b;g/;.a;h/;.i;j/;.d;k/;.b;j/;.d;f /; .g; j /; .a; e/. List the vertices in each connected component after each iteration of lines 3–5.
21.1-2
Show that after all edges are processed by CONNECTED-COMPONENTS, two ver- tices are in the same connected component if and only if they are in the same set.
21.1-3
During the execution of CONNECTED-COMPONENTS on an undirected graph G D .V; E/ with k connected components, how many times is FIND-SET called? How many times is UNION called? Express your answers in terms of jV j, jEj, and k.
21.2 Linked-list representation of disjoint sets
Figure 21.2(a) shows a simple way to implement a disjoint-set data structure: each set is represented by its own linked list. The object for each set has attributes head, pointing to the first object in the list, and tail, pointing to the last object. Each object in the list contains a set member, a pointer to the next object in the list, and a pointer back to the set object. Within each linked list, the objects may appear in any order. The representative is the set member in the first object in the list.
With this linked-list representation, both MAKE-SET and FIND-SET are easy, requiring O.1/ time. To carry out MAKE-SET.x/, we create a new linked list whose only object is x. For FIND-SET.x/, we just follow the pointer from x back to its set object and then return the member in the object that head points to. For example, in Figure 21.2(a), the call FIND-SET.g/ would return f .

21.2 Linked-list representation of disjoint sets 565
(a)
(b) S1
f
g
d
c
h
e
b
head tail
head tail
S1 S2
f
g
d
c
h
e
b
head tail
Figure 21.2 (a) Linked-list representations of two sets. Set S1 contains members d , f , and g, with representative f , and set S2 contains members b, c, e, and h, with representative c. Each object in the list contains a set member, a pointer to the next object in the list, and a pointer back to the set object. Each set object has pointers head and tail to the first and last objects, respectively. (b) The result of UNION.g; e/, which appends the linked list containing e to the linked list containing g. The representative of the resulting set is f . The set object for e’s list, S2, is destroyed.
A simple implementation of union
The simplest implementation of the UNION operation using the linked-list set rep- resentation takes significantly more time than MAKE-SET or FIND-SET. As Fig- ure 21.2(b) shows, we perform UNION.x;y/ by appending y’s list onto the end of x’s list. The representative of x’s list becomes the representative of the resulting set. We use the tail pointer for x’s list to quickly find where to append y’s list. Be- cause all members of y’s list join x’s list, we can destroy the set object for y’s list. Unfortunately, we must update the pointer to the set object for each object origi- nally on y’s list, which takes time linear in the length of y’s list. In Figure 21.2, for example, the operation UNION.g;e/ causes pointers to be updated in the objects for b, c, e, and h.
In fact, we can easily construct a sequence of m operations on n objects that requires ‚.n2 / time. Suppose that we have objects x1 ; x2 ; : : : ; xn . We execute the sequence of n MAKE-SET operations followed by n 􏳣 1 UNION operations shown in Figure 21.3, so that m D 2n 􏳣 1. We spend ‚.n/ time performing the n MAKE-SET operations. Because the ith UNION operation updates i objects, the total number of objects updated by all n 􏳣 1 UNION operations is

566 Chapter 21 Data Structures for Disjoint Sets
Operation MAKE-SET.x1/ MAKE-SET.x2/
:
MAKE-SET.xn/ UNION.x2; x1/ UNION.x3; x2/ UNION.x4; x3/
: UNION.xn; xn􏳣1/
Number of objects updated 1
1
:
1 1 2 3
:
n 􏳣 1
Figure 21.3 A sequence of 2n 􏳣 1 operations on n objects that takes ‚.n2/ time, or ‚.n/ time per operation on average, using the linked-list set representation and the simple implementation of UNION.
n􏳣1
X i D ‚.n2/ : iD1
The total number of operations is 2n􏳣1, and so each operation on average requires ‚.n/ time. That is, the amortized time of an operation is ‚.n/.
A weighted-union heuristic
In the worst case, the above implementation of the UNION procedure requires an average of ‚.n/ time per call because we may be appending a longer list onto a shorter list; we must update the pointer to the set object for each member of the longer list. Suppose instead that each list also includes the length of the list (which we can easily maintain) and that we always append the shorter list onto the longer, breaking ties arbitrarily. With this simple weighted-union heuristic, a sin- gle UNION operation can still take 􏳫.n/ time if both sets have 􏳫.n/ members. As the following theorem shows, however, a sequence of m MAKE-SET, UNION, and FIND-SET operations, n of which are MAKE-SET operations, takes O.m C n lg n/ time.
Theorem 21.1
Using the linked-list representation of disjoint sets and the weighted-union heuris- tic, a sequence of m MAKE-SET, UNION, and FIND-SET operations, n of which are MAKE-SET operations, takes O.m C n lg n/ time.

21.2 Linked-list representation of disjoint sets 567
Proof Because each UNION operation unites two disjoint sets, we perform at most n􏳣1 UNION operations over all. We now bound the total time taken by these UNION operations. We start by determining, for each object, an upper bound on the number of times the object’s pointer back to its set object is updated. Consider a particular object x. We know that each time x’s pointer was updated, x must have started in the smaller set. The first time x’s pointer was updated, therefore, the resulting set must have had at least 2 members. Similarly, the next time x’s pointer was updated, the resulting set must have had at least 4 members. Continuing on, we observe that for any k 􏳥 n, after x’s pointer has been updated dlgke times, the resulting set must have at least k members. Since the largest set has at most n members, each object’s pointer is updated at most dlg ne times over all the UNION operations. Thus the total time spent updating object pointers over all UNION operations is O.n lg n/. We must also account for updating the tail pointers and the list lengths, which take only ‚.1/ time per UNION operation. The total time spent in all UNION operations is thus O.n lg n/.
The time for the entire sequence of m operations follows easily. Each MAKE- SET and FIND-SET operation takes O.1/ time, and there are O.m/ of them. The total time for the entire sequence is thus O.m C n lg n/.
Exercises
21.2-1
Write pseudocode for MAKE-SET, FIND-SET, and UNION using the linked-list representation and the weighted-union heuristic. Make sure to specify the attributes that you assume for set objects and list objects.
21.2-2
Show the data structure that results and the answers returned by the FIND-SET operations in the following program. Use the linked-list representation with the weighted-union heuristic.
1 2 3 4 5 6 7 8 9
10 11
foriD1to16 MAKE-SET.xi/
foriD1to15by2 UNION.xi;xiC1/
foriD1to13by4 UNION.xi;xiC2/
UNION.x1; x5/ UNION.x11; x13/ UNION.x1; x10/ FIND-SET.x2/ FIND-SET.x9/

568 Chapter 21 Data Structures for Disjoint Sets
Assume that if the sets containing xi and xj have the same size, then the operation UNION.xi ; xj / appends xj ’s list onto xi ’s list.
21.2-3
Adapt the aggregate proof of Theorem 21.1 to obtain amortized time bounds of O.1/ for MAKE-SET and FIND-SET and O.lgn/ for UNION using the linked- list representation and the weighted-union heuristic.
21.2-4
Give a tight asymptotic bound on the running time of the sequence of operations in Figure 21.3 assuming the linked-list representation and the weighted-union heuris- tic.
21.2-5
Professor Gompers suspects that it might be possible to keep just one pointer in each set object, rather than two (head and tail), while keeping the number of point- ers in each list element at two. Show that the professor’s suspicion is well founded by describing how to represent each set by a linked list such that each operation has the same running time as the operations described in this section. Describe also how the operations work. Your scheme should allow for the weighted-union heuristic, with the same effect as described in this section. (Hint: Use the tail of a linked list as its set’s representative.)
21.2-6
Suggest a simple change to the UNION procedure for the linked-list representation that removes the need to keep the tail pointer to the last object in each list. Whether or not the weighted-union heuristic is used, your change should not change the asymptotic running time of the UNION procedure. (Hint: Rather than appending one list to another, splice them together.)
21.3 Disjoint-set forests
In a faster implementation of disjoint sets, we represent sets by rooted trees, with each node containing one member and each tree representing one set. In a disjoint- set forest, illustrated in Figure 21.4(a), each member points only to its parent. The root of each tree contains the representative and is its own parent. As we shall see, although the straightforward algorithms that use this representation are no faster than ones that use the linked-list representation, by introducing two heuris- tics—“union by rank” and “path compression”—we can achieve an asymptotically optimal disjoint-set data structure.

21.3 Disjoint-set forests 569
cff hedcd bgheg
(a)
b
(b)
Figure 21.4 A disjoint-set forest. (a) Two trees representing the two sets of Figure 21.2. The tree on the left represents the set fb; c; e; hg, with c as the representative, and the tree on the right represents the set fd; f; gg, with f as the representative. (b) The result of UNION.e; g/.
We perform the three disjoint-set operations as follows. A MAKE-SET operation simply creates a tree with just one node. We perform a FIND-SET operation by following parent pointers until we find the root of the tree. The nodes visited on this simple path toward the root constitute the find path. A U N I O N operation, shown in Figure 21.4(b), causes the root of one tree to point to the root of the other.
Heuristics to improve the running time
So far, we have not improved on the linked-list implementation. A sequence of n 􏳣 1 UNION operations may create a tree that is just a linear chain of n nodes. By using two heuristics, however, we can achieve a running time that is almost linear in the total number of operations m.
The first heuristic, union by rank, is similar to the weighted-union heuristic we used with the linked-list representation. The obvious approach would be to make the root of the tree with fewer nodes point to the root of the tree with more nodes. Rather than explicitly keeping track of the size of the subtree rooted at each node, we shall use an approach that eases the analysis. For each node, we maintain a rank, which is an upper bound on the height of the node. In union by rank, we make the root with smaller rank point to the root with larger rank during a UNION operation.
The second heuristic, path compression, is also quite simple and highly effec- tive. As shown in Figure 21.5, we use it during FIND-SET operations to make each node on the find path point directly to the root. Path compression does not change any ranks.

570
Chapter 21
Data Structures for Disjoint Sets
c
d
e
f
abd
(b)
c
e
f
a
b
Figure 21.5
omitted. (a) A tree representing a set prior to executing FIND-SET.a/. Triangles represent subtrees whose roots are the nodes shown. Each node has a pointer to its parent. (b) The same set after executing FIND-SET.a/. Each node on the find path now points directly to the root.
Pseudocode for disjoint-set forests
To implement a disjoint-set forest with the union-by-rank heuristic, we must keep track of ranks. With each node x, we maintain the integer value x:rank, which is an upper bound on the height of x (the number of edges in the longest simple path between x and a descendant leaf). When MAKE-SET creates a singleton set, the single node in the corresponding tree has an initial rank of 0. Each FIND-SET oper- ation leaves all ranks unchanged. The UNION operation has two cases, depending on whether the roots of the trees have equal rank. If the roots have unequal rank, we make the root with higher rank the parent of the root with lower rank, but the ranks themselves remain unchanged. If, instead, the roots have equal ranks, we arbitrarily choose one of the roots as the parent and increment its rank.
Let us put this method into pseudocode. We designate the parent of node x by x:p. The LINK procedure, a subroutine called by UNION, takes pointers to two roots as inputs.
(a)
Path compression during the operation FIND-SET. Arrows and self-loops at roots are

21.3 Disjoint-set forests 571
MAKE-SET.x/ 1 x:pDx
2 x:rank D 0 UNION.x; y/
1 LINK.FIND-SET.x/; FIND-SET.y// LINK.x; y/
1 2 3 4 5
1 2 3
if x:rank > y:rank y:p D x
elsex:pDy
if x:rank == y:rank
y:rank D y:rank C 1
The FIND-SET procedure with path compression is quite simple: FIND-SET.x/
ifx¤x:p
x:p D FIND-SET.x:p/
return x:p
The FIND-SET procedure is a two-pass method: as it recurses, it makes one pass up the find path to find the root, and as the recursion unwinds, it makes a second pass back down the find path to update each node to point directly to the root. Each call of FIND-SET.x/ returns x:p in line 3. If x is the root, then FIND-SET skips line 2 and instead returns x:p, which is x; this is the case in which the recursion bottoms out. Otherwise, line 2 executes, and the recursive call with parameter x:p returns a pointer to the root. Line 2 updates node x to point directly to the root, and line 3 returns this pointer.
Effect of the heuristics on the running time
Separately, either union by rank or path compression improves the running time of the operations on disjoint-set forests, and the improvement is even greater when we use the two heuristics together. Alone, union by rank yields a running time of O.m lg n/ (see Exercise 21.4-4), and this bound is tight (see Exercise 21.3-3). Although we shall not prove it here, for a sequence of n MAKE-SET opera- tions (and hence at most n 􏳣 1 UNION operations) and f FIND-SET opera- tions, the path-compression heuristic alone gives a worst-case running time of ‚.nCf 􏳵.1Clog2Cf=n n//.

572 Chapter 21 Data Structures for Disjoint Sets
When we use both union by rank and path compression, the worst-case running time is O.m ̨.n//, where ̨.n/ is a very slowly growing function, which we de- fine in Section 21.4. In any conceivable application of a disjoint-set data structure, ̨.n/ 􏳥 4; thus, we can view the running time as linear in m in all practical situa- tions. Strictly speaking, however, it is superlinear. In Section 21.4, we prove this upper bound.
Exercises
21.3-1
Redo Exercise 21.2-2 using a disjoint-set forest with union by rank and path com- pression.
21.3-2
Write a nonrecursive version of FIND-SET with path compression.
21.3-3
Give a sequence of m MAKE-SET, UNION, and FIND-SET operations, n of which are MAKE-SET operations, that takes 􏳫.mlgn/ time when we use union by rank only.
21.3-4
Suppose that we wish to add the operation PRINT-SET.x/, which is given a node x and prints all the members of x’s set, in any order. Show how we can add just a single attribute to each node in a disjoint-set forest so that PRINT-SET.x/ takes time linear in the number of members of x’s set and the asymptotic running times of the other operations are unchanged. Assume that we can print each member of the set in O.1/ time.
21.3-5 ?
Show that any sequence of m MAKE-SET, FIND-SET, and LINK operations, where all the LINK operations appear before any of the FIND-SET operations, takes only O.m/ time if we use both path compression and union by rank. What happens in the same situation if we use only the path-compression heuristic?

21.4 Analysis of union by rank with path compression 573
? 21.4
Analysis of union by rank with path compression
As noted in Section 21.3, the combined union-by-rank and path-compression heu- ristic runs in time O.m ̨.n// for m disjoint-set operations on n elements. In this section, we shall examine the function ̨ to see just how slowly it grows. Then we prove this running time using the potential method of amortized analysis.
A very quickly growing function and its very slowly growing inverse
For integers k 􏳦 0 and j 􏳦 1, we define the function Ak.j/ as (
A.j/D jC1 ifkD0; k A.jC1/.j/ ifk􏳦1;
k􏳣1
where the expression A.j C1/ .j / uses the functional-iteration notation given in Sec-
k􏳣1
tion 3.2. Specifically, A.0/ .j/ D j and A.i/ .j/ D Ak􏳣1.A.i􏳣1/.j// for i 􏳦 1.
k􏳣1 k􏳣1 k􏳣1 We will refer to the parameter k as the level of the function A.
The function Ak .j / strictly increases with both j and k. To see just how quickly this function grows, we first obtain closed-form expressions for A1 .j / and A2 .j /.
Lemma 21.2
Foranyintegerj 􏳦1,wehaveA1.j/D2j C1.
Proof We first use induction on i to show that A.i/.j/ D j Ci. For the base case,
we have A.0/.j/ D j D j C 0. For the inductive step, assume that A.i􏳣1/.j/ D 00
j C.i 􏳣1/. Then A.i/.j/ D A .A.i􏳣1/.j// D .j C.i 􏳣1//C1 D j Ci. Finally, 000
wenotethatA .j/DA.jC1/.j/Dj C.j C1/D2j C1. 10
Lemma 21.3
Foranyintegerj 􏳦1,wehaveA2.j/D2jC1.j C1/􏳣1.
Proof We first use induction on i to show that A.i/.j/ D 2i.j C 1/ 􏳣 1. For
the base case, we have A.0/.j / D j D 20.j C 1/ 􏳣 1. For the inductive step, 1
assume that A.i􏳣1/.j/ D 2i􏳣1.j C 1/ 􏳣 1. Then A.i/.j/ D A .A.i􏳣1/.j// D 1111
A1.2i􏳣1.j C 1/ 􏳣 1/ D 2􏳵.2i􏳣1.j C1/􏳣1/C1 D 2i .j C1/􏳣2C1 D 2i .j C1/􏳣1. Finally, we note that A .j/ D A.jC1/.j/ D 2jC1.j C 1/ 􏳣 1.
21
Now we can see how quickly Ak .j / grows by simply examining Ak .1/ for levels k D 0; 1; 2; 3; 4. From the definition of A0.k/ and the above lemmas, we have A0.1/D1C1D2,A1.1/D2􏳵1C1D3,andA2.1/D21C1 􏳵.1C1/􏳣1D7.
0
1

574 Chapter 21 Data Structures for Disjoint Sets
We also have
A .1/ D A.2/.1/ 32
D A2.A2.1// D A2.7/
D 28􏳵8􏳣1 D 211􏳣1
D 2047 and
D A.2/.1/ 43
D A3 .A3 .1//
D A3 .2047/
D A.2048/ .2047/ 2
􏳷 A2 .2047/
D 22048 􏳵 2048 􏳣 1
> 22048
D .24 /512
D 16512 􏳷 1080 ;
which is the estimated number of atoms in the observable universe. (The symbol “􏳷” denotes the “much-greater-than” relation.)
We define the inverse of the function Ak .n/, for integer n 􏳦 0, by ̨.n/ D minfk W Ak.1/ 􏳦 ng :
In words ̊, ̨.n/ is the lowest level k for which Ak.1/ is at least n. From the above values of Ak .1/, we see that
0 for0􏳥n􏳥2;
1 fornD3; ̨.n/D 2 for4􏳥n􏳥7;
3 for8􏳥n􏳥2047;
4 for2048􏳥n􏳥A4.1/:
It is only for values of n so large that the term “astronomical” understates them (greater than A4.1/, a huge number) that ̨.n/ > 4, and so ̨.n/ 􏳥 4 for all practical purposes.
A .1/

21.4 Analysis of union by rank with path compression 575
Properties of ranks
In the remainder of this section, we prove an O.m ̨.n// bound on the running time of the disjoint-set operations with union by rank and path compression. In order to prove this bound, we first prove some simple properties of ranks.
Lemma 21.4
For all nodes x, we have x:rank 􏳥 x:p:rank, with strict inequality if x ¤ x:p. The value of x:rank is initially 0 and increases through time until x ¤ x:p; from then on, x:rank does not change. The value of x:p:rank monotonically increases over time.
Proof The proof is a straightforward induction on the number of operations, us- ing the implementations of MAKE-SET, UNION, and FIND-SET that appear in Section 21.3. We leave it as Exercise 21.4-1.
Corollary 21.5
As we follow the simple path from any node toward a root, the node ranks strictly increase.
Lemma 21.6
Every node has rank at most n 􏳣 1.
Proof Each node’s rank starts at 0, and it increases only upon LINK operations. Because there are at most n 􏳣 1 UNION operations, there are also at most n 􏳣 1 L I N K operations. Because each L I N K operation either leaves all ranks alone or increases some node’s rank by 1, all ranks are at most n 􏳣 1.
Lemma 21.6 provides a weak bound on ranks. In fact, every node has rank at most blg nc (see Exercise 21.4-2). The looser bound of Lemma 21.6 will suffice for our purposes, however.
Proving the time bound
We shall use the potential method of amortized analysis (see Section 17.3) to prove the O.m ̨.n// time bound. In performing the amortized analysis, we will find it convenient to assume that we invoke the LINK operation rather than the UNION operation. That is, since the parameters of the LINK procedure are pointers to two roots, we act as though we perform the appropriate FIND-SET operations sepa- rately. The following lemma shows that even if we count the extra FIND-SET op- erations induced by UNION calls, the asymptotic running time remains unchanged.

576 Chapter 21 Data Structures for Disjoint Sets
Lemma 21.7
Suppose we convert a sequence S0 of m0 MAKE-SET, UNION, and FIND-SET op- erations into a sequence S of m MAKE-SET, LINK, and FIND-SET operations by turning each UNION into two FIND-SET operations followed by a LINK. Then, if sequence S runs in O.m ̨.n// time, sequence S0 runs in O.m0 ̨.n// time.
Proof Since each UNION operation in sequence S0 is converted into three opera- tions in S, we have m0 􏳥 m 􏳥 3m0. Since m D O.m0/, an O.m ̨.n// time bound for the converted sequence S implies an O.m0 ̨.n// time bound for the original sequence S0.
In the remainder of this section, we shall assume that the initial sequence of m0 MAKE-SET, UNION, and FIND-SET operations has been converted to a sequence of m MAKE-SET, LINK, and FIND-SET operations. We now prove an O.m ̨.n// time bound for the converted sequence and appeal to Lemma 21.7 to prove the O.m0 ̨.n// running time of the original sequence of m0 operations.
Potential function
The potential function we use assigns a potential 􏳭q.x/ to each node x in the
disjoint-set forest after q operations. We sum the node potentials for the poten-
tial of the entire forest: ˆq D P 􏳭q.x/, where ˆq denotes the potential of the x
forest after q operations. The forest is empty prior to the first operation, and we arbitrarily set ˆ0 D 0. No potential ˆq will ever be negative.
The value of 􏳭q.x/ depends on whether x is a tree root after the qth operation. If it is, or if x:rank D 0, then 􏳭q.x/ D ̨.n/ 􏳵 x:rank.
Now suppose that after the qth operation, x is not a root and that x:rank 􏳦 1. We need to define two auxiliary functions on x before we can define 􏳭q.x/. First we define
level.x/ D max fk W x:p:rank 􏳦 Ak.x:rank/g :
That is, level.x/ is the greatest level k for which Ak, applied to x’s rank, is no greater than x’s parent’s rank.
We claim that
0 􏳥 level.x/ < ̨.n/ ; which we see as follows. We have x:p:rank 􏳦 x:rank C 1 (by Lemma 21.4) D A0.x:rank/ (by definition of A0.j/) , which implies that level.x/ 􏳦 0, and we have (21.1) 21.4 Analysis of union by rank with path compression 577 (because Ak.j/ is strictly increasing) (by the definition of ̨.n/) (by Lemma 21.6) , which implies that level.x/ < ̨.n/. Note that because x:p:rank monotonically increases over time, so does level.x/. The second auxiliary function applies when x:rank 􏳦 1: iter.x/ D max ̊i W x:p:rank 􏳦 A.i/ .x:rank/􏳻 : That is, iter.x/ is the largest number of times we can iteratively apply Alevel.x/, applied initially to x’s rank, before we get a value greater than x’s parent’s rank. A ̨.n/.x:rank/ 􏳦 􏳦 n level.x/ A ̨.n/.1/ > x:p:rank
level.x/
We claim that when x:rank 􏳦 1, we have 1 􏳥 iter.x/ 􏳥 x:rank ;
which we see as follows. We have
x:p:rank 􏳦 Alevel.x/.x:rank/
D A.1/ .x:rank/ level.x/
which implies that iter.x/ 􏳦 1, and we have
A.x:rankC1/.x:rank/ D Alevel.x/C1.x:rank/ (by definition of Ak.j/)
> x:p:rank (by definition of level.x/) ,
(21.2)
(by definition of level.x/)
(by definition of functional iteration) ,
which implies that iter.x/ 􏳥 x:rank. Note that because x:p:rank monotonically increases over time, in order for iter.x/ to decrease, level.x/ must increase. As long as level.x/ remains unchanged, iter.x/ must either increase or remain unchanged.
With these auxiliary functions in place, we are ready to define the potential of node x after q operations:
(
̨.n/ 􏳵 x:rank if x is a root or x:rank D 0 ; . ̨.n/ 􏳣 level.x//􏳵x:rank 􏳣 iter.x/ if x is not a root and x:rank 􏳦 1 :
􏳭q.x/ D
We next investigate some useful properties of node potentials.
Lemma 21.8
For every node x, and for all operation counts q, we have 0 􏳥 􏳭q.x/ 􏳥 ̨.n/ 􏳵 x:rank :

578 Chapter 21 Data Structures for Disjoint Sets
Proof If x is a root or x:rank D 0, then 􏳭q.x/ D ̨.n/􏳵x:rank by definition. Now suppose that x is not a root and that x:rank 􏳦 1. We obtain a lower bound on 􏳭q.x/ by maximizing level.x/ and iter.x/. By the bound (21.1), level.x/ 􏳥 ̨.n/􏳣1, and by the bound (21.2), iter.x/ 􏳥 x:rank. Thus,
􏳭q.x/ D 􏳦 D
. ̨.n/ 􏳣 level.x// 􏳵 x:rank 􏳣 iter.x/ . ̨.n/ 􏳣 . ̨.n/ 􏳣 1// 􏳵 x:rank 􏳣 x:rank x:rank 􏳣 x:rank
D0:
Similarly, we obtain an upper bound on 􏳭q.x/ by minimizing level.x/ and iter.x/.
By the bound (21.1), level.x/ 􏳦 0, and by the bound (21.2), iter.x/ 􏳦 1. Thus,
􏳭q.x/ 􏳥 . ̨.n/􏳣0/􏳵x:rank􏳣1 D ̨.n/􏳵x:rank􏳣1
< ̨.n/􏳵x:rank: Corollary 21.9 If node x is not a root and x:rank > 0, then 􏳭q.x/ < ̨.n/ 􏳵 x:rank. Potential changes and amortized costs of operations We are now ready to examine how the disjoint-set operations affect node potentials. With an understanding of the change in potential due to each operation, we can determine each operation’s amortized cost. Lemma 21.10 Let x be a node that is not a root, and suppose that the qth operation is either a LINK or FIND-SET. Then after the qth operation, 􏳭q.x/ 􏳥 􏳭q􏳣1.x/. Moreover, if x:rank 􏳦 1 and either level.x/ or iter.x/ changes due to the qth operation, then 􏳭q .x/ 􏳥 􏳭q􏳣1.x/ 􏳣 1. That is, x’s potential cannot increase, and if it has positive rank and either level.x/ or iter.x/ changes, then x’s potential drops by at least 1. Proof Because x is not a root, the qth operation does not change x:rank, and because n does not change after the initial n MAKE-SET operations, ̨.n/ remains unchanged as well. Hence, these components of the formula for x’s potential re- main the same after the qth operation. If x:rank D 0, then 􏳭q.x/ D 􏳭q􏳣1.x/ D 0. Now assume that x:rank 􏳦 1. Recall that level.x/ monotonically increases over time. If the qth operation leaves level.x/ unchanged, then iter.x/ either increases or remains unchanged. If both level.x/ and iter.x/ are unchanged, then 􏳭q.x/ D 􏳭q􏳣1.x/. If level.x/ 21.4 Analysis of union by rank with path compression 579 is unchanged and iter.x/ increases, then it increases by at least 1, and so 􏳭q.x/ 􏳥 􏳭q􏳣1.x/ 􏳣 1. Finally, if the qth operation increases level.x/, it increases by at least 1, so that the value of the term . ̨.n/ 􏳣 level.x// 􏳵 x:rank drops by at least x:rank. Be- cause level.x/ increased, the value of iter.x/ might drop, but according to the bound (21.2), the drop is by at most x:rank 􏳣 1. Thus, the increase in poten- tial due to the change in iter.x/ is less than the decrease in potential due to the change in level.x/, and we conclude that 􏳭q.x/ 􏳥 􏳭q􏳣1.x/ 􏳣 1. Our final three lemmas show that the amortized cost of each MAKE-SET, LINK, and FIND-SET operation is O. ̨.n//. Recall from equation (17.2) that the amor- tized cost of each operation is its actual cost plus the increase in potential due to the operation. Lemma 21.11 The amortized cost of each MAKE-SET operation is O.1/. Proof Suppose that the qth operation is MAKE-SET.x/. This operation creates node x with rank 0, so that 􏳭q.x/ D 0. No other ranks or potentials change, and so ˆq D ˆq􏳣1. Noting that the actual cost of the MAKE-SET operation is O.1/ completes the proof. Lemma 21.12 The amortized cost of each LINK operation is O. ̨.n//. Proof Suppose that the qth operation is LINK.x; y/. The actual cost of the LINK operation is O.1/. Without loss of generality, suppose that the LINK makes y the parent of x. To determine the change in potential due to the LINK, we note that the only nodes whose potentials may change are x, y, and the children of y just prior to the operation. We shall show that the only node whose potential can increase due to the LINK is y, and that its increase is at most ̨.n/: By Lemma 21.10, any node that is y’s child just before the LINK cannot have its potential increase due to the LINK. From the definition of 􏳭q.x/, we see that, since x was a root just before the qth operation, 􏳭q􏳣1.x/ D ̨.n/􏳵x:rank. If x:rank D 0, then 􏳭q.x/ D 􏳭q􏳣1.x/ D 0. Otherwise, 􏳭q.x/ < ̨.n/ 􏳵 x:rank (by Corollary 21.9) D 􏳭q􏳣1.x/ ; and so x’s potential decreases. 􏳮 􏳮 580 Chapter 21 Data Structures for Disjoint Sets Because y is a root prior to the LINK, 􏳭q􏳣1.y/ D ̨.n/ 􏳵 y:rank. The LINK operation leaves y as a root, and it either leaves y’s rank alone or it increases y’s rank by 1. Therefore, either 􏳭q.y/ D 􏳭q􏳣1.y/ or 􏳭q.y/ D 􏳭q􏳣1.y/ C ̨.n/. The increase in potential due to the LINK operation, therefore, is at most ̨.n/. The amortized cost of the LINK operation is O.1/ C ̨.n/ D O. ̨.n//. Lemma 21.13 The amortized cost of each FIND-SET operation is O. ̨.n//. Proof Suppose that the qth operation is a FIND-SET and that the find path con- tains s nodes. The actual cost of the FIND-SET operation is O.s/. We shall show that no node’s potential increases due to the FIND-SET and that at least max.0; s 􏳣 . ̨.n/ C 2// nodes on the find path have their potential decrease by at least 1. To see that no node’s potential increases, we first appeal to Lemma 21.10 for all nodes other than the root. If x is the root, then its potential is ̨.n/ 􏳵 x:rank, which does not change. Now we show that at least max.0; s 􏳣 . ̨.n/ C 2// nodes have their potential decrease by at least 1. Let x be a node on the find path such that x:rank > 0 and x is followed somewhere on the find path by another node y that is not a root, where level.y/ D level.x/ just before the FIND-SET operation. (Node y need not immediately follow x on the find path.) All but at most ̨.n/ C 2 nodes on the find path satisfy these constraints on x. Those that do not satisfy them are the first node on the find path (if it has rank 0), the last node on the path (i.e., the root), and the last node w on the path for which level.w/ D k, for each k D 0; 1; 2; : : : ; ̨.n/􏳣1.
Let us fix such a node x, and we shall show that x’s potential decreases by at least 1. Let k D level.x/ D level.y/. Just prior to the path compression caused by the FIND-SET, we have
􏳮
x:p:rank y:p:rank y:rank
􏳦 A.iter.x//.x:rank/ k
􏳦 Ak.y:rank/ 􏳦 x:p:rank
(by definition of iter.x/) ,
(by definition of level.y/) ,
(by Corollary 21.5 and because
y follows x on the find path) .
Putting these inequalities together and letting i be the value of iter.x/ before path compression, we have
y:p:rank 􏳦 Ak.y:rank/
􏳦 Ak.x:p:rank/ (because Ak.j/ is strictly increasing)
􏳦 Ak.A.iter.x//.x:rank// k
D A.iC1/.x:rank/ : k

21.4 Analysis of union by rank with path compression 581
Because path compression will make x and y have the same parent, we know
that after path compression, x:p:rank D y:p:rank and that the path compression
does not decrease y:p:rank. Since x:rank does not change, after path compression
we have that x:p:rank 􏳦 A.iC1/.x:rank/. Thus, path compression will cause ei- k
ther iter.x/ to increase (to at least i C 1) or level.x/ to increase (which occurs if iter.x/ increases to at least x:rank C 1). In either case, by Lemma 21.10, we have 􏳭q.x/ 􏳥 􏳭q􏳣1.x/ 􏳣 1. Hence, x’s potential decreases by at least 1.
The amortized cost of the FIND-SET operation is the actual cost plus the change in potential. The actual cost is O.s/, and we have shown that the total potential decreases by at least max.0; s 􏳣 . ̨.n/ C 2//. The amortized cost, therefore, is at most O.s/ 􏳣 .s 􏳣 . ̨.n/ C 2// D O.s/ 􏳣 s C O. ̨.n// D O. ̨.n//, since we can scale up the units of potential to dominate the constant hidden in O.s/.
Putting the preceding lemmas together yields the following theorem.
Theorem 21.14
A sequence of m MAKE-SET, UNION, and FIND-SET operations, n of which are MAKE-SET operations, can be performed on a disjoint-set forest with union by rank and path compression in worst-case time O.m ̨.n//.
Proof Immediate from Lemmas 21.7, 21.11, 21.12, and 21.13. Exercises
21.4-1
Prove Lemma 21.4.
21.4-2
Prove that every node has rank at most blg nc.
21.4-3
In light of Exercise 21.4-2, how many bits are necessary to store x:rank for each node x?
21.4-4
Using Exercise 21.4-2, give a simple proof that operations on a disjoint-set forest with union by rank but without path compression run in O.m lg n/ time.
21.4-5
Professor Dante reasons that because node ranks increase strictly along a simple path to the root, node levels must monotonically increase along the path. In other

582 Chapter 21 Data Structures for Disjoint Sets
Problems
words, if x:rank > 0 and x:p is not a root, then level.x/ 􏳥 level.x:p/. Is the professor correct?
21.4-6 ?
Consider the function ̨0.n/ D minfk W Ak.1/ 􏳦 lg.nC1/g. Show that ̨0.n/ 􏳥 3 for all practical values of n and, using Exercise 21.4-2, show how to modify the potential-function argument to prove that we can perform a sequence of m MAKE- SET, UNION, and FIND-SET operations, n of which are MAKE-SET operations, on a disjoint-set forest with union by rank and path compression in worst-case time O.m ̨0.n//.
21-1 Off-line minimum
The off-line minimum problem asks us to maintain a dynamic set T of elements from the domain f1; 2; : : : ; ng under the operations INSERT and EXTRACT-MIN. We are given a sequence S of n INSERT and m EXTRACT-MIN calls, where each key in f1; 2; : : : ; ng is inserted exactly once. We wish to determine which key is returned by each EXTRACT-MIN call. Specifically, we wish to fill in an array extractedŒ1::m􏳩, where for i D 1;2;:::;m, extractedŒi􏳩 is the key returned by the ith EXTRACT-MIN call. The problem is “off-line” in the sense that we are allowed to process the entire sequence S before determining any of the returned keys.
a. In the following instance of the off-line minimum problem, each operation INSERT.i/ is represented by the value of i and each EXTRACT-MIN is rep- resented by the letter E:
4;8;E;3;E;9;2;6;E;E;E;1;7;E;5 :
Fill in the correct values in the extracted array.
To develop an algorithm for this problem, we break the sequence S into homoge- neous subsequences. That is, we represent S by
I1;E;I2;E;I3;:::;Im;E;ImC1 ;
where each E represents a single EXTRACT-MIN call and each Ij represents a (pos- sibly empty) sequence of INSERT calls. For each subsequence Ij , we initially place the keys inserted by these operations into a set Kj , which is empty if Ij is empty. We then do the following:

Problems for Chapter 21 583
OFF-LINE-MINIMUM.m;n/
1 2 3 4 5
6 7
b.
foriD1ton
determine j such that i 2 Kj ifj ¤mC1
extractedŒj 􏳩 D i
let l be the smallest value greater than j
for which set Kl exists
Kl DKj[Kl,destroyingKj
return extracted
Argue that the array extracted returned by OFF-LINE-MINIMUM is correct.
c. Describe how to implement OFF-LINE-MINIMUM efficiently with a disjoint- set data structure. Give a tight bound on the worst-case running time of your implementation.
21-2 Depth determination
In the depth-determination problem, we maintain a forest F D fTi g of rooted trees under three operations:
MAKE-TREE.􏳪/ creates a tree whose only node is 􏳪.
FIND-DEPTH.􏳪/ returns the depth of node 􏳪 within its tree.
GRAFT.r;􏳪/ makes node r, which is assumed to be the root of a tree, become the child of node 􏳪, which is assumed to be in a different tree than r but may or may not itself be a root.
a. Suppose that we use a tree representation similar to a disjoint-set forest: 􏳪:p is the parent of node 􏳪, except that 􏳪:p D 􏳪 if 􏳪 is a root. Suppose further that we implement GRAFT.r;􏳪/ by setting r:p D 􏳪 and FIND-DEPTH.􏳪/ by following the find path up to the root, returning a count of all nodes other than 􏳪 encountered. Show that the worst-case running time of a sequence of m MAKE- TREE, FIND-DEPTH, and GRAFT operations is ‚.m2/.
By using the union-by-rank and path-compression heuristics, we can reduce the worst-case running time. We use the disjoint-set forest S D fSi g, where each set Si (which is itself a tree) corresponds to a tree Ti in the forest F . The tree structure within a set Si , however, does not necessarily correspond to that of Ti . In fact, the implementation of Si does not record the exact parent-child relationships but nevertheless allows us to determine any node’s depth in Ti .
The key idea is to maintain in each node 􏳪 a “pseudodistance” 􏳪:d, which is defined so that the sum of the pseudodistances along the simple path from 􏳪 to the

584 Chapter 21 Data Structures for Disjoint Sets
root of its set Si equals the depth of 􏳪 in Ti . That is, if the simple path from 􏳪 to its
root in Si is 􏳪0;􏳪1;:::;􏳪k, where 􏳪0 D 􏳪 and 􏳪k is Si’s root, then the depth of 􏳪
inTi isPk 􏳪j:d. jD0
b. Give an implementation of MAKE-TREE.
c. Show how to modify FIND-SET to implement FIND-DEPTH. Your implemen- tation should perform path compression, and its running time should be linear in the length of the find path. Make sure that your implementation updates pseudodistances correctly.
d. Show how to implement G R A F T .r; 􏳪 /, which combines the sets containing r and 􏳪, by modifying the UNION and LINK procedures. Make sure that your implementation updates pseudodistances correctly. Note that the root of a set Si is not necessarily the root of the corresponding tree Ti .
e. Give a tight bound on the worst-case running time of a sequence of m M A K E – TREE, FIND-DEPTH, and GRAFT operations, n of which are MAKE-TREE op- erations.
21-3 Tarjan’s off-line least-common-ancestors algorithm
The least common ancestor of two nodes u and 􏳪 in a rooted tree T is the node w that is an ancestor of both u and 􏳪 and that has the greatest depth in T . In the off-line least-common-ancestors problem, we are given a rooted tree T and an arbitrary set P D ffu; 􏳪gg of unordered pairs of nodes in T , and we wish to deter- mine the least common ancestor of each pair in P .
To solve the off-line least-common-ancestors problem, the following procedure performs a tree walk of T with the initial call LCA.T:root/. We assume that each node is colored WHITE prior to the walk.
LCA.u/
1 2 3 4 5 6 7 8 9
10
MAKE-SET.u/ FIND-SET.u/:ancestor D u foreachchild􏳪ofuinT
LCA.􏳪/
UNION.u; 􏳪/ FIND-SET.u/:ancestor D u
u:color D BLACK
for each node 􏳪 such that fu;􏳪g 2 P
if 􏳪:color == BLACK
print “The least common ancestor of”
u “and” 􏳪 “is” FIND-SET.􏳪/:ancestor

Notes for Chapter 21 585
a. Argue that line 10 executes exactly once for each pair fu; 􏳪g 2 P .
b. Argue that at the time of the call LCA.u/, the number of sets in the disjoint-set
data structure equals the depth of u in T .
c. Prove that LCA correctly prints the least common ancestor of u and 􏳪 for each
pair fu;􏳪g 2 P.
d. Analyze the running time of LCA, assuming that we use the implementation of
the disjoint-set data structure in Section 21.3.
Chapter notes
Many of the important results for disjoint-set data structures are due at least in part to R. E. Tarjan. Using aggregate analysis, Tarjan [328, 330] gave the first tight upper bound in terms of the very slowly growing inverse ̨y.m; n/ of Ackermann’s function. (The function Ak.j/ given in Section 21.4 is similar to Ackermann’s function, and the function ̨.n/ is similar to the inverse. Both ̨.n/ and ̨y.m;n/ are at most 4 for all conceivable values of m and n.) An O.m lg􏳤 n/ upper bound was proven earlier by Hopcroft and Ullman [5, 179]. The treatment in Section 21.4 is adapted from a later analysis by Tarjan [332], which is in turn based on an anal- ysis by Kozen [220]. Harfst and Reingold [161] give a potential-based version of Tarjan’s earlier bound.
Tarjan and van Leeuwen [333] discuss variants on the path-compression heuris- tic, including “one-pass methods,” which sometimes offer better constant factors in their performance than do two-pass methods. As with Tarjan’s earlier analyses of the basic path-compression heuristic, the analyses by Tarjan and van Leeuwen are aggregate. Harfst and Reingold [161] later showed how to make a small change to the potential function to adapt their path-compression analysis to these one-pass variants. Gabow and Tarjan [121] show that in certain applications, the disjoint-set operations can be made to run in O.m/ time.
Tarjan [329] showed that a lower bound of 􏳫.m ̨y.m; n// time is required for operations on any disjoint-set data structure satisfying certain technical conditions. This lower bound was later generalized by Fredman and Saks [113], who showed that in the worst case, 􏳫.m ̨y.m; n// .lg n/-bit words of memory must be accessed.

VI Graph Algorithms

Introduction
Graph problems pervade computer science, and algorithms for working with them are fundamental to the field. Hundreds of interesting computational problems are couched in terms of graphs. In this part, we touch on a few of the more significant ones.
Chapter 22 shows how we can represent a graph in a computer and then discusses algorithms based on searching a graph using either breadth-first search or depth- first search. The chapter gives two applications of depth-first search: topologically sorting a directed acyclic graph and decomposing a directed graph into its strongly connected components.
Chapter 23 describes how to compute a minimum-weight spanning tree of a graph: the least-weight way of connecting all of the vertices together when each edge has an associated weight. The algorithms for computing minimum spanning trees serve as good examples of greedy algorithms (see Chapter 16).
Chapters 24 and 25 consider how to compute shortest paths between vertices when each edge has an associated length or “weight.” Chapter 24 shows how to find shortest paths from a given source vertex to all other vertices, and Chapter 25 examines methods to compute shortest paths between every pair of vertices.
Finally, Chapter 26 shows how to compute a maximum flow of material in a flow network, which is a directed graph having a specified source vertex of material, a specified sink vertex, and specified capacities for the amount of material that can traverse each directed edge. This general problem arises in many forms, and a good algorithm for computing maximum flows can help solve a variety of related problems efficiently.

588 Part VI Graph Algorithms
When we characterize the running time of a graph algorithm on a given graph G D .V; E/, we usually measure the size of the input in terms of the number of vertices jV j and the number of edges jEj of the graph. That is, we describe the size of the input with two parameters, not just one. We adopt a common notational convention for these parameters. Inside asymptotic notation (such as O-notation or ‚-notation), and only inside such notation, the symbol V denotes jV j and the symbol E denotes jEj. For example, we might say, “the algorithm runs in time O.VE/,” meaning that the algorithm runs in time O.jV j jEj/. This conven- tion makes the running-time formulas easier to read, without risk of ambiguity.
Another convention we adopt appears in pseudocode. We denote the vertex set of a graph G by G:V and its edge set by G:E. That is, the pseudocode views vertex and edge sets as attributes of a graph.

22 Elementary Graph Algorithms
This chapter presents methods for representing a graph and for searching a graph. Searching a graph means systematically following the edges of the graph so as to visit the vertices of the graph. A graph-searching algorithm can discover much about the structure of a graph. Many algorithms begin by searching their input graph to obtain this structural information. Several other graph algorithms elabo- rate on basic graph searching. Techniques for searching a graph lie at the heart of the field of graph algorithms.
Section 22.1 discusses the two most common computational representations of graphs: as adjacency lists and as adjacency matrices. Section 22.2 presents a sim- ple graph-searching algorithm called breadth-first search and shows how to cre- ate a breadth-first tree. Section 22.3 presents depth-first search and proves some standard results about the order in which depth-first search visits vertices. Sec- tion 22.4 provides our first real application of depth-first search: topologically sort- ing a directed acyclic graph. A second application of depth-first search, finding the strongly connected components of a directed graph, is the topic of Section 22.5.
22.1 Representations of graphs
We can choose between two standard ways to represent a graph G D .V;E/: as a collection of adjacency lists or as an adjacency matrix. Either way applies to both directed and undirected graphs. Because the adjacency-list representation provides a compact way to represent sparse graphs—those for which jEj is much less than jV j2—it is usually the method of choice. Most of the graph algorithms presented in this book assume that an input graph is represented in adjacency- list form. We may prefer an adjacency-matrix representation, however, when the graph is dense—jEj is close to jV j2—or when we need to be able to tell quickly if there is an edge connecting two given vertices. For example, two of the all-pairs

590
Chapter 22 Elementary Graph Algorithms
11 1222
2
1
11
22 12333 44 55
5
5
4
12345
01001 10111 01010 01101 11010
3
2
4
3
33
44 5455
2
5
3
4
1
2
(a) (b) (c)
Figure 22.1 Two representations of an undirected graph. (a) An undirected graph G with 5 vertices and 7 edges. (b) An adjacency-list representation of G. (c) The adjacency-matrix representation of G.
123456
2
4
010100 000010 000011 010000 000100 000001
5
6
5
2
4
45666
(a) (b) (c)
Figure 22.2 Two representations of a directed graph. (a) A directed graph G with 6 vertices and 8 edges. (b) An adjacency-list representation of G. (c) The adjacency-matrix representation of G.
shortest-paths algorithms presented in Chapter 25 assume that their input graphs are represented by adjacency matrices.
The adjacency-list representation of a graph G D .V;E/ consists of an ar- ray Adj of jVj lists, one for each vertex in V. For each u 2 V, the adjacency list AdjŒu􏳩 contains all the vertices 􏳪 such that there is an edge .u;􏳪/ 2 E. That is, AdjŒu􏳩 consists of all the vertices adjacent to u in G. (Alternatively, it may contain pointers to these vertices.) Since the adjacency lists represent the edges of a graph, in pseudocode we treat the array Adj as an attribute of the graph, just as we treat the edge set E. In pseudocode, therefore, we will see notation such as G:AdjŒu􏳩. Figure 22.1(b) is an adjacency-list representation of the undirected graph in Fig- ure 22.1(a). Similarly, Figure 22.2(b) is an adjacency-list representation of the directed graph in Figure 22.2(a).
If G is a directed graph, the sum of the lengths of all the adjacency lists is jEj, since an edge of the form .u; 􏳪/ is represented by having 􏳪 appear in AdjŒu􏳩. If G is
6

22.1 Representations of graphs 591
an undirected graph, the sum of the lengths of all the adjacency lists is 2 jEj, since if .u; 􏳪/ is an undirected edge, then u appears in 􏳪’s adjacency list and vice versa. For both directed and undirected graphs, the adjacency-list representation has the desirable property that the amount of memory it requires is ‚.V C E/.
We can readily adapt adjacency lists to represent weighted graphs, that is, graphs for which each edge has an associated weight, typically given by a weight function w W E ! R. For example, let G D .V;E/ be a weighted graph with weight function w. We simply store the weight w.u;􏳪/ of the edge .u;􏳪/ 2 E with vertex 􏳪 in u’s adjacency list. The adjacency-list representation is quite robust in that we can modify it to support many other graph variants.
A potential disadvantage of the adjacency-list representation is that it provides no quicker way to determine whether a given edge .u;􏳪/ is present in the graph than to search for 􏳪 in the adjacency list AdjŒu􏳩. An adjacency-matrix representa- tion of the graph remedies this disadvantage, but at the cost of using asymptotically more memory. (See Exercise 22.1-8 for suggestions of variations on adjacency lists that permit faster edge lookup.)
For the adjacency-matrix representation of a graph G D .V;E/, we assume thattheverticesarenumbered1;2;:::;jVjinsomearbitrarymanner. Thenthe adjacency-matrix representation of a graph G consists of a jV j 􏳨 jV j matrix A D .aij / such that
(
aij D
Figures 22.1(c) and 22.2(c) are the adjacency matrices of the undirected and di- rected graphs in Figures 22.1(a) and 22.2(a), respectively. The adjacency matrix of a graph requires ‚.V 2/ memory, independent of the number of edges in the graph.
Observe the symmetry along the main diagonal of the adjacency matrix in Fig- ure 22.1(c). Since in an undirected graph, .u;􏳪/ and .􏳪;u/ represent the same edge, the adjacency matrix A of an undirected graph is its own transpose: A D AT. In some applications, it pays to store only the entries on and above the diagonal of the adjacency matrix, thereby cutting the memory needed to store the graph almost in half.
Like the adjacency-list representation of a graph, an adjacency matrix can repre- sent a weighted graph. For example, if G D .V; E/ is a weighted graph with edge- weight function w, we can simply store the weight w.u; 􏳪/ of the edge .u; 􏳪/ 2 E as the entry in row u and column 􏳪 of the adjacency matrix. If an edge does not exist, we can store a NIL value as its corresponding matrix entry, though for many problems it is convenient to use a value such as 0 or 1.
Although the adjacency-list representation is asymptotically at least as space- efficient as the adjacency-matrix representation, adjacency matrices are simpler, and so we may prefer them when graphs are reasonably small. Moreover, adja-
1 if.i;j/2E; 0 otherwise :

592 Chapter 22 Elementary Graph Algorithms
cency matrices carry a further advantage for unweighted graphs: they require only one bit per entry.
Representing attributes
Most algorithms that operate on graphs need to maintain attributes for vertices and/or edges. We indicate these attributes using our usual notation, such as 􏳪:d for an attribute d of a vertex 􏳪. When we indicate edges as pairs of vertices, we use the same style of notation. For example, if edges have an attribute f , then we denote this attribute for edge .u;􏳪/ by .u;􏳪/:f. For the purpose of presenting and understanding algorithms, our attribute notation suffices.
Implementing vertex and edge attributes in real programs can be another story entirely. There is no one best way to store and access vertex and edge attributes. For a given situation, your decision will likely depend on the programming lan- guage you are using, the algorithm you are implementing, and how the rest of your program uses the graph. If you represent a graph using adjacency lists, one design represents vertex attributes in additional arrays, such as an array dŒ1::jVj􏳩 that parallels the Adj array. If the vertices adjacent to u are in AdjŒu􏳩, then what we call the attribute u: d would actually be stored in the array entry d Œu􏳩. Many other ways of implementing attributes are possible. For example, in an object-oriented pro- gramming language, vertex attributes might be represented as instance variables within a subclass of a Vertex class.
Exercises
22.1-1
Given an adjacency-list representation of a directed graph, how long does it take to compute the out-degree of every vertex? How long does it take to compute the in-degrees?
22.1-2
Give an adjacency-list representation for a complete binary tree on 7 vertices. Give an equivalent adjacency-matrix representation. Assume that vertices are numbered from 1 to 7 as in a binary heap.
22.1-3
The transpose of a directed graph G D .V;E/ is the graph GT D .V;ET/, where ET Df.􏳪;u/2V􏳨VW.u;􏳪/2Eg.Thus,GTisGwithallitsedgesreversed. Describe efficient algorithms for computing GT from G, for both the adjacency- list and adjacency-matrix representations of G. Analyze the running times of your algorithms.

22.1 Representations of graphs 593
22.1-4
Given an adjacency-list representation of a multigraph G D .V;E/, describe an O.V C E/-time algorithm to compute the adjacency-list representation of the “equivalent” undirected graph G0 D .V;E0/, where E0 consists of the edges in E with all multiple edges between two vertices replaced by a single edge and with all self-loops removed.
22.1-5
The square of a directed graph G D .V;E/ is the graph G2 D .V;E2/ such that .u; 􏳪/ 2 E2 if and only G contains a path with at most two edges between u and 􏳪. Describe efficient algorithms for computing G2 from G for both the adjacency- list and adjacency-matrix representations of G. Analyze the running times of your algorithms.
22.1-6
Most graph algorithms that take an adjacency-matrix representation as input re- quire time 􏳫.V 2/, but there are some exceptions. Show how to determine whether a directed graph G contains a universal sink—a vertex with in-degree jV j 􏳣 1 and out-degree 0—in time O.V /, given an adjacency matrix for G.
22.1-7
The incidence matrix of a directed graph G D .V;E/ with no self-loops is a jVj􏳨j􏳾EjmatrixB D.bij/suchthat
􏳣1 if edge j leaves vertex i ; bij D 1 ifedgejentersvertexi;
0 otherwise :
Describe what the entries of the matrix product BBT represent, where BT is the
transpose of B.
22.1-8
Suppose that instead of a linked list, each array entry AdjŒu􏳩 is a hash table contain- ing the vertices 􏳪 for which .u; 􏳪/ 2 E. If all edge lookups are equally likely, what is the expected time to determine whether an edge is in the graph? What disadvan- tages does this scheme have? Suggest an alternate data structure for each edge list that solves these problems. Does your alternative have disadvantages compared to the hash table?

594
Chapter 22 Elementary Graph Algorithms
22.2
Breadth-first search
Breadth-first search is one of the simplest algorithms for searching a graph and the archetype for many important graph algorithms. Prim’s minimum-spanning- tree algorithm (Section 23.2) and Dijkstra’s single-source shortest-paths algorithm (Section 24.3) use ideas similar to those in breadth-first search.
Given a graph G D .V;E/ and a distinguished source vertex s, breadth-first search systematically explores the edges of G to “discover” every vertex that is reachable from s. It computes the distance (smallest number of edges) from s to each reachable vertex. It also produces a “breadth-first tree” with root s that contains all reachable vertices. For any vertex 􏳪 reachable from s, the simple path in the breadth-first tree from s to 􏳪 corresponds to a “shortest path” from s to 􏳪 in G, that is, a path containing the smallest number of edges. The algorithm works on both directed and undirected graphs.
Breadth-first search is so named because it expands the frontier between discov- ered and undiscovered vertices uniformly across the breadth of the frontier. That is, the algorithm discovers all vertices at distance k from s before discovering any vertices at distance k C 1.
To keep track of progress, breadth-first search colors each vertex white, gray, or black. All vertices start out white and may later become gray and then black. A vertex is discovered the first time it is encountered during the search, at which time it becomes nonwhite. Gray and black vertices, therefore, have been discovered, but breadth-first search distinguishes between them to ensure that the search proceeds in a breadth-first manner.1 If .u;􏳪/ 2 E and vertex u is black, then vertex 􏳪 is either gray or black; that is, all vertices adjacent to black vertices have been discovered. Gray vertices may have some adjacent white vertices; they represent the frontier between discovered and undiscovered vertices.
Breadth-first search constructs a breadth-first tree, initially containing only its root, which is the source vertex s. Whenever the search discovers a white vertex 􏳪 in the course of scanning the adjacency list of an already discovered vertex u, the vertex 􏳪 and the edge .u; 􏳪/ are added to the tree. We say that u is the predecessor or parent of 􏳪 in the breadth-first tree. Since a vertex is discovered at most once, it has at most one parent. Ancestor and descendant relationships in the breadth-first tree are defined relative to the root s as usual: if u is on the simple path in the tree from the root s to vertex 􏳪, then u is an ancestor of 􏳪 and 􏳪 is a descendant of u.
1We distinguish between gray and black vertices to help us understand how breadth-first search op- erates. In fact, as Exercise 22.2-3 shows, we would get the same result even if we did not distinguish between gray and black vertices.

22.2 Breadth-first search 595
The breadth-first-search procedure BFS below assumes that the input graph G D .V;E/ is represented using adjacency lists. It attaches several additional attributes to each vertex in the graph. We store the color of each vertex u 2 V in the attribute u:color and the predecessor of u in the attribute u:􏳬. If u has no predecessor (for example, if u D s or u has not been discovered), then u:􏳬 D NIL. The attribute u:d holds the distance from the source s to vertex u computed by the algorithm. The algorithm also uses a first-in, first-out queue Q (see Section 10.1) to manage the set of gray vertices.
BFS.G; s/
1 2 3 4 5 6 7 8 9
10
11
12
13
14
15
16
17
18
foreachvertexu2G:V􏳣fsg u:color D WHITE
u:d D 1
u:􏳬 D NIL
s:color D GRAY s:dD0
s:􏳬 D NIL QD; ENQUEUE.Q; s/ whileQ¤;
u D DEQUEUE.Q/ for each 􏳪 2 G:AdjŒu􏳩
if 􏳪:color == WHITE 􏳪:color D GRAY
􏳪:d D u:d C 1 􏳪:􏳬 D u ENQUEUE.Q; 􏳪/
u:color D BLACK
Figure 22.3 illustrates the progress of BFS on a sample graph.
The procedure BFS works as follows. With the exception of the source vertex s, lines 1–4 paint every vertex white, set u:d to be infinity for each vertex u, and set the parent of every vertex to be NIL. Line 5 paints s gray, since we consider it to be discovered as the procedure begins. Line 6 initializes s:d to 0, and line 7 sets the predecessor of the source to be NIL. Lines 8–9 initialize Q to the queue containing
just the vertex s.
The while loop of lines 10–18 iterates as long as there remain gray vertices,
which are discovered vertices that have not yet had their adjacency lists fully ex- amined. This while loop maintains the following invariant:
At the test in line 10, the queue Q consists of the set of gray vertices.

596
Chapter 22 Elementary Graph Algorithms
rstu rstu
∞0∞∞ 10∞∞
(a) Qs (b) Q
∞∞∞∞0 ∞1∞∞11 vwxy vwxy
rstu rstu
102∞ 102∞
(c) Q (d) Q
w
r
r
t
x
t
x
v
x
v
u
v
u
y
(e)
(g)
(i)
∞12∞ 122 212∞ 222 vwxy vwxy
rstu rstu
1023 1023
Q (f) Q
212∞ 223 2123 233 vwxy vwxy
rstu rstu
1023 1023
Q (h) Qy 212333 21233
u
y
vwxy rstu
1023 2123
vwxy
vwxy
Q;
Figure 22.3 The operation of BFS on an undirected graph. Tree edges are shown shaded as they are produced by BFS. The value of u:d appears within each vertex u. The queue Q is shown at the beginning of each iteration of the while loop of lines 10–18. Vertex distances appear below vertices in the queue.
Although we won’t use this loop invariant to prove correctness, it is easy to see that it holds prior to the first iteration and that each iteration of the loop maintains the invariant. Prior to the first iteration, the only gray vertex, and the only vertex in Q, is the source vertex s. Line 11 determines the gray vertex u at the head of the queue Q and removes it from Q. The for loop of lines 12–17 considers each vertex 􏳪 in the adjacency list of u. If 􏳪 is white, then it has not yet been discovered, and the procedure discovers it by executing lines 14–17. The procedure paints vertex 􏳪 gray, sets its distance 􏳪:d to u:dC1, records u as its parent 􏳪:􏳬, and places it at the tail of the queue Q. Once the procedure has examined all the vertices on u’s

22.2 Breadth-first search 597
adjacency list, it blackens u in line 18. The loop invariant is maintained because whenever a vertex is painted gray (in line 14) it is also enqueued (in line 17), and whenever a vertex is dequeued (in line 11) it is also painted black (in line 18).
The results of breadth-first search may depend upon the order in which the neigh- bors of a given vertex are visited in line 12: the breadth-first tree may vary, but the distances d computed by the algorithm will not. (See Exercise 22.2-5.)
Analysis
Before proving the various properties of breadth-first search, we take on the some- what easier job of analyzing its running time on an input graph G D .V;E/. We use aggregate analysis, as we saw in Section 17.1. After initialization, breadth-first search never whitens a vertex, and thus the test in line 13 ensures that each vertex is enqueued at most once, and hence dequeued at most once. The operations of enqueuing and dequeuing take O.1/ time, and so the total time devoted to queue operations is O.V /. Because the procedure scans the adjacency list of each vertex only when the vertex is dequeued, it scans each adjacency list at most once. Since the sum of the lengths of all the adjacency lists is ‚.E/, the total time spent in scanning adjacency lists is O.E/. The overhead for initialization is O.V /, and thus the total running time of the BFS procedure is O.V C E/. Thus, breadth-first search runs in time linear in the size of the adjacency-list representation of G.
Shortest paths
At the beginning of this section, we claimed that breadth-first search finds the dis- tance to each reachable vertex in a graph G D .V;E/ from a given source vertex s 2 V . Define the shortest-path distance ı.s; 􏳪/ from s to 􏳪 as the minimum num- ber of edges in any path from vertex s to vertex 􏳪; if there is no path from s to 􏳪, then ı.s;􏳪/ D 1. We call a path of length ı.s;􏳪/ from s to 􏳪 a shortest path2 from s to 􏳪. Before showing that breadth-first search correctly computes shortest- path distances, we investigate an important property of shortest-path distances.
2In Chapters 24 and 25, we shall generalize our study of shortest paths to weighted graphs, in which every edge has a real-valued weight and the weight of a path is the sum of the weights of its con- stituent edges. The graphs considered in the present chapter are unweighted or, equivalently, all edges have unit weight.

598 Chapter 22 Elementary Graph Algorithms
Lemma 22.1
Let G D .V;E/ be a directed or undirected graph, and let s 2 V be an arbitrary vertex. Then, for any edge .u; 􏳪/ 2 E,
ı.s; 􏳪/ 􏳥 ı.s; u/ C 1 :
Proof If u is reachable from s, then so is 􏳪. In this case, the shortest path from s to 􏳪 cannot be longer than the shortest path from s to u followed by the edge .u; 􏳪/, and thus the inequality holds. If u is not reachable from s, then ı.s; u/ D 1, and the inequality holds.
We want to show that BFS properly computes 􏳪:d D ı.s;􏳪/ for each ver- tex 􏳪 2 V . We first show that 􏳪:d bounds ı.s; 􏳪/ from above.
Lemma 22.2
Let G D .V;E/ be a directed or undirected graph, and suppose that BFS is run on G from a given source vertex s 2 V . Then upon termination, for each ver- tex 􏳪 2 V , the value 􏳪:d computed by BFS satisfies 􏳪:d 􏳦 ı.s; 􏳪/.
Proof We use induction on the number of ENQUEUE operations. Our inductive hypothesis is that 􏳪:d 􏳦 ı.s;􏳪/ for all 􏳪 2 V .
The basis of the induction is the situation immediately after enqueuing s in line 9 of BFS. The inductive hypothesis holds here, because s:d D 0 D ı.s;s/ and 􏳪:dD1􏳦ı.s;􏳪/forall􏳪2V 􏳣fsg.
For the inductive step, consider a white vertex 􏳪 that is discovered during the search from a vertex u. The inductive hypothesis implies that u: d 􏳦 ı.s; u/. From the assignment performed by line 15 and from Lemma 22.1, we obtain
􏳪:d D u:dC1
􏳦 ı.s;u/C1
􏳦 ı.s;􏳪/:
Vertex 􏳪 is then enqueued, and it is never enqueued again because it is also grayed and the then clause of lines 14–17 is executed only for white vertices. Thus, the value of 􏳪:d never changes again, and the inductive hypothesis is maintained.
To prove that 􏳪:d D ı.s; 􏳪/, we must first show more precisely how the queue Q operates during the course of BFS. The next lemma shows that at all times, the queue holds at most two distinct d values.

22.2 Breadth-first search 599
Lemma 22.3
Suppose that during the execution of BFS on a graph G D .V;E/, the queue Q contains the vertices h􏳪1; 􏳪2; : : : ; 􏳪r i, where 􏳪1 is the head of Q and 􏳪r is the tail. Then,􏳪r:d􏳥􏳪1:dC1and􏳪i:d􏳥􏳪iC1:dfori D1;2;:::;r􏳣1.
Proof The proof is by induction on the number of queue operations. Initially, when the queue contains only s, the lemma certainly holds.
For the inductive step, we must prove that the lemma holds after both dequeuing and enqueuing a vertex. If the head 􏳪1 of the queue is dequeued, 􏳪2 becomes the new head. (If the queue becomes empty, then the lemma holds vacuously.) By the inductive hypothesis, 􏳪1:d 􏳥 􏳪2:d. But then we have 􏳪r:d 􏳥 􏳪1:dC1 􏳥 􏳪2:dC1, and the remaining inequalities are unaffected. Thus, the lemma follows with 􏳪2 as the head.
In order to understand what happens upon enqueuing a vertex, we need to ex- amine the code more closely. When we enqueue a vertex 􏳪 in line 17 of BFS, it becomes 􏳪rC1. At that time, we have already removed vertex u, whose adjacency list is currently being scanned, from the queue Q, and by the inductive hypothesis, the new head 􏳪1 has 􏳪1:d 􏳦 u:d. Thus, 􏳪rC1:d D 􏳪:d D u:dC1 􏳥 􏳪1:dC1. From the inductive hypothesis, we also have 􏳪r:d 􏳥 u:d C 1, and so 􏳪r:d 􏳥 u:d C 1 D 􏳪:d D 􏳪rC1:d, and the remaining inequalities are unaffected. Thus, the lemma follows when 􏳪 is enqueued.
The following corollary shows that the d values at the time that vertices are enqueued are monotonically increasing over time.
Corollary 22.4
Suppose that vertices 􏳪i and 􏳪j are enqueued during the execution of BFS, and that 􏳪i is enqueued before 􏳪j . Then 􏳪i :d 􏳥 􏳪j :d at the time that 􏳪j is enqueued.
Proof Immediate from Lemma 22.3 and the property that each vertex receives a finite d value at most once during the course of BFS.
We can now prove that breadth-first search correctly finds shortest-path dis- tances.
Theorem 22.5 (Correctness of breadth-first search)
Let G D .V;E/ be a directed or undirected graph, and suppose that BFS is run on G from a given source vertex s 2 V . Then, during its execution, BFS discovers every vertex 􏳪 2 V that is reachable from the source s, and upon termination, 􏳪:d D ı.s;􏳪/ for all 􏳪 2 V. Moreover, for any vertex 􏳪 ¤ s that is reachable

600 Chapter 22 Elementary Graph Algorithms
from s, one of the shortest paths from s to 􏳪 is a shortest path from s to 􏳪:􏳬 followed by the edge .􏳪:􏳬; 􏳪/.
Proof Assume, for the purpose of contradiction, that some vertex receives a d value not equal to its shortest-path distance. Let 􏳪 be the vertex with min- imum ı.s;􏳪/ that receives such an incorrect d value; clearly 􏳪 ¤ s. By Lemma 22.2, 􏳪:d 􏳦 ı.s;􏳪/, and thus we have that 􏳪:d > ı.s;􏳪/. Vertex 􏳪 must be reachable from s, for if it is not, then ı.s;􏳪/ D 1 􏳦 􏳪:d. Let u be the vertex im- mediately preceding 􏳪 on a shortest path from s to 􏳪, so that ı.s; 􏳪/ D ı.s; u/ C 1. Because ı.s; u/ < ı.s; 􏳪/, and because of how we chose 􏳪, we have u:d D ı.s; u/. Putting these properties together, we have 􏳪:d > ı.s; 􏳪/ D ı.s; u/ C 1 D u:d C 1 : (22.1)
Now consider the time when BFS chooses to dequeue vertex u from Q in line 11. At this time, vertex 􏳪 is either white, gray, or black. We shall show that in each of these cases, we derive a contradiction to inequality (22.1). If 􏳪 is white, then line 15 sets 􏳪:d D u:d C 1, contradicting inequality (22.1). If 􏳪 is black, then it was already removed from the queue and, by Corollary 22.4, we have 􏳪:d 􏳥 u:d, again contradicting inequality (22.1). If 􏳪 is gray, then it was painted gray upon dequeuing some vertex w, which was removed from Q earlier than u and for which 􏳪:d D w:d C 1. By Corollary 22.4, however, w:d 􏳥 u:d, and so we have 􏳪:d D w:d C 1 􏳥 u:d C 1, once again contradicting inequality (22.1).
Thus we conclude that 􏳪:d D ı.s;􏳪/ for all 􏳪 2 V. All vertices 􏳪 reachable from s must be discovered, for otherwise they would have 1 D 􏳪:d > ı.s;􏳪/. To conclude the proof of the theorem, observe that if 􏳪:􏳬 D u, then 􏳪:d D u:d C 1. Thus, we can obtain a shortest path from s to 􏳪 by taking a shortest path from s to 􏳪:􏳬 and then traversing the edge .􏳪:􏳬;􏳪/.
Breadth-first trees
The procedure BFS builds a breadth-first tree as it searches the graph, as Fig- ure 22.3 illustrates. The tree corresponds to the 􏳬 attributes. More formally, for a graph G D .V;E/ with source s, we define the predecessor subgraph of G as G􏳬 D .V􏳬;E􏳬/, where
V􏳬 Df􏳪2V W􏳪:􏳬¤NILg[fsg and
E􏳬 Df.􏳪:􏳬;􏳪/W􏳪2V􏳬 􏳣fsgg :
The predecessor subgraph G􏳬 is a breadth-first tree if V􏳬 consists of the vertices reachable from s and, for all 􏳪 2 V􏳬 , the subgraph G􏳬 contains a unique simple

22.2 Breadth-first search 601
path from s to 􏳪 that is also a shortest path from s to 􏳪 in G. A breadth-first tree is in fact a tree, since it is connected and jE􏳬 j D jV􏳬 j 􏳣 1 (see Theorem B.2). We call the edges in E􏳬 tree edges.
The following lemma shows that the predecessor subgraph produced by the BFS procedure is a breadth-first tree.
Lemma 22.6
When applied to a directed or undirected graph G D .V;E/, procedure BFS con- structs 􏳬 so that the predecessor subgraph G􏳬 D .V􏳬 ; E􏳬 / is a breadth-first tree.
Proof Line16ofBFSsets􏳪:􏳬Duifandonlyif.u;􏳪/2Eandı.s;􏳪/<1— that is, if 􏳪 is reachable from s—and thus V􏳬 consists of the vertices in V reachable from s. Since G􏳬 forms a tree, by Theorem B.2, it contains a unique simple path from s to each vertex in V􏳬 . By applying Theorem 22.5 inductively, we conclude that every such path is a shortest path in G. The following procedure prints out the vertices on a shortest path from s to 􏳪, assuming that BFS has already computed a breadth-first tree: PRINT-PATH.G; s; 􏳪/ 1 2 3 4 5 6 if􏳪==s print s elseif 􏳪:􏳬 == NIL print “no path from” s “to” 􏳪 “exists” else PRINT-PATH.G; s; 􏳪:􏳬/ print 􏳪 This procedure runs in time linear in the number of vertices in the path printed, since each recursive call is for a path one vertex shorter. Exercises 22.2-1 Show the d and 􏳬 values that result from running breadth-first search on the di- rected graph of Figure 22.2(a), using vertex 3 as the source. 22.2-2 Show the d and 􏳬 values that result from running breadth-first search on the undi- rected graph of Figure 22.3, using vertex u as the source. 602 Chapter 22 Elementary Graph Algorithms 22.2-3 Show that using a single bit to store each vertex color suffices by arguing that the BFS procedure would produce the same result if lines 5 and 14 were removed. 22.2-4 What is the running time of BFS if we represent its input graph by an adjacency matrix and modify the algorithm to handle this form of input? 22.2-5 Argue that in a breadth-first search, the value u:d assigned to a vertex u is inde- pendent of the order in which the vertices appear in each adjacency list. Using Figure 22.3 as an example, show that the breadth-first tree computed by BFS can depend on the ordering within adjacency lists. 22.2-6 Give an example of a directed graph G D .V; E/, a source vertex s 2 V , and a set of tree edges E􏳬 􏳧 E such that for each vertex 􏳪 2 V , the unique simple path in the graph .V;E􏳬/ from s to 􏳪 is a shortest path in G, yet the set of edges E􏳬 cannot be produced by running BFS on G, no matter how the vertices are ordered in each adjacency list. 22.2-7 There are two types of professional wrestlers: “babyfaces” (“good guys”) and “heels” (“bad guys”). Between any pair of professional wrestlers, there may or may not be a rivalry. Suppose we have n professional wrestlers and we have a list of r pairs of wrestlers for which there are rivalries. Give an O.n C r/-time algo- rithm that determines whether it is possible to designate some of the wrestlers as babyfaces and the remainder as heels such that each rivalry is between a babyface and a heel. If it is possible to perform such a designation, your algorithm should produce it. 22.2-8 ? The diameter of a tree T D .V;E/ is defined as maxu;􏳪2V ı.u;􏳪/, that is, the largest of all shortest-path distances in the tree. Give an efficient algorithm to compute the diameter of a tree, and analyze the running time of your algorithm. 22.2-9 Let G D .V; E/ be a connected, undirected graph. Give an O.V C E/-time algo- rithm to compute a path in G that traverses each edge in E exactly once in each direction. Describe how you can find your way out of a maze if you are given a large supply of pennies. 22.3 Depth-first search 603 22.3 Depth-first search The strategy followed by depth-first search is, as its name implies, to search “deeper” in the graph whenever possible. Depth-first search explores edges out of the most recently discovered vertex 􏳪 that still has unexplored edges leaving it. Once all of 􏳪’s edges have been explored, the search “backtracks” to explore edges leaving the vertex from which 􏳪 was discovered. This process continues until we have discovered all the vertices that are reachable from the original source vertex. If any undiscovered vertices remain, then depth-first search selects one of them as a new source, and it repeats the search from that source. The algorithm repeats this entire process until it has discovered every vertex.3 As in breadth-first search, whenever depth-first search discovers a vertex 􏳪 dur- ing a scan of the adjacency list of an already discovered vertex u, it records this event by setting 􏳪’s predecessor attribute 􏳪:􏳬 to u. Unlike breadth-first search, whose predecessor subgraph forms a tree, the predecessor subgraph produced by a depth-first search may be composed of several trees, because the search may repeat from multiple sources. Therefore, we define the predecessor subgraph of a depth-first search slightly differently from that of a breadth-first search: we let G􏳬 D.V;E􏳬/,where E􏳬 Df.􏳪:􏳬;􏳪/W􏳪2Vand􏳪:􏳬¤NILg: The predecessor subgraph of a depth-first search forms a depth-first forest com- prising several depth-first trees. The edges in E􏳬 are tree edges. As in breadth-first search, depth-first search colors vertices during the search to indicate their state. Each vertex is initially white, is grayed when it is discovered in the search, and is blackened when it is finished, that is, when its adjacency list has been examined completely. This technique guarantees that each vertex ends up in exactly one depth-first tree, so that these trees are disjoint. Besides creating a depth-first forest, depth-first search also timestamps each ver- tex. Each vertex 􏳪 has two timestamps: the first timestamp 􏳪:d records when 􏳪 is first discovered (and grayed), and the second timestamp 􏳪:f records when the search finishes examining 􏳪’s adjacency list (and blackens 􏳪). These timestamps 3It may seem arbitrary that breadth-first search is limited to only one source whereas depth-first search may search from multiple sources. Although conceptually, breadth-first search could proceed from multiple sources and depth-first search could be limited to one source, our approach reflects how the results of these searches are typically used. Breadth-first search usually serves to find shortest- path distances (and the associated predecessor subgraph) from a given source. Depth-first search is often a subroutine in another algorithm, as we shall see later in this chapter. 604 Chapter 22 Elementary Graph Algorithms provide important information about the structure of the graph and are generally helpful in reasoning about the behavior of depth-first search. The procedure DFS below records when it discovers vertex u in the attribute u:d and when it finishes vertex u in the attribute u:f. These timestamps are integers between 1 and 2 jV j, since there is one discovery event and one finishing event for each of the jV j vertices. For every vertex u, u:d < u:f : (22.2) Vertex u is WHITE before time u:d, GRAY between time u:d and time u:f, and BLACK thereafter. The following pseudocode is the basic depth-first-search algorithm. The input graph G may be undirected or directed. The variable time is a global variable that we use for timestamping. DFS.G/ 1 2 3 4 5 6 7 for each vertex u 2 G:V u:color D WHITE u:􏳬 D NIL timeD0 for each vertex u 2 G:V if u:color == WHITE DFS-VISIT.G; u/ DFS-VISIT.G;u/ 1 2 3 4 5 6 7 8 9 10 // white vertex u has just been discovered time D time C 1 u:d D time u:color D GRAY foreach􏳪2G:AdjŒu􏳩 //exploreedge.u;􏳪/ if 􏳪:color == WHITE 􏳪:􏳬 D u DFS-VISIT.G;􏳪/ u:color D BLACK timeDtimeC1 u:fDtime // blacken u; it is finished Figure 22.4 illustrates the progress of DFS on the graph shown in Figure 22.2. Procedure DFS works as follows. Lines 1–3 paint all vertices white and ini- tialize their 􏳬 attributes to NIL. Line 4 resets the global time counter. Lines 5–7 check each vertex in V in turn and, when a white vertex is found, visit it using DFS-VISIT. Every time DFS-VISIT.G;u/ is called in line 7, vertex u becomes / 2/ B / 3/ 22.3 Depth-first search 605 uvw uvw uvw uvw 1/ 1/ 2/ 1/ 2/ 1 3/ 4 xyz xyz xyz xyz (a) (b) (c) (d) uvw uvw uvw uvw 11117 444646 xyz xyz xyz xyz (e) (f) (g) (h) uvw uvw uvw uvw 17 17 179/179/ FFFFC 46464646 xyz xyz xyz xyz (i) (j) (k) (l) uvw uvw uvw uvw 179/ 179/ 179/ 179/12 FCFCFCFC BBB 4610/4610/4610/114610/11 xyz xyz xyz xyz (m) (n) (o) (p) Figure 22.4 The progress of the depth-first-search algorithm DFS on a directed graph. As edges are explored by the algorithm, they are shown as either shaded (if they are tree edges) or dashed (otherwise). Nontree edges are labeled B, C, or F according to whether they are back, cross, or forward edges. Timestamps within vertices indicate discovery time/finishing times. the root of a new tree in the depth-first forest. When DFS returns, every vertex u has been assigned a discovery time u:d and a finishing time u:f. In each call DFS-VISIT.G;u/, vertex u is initially white. Line 1 increments the global variable time, line 2 records the new value of time as the discovery time u:d, and line 3 paints u gray. Lines 4–7 examine each vertex 􏳪 adjacent to u and recursively visit 􏳪 if it is white. As each vertex 􏳪 2 AdjŒu􏳩 is considered in line 4, we say that edge .u;􏳪/ is explored by the depth-first search. Finally, after every edge leaving u has been explored, lines 8–10 paint u black, increment time, and record the finishing time in u: f . Note that the results of depth-first search may depend upon the order in which line 5 of DFS examines the vertices and upon the order in which line 4 of DFS- VISIT visits the neighbors of a vertex. These different visitation orders tend not / 2/ B / 2/ B / 2/ / 3/ / 2/ B /5 3/ /5 3/ /5 3/ / 2/ B /8 /5 B 2/ 3/ /8 /5 B 2/ 3/ /5 3/ /8 /5 B 2/ 3/ /8 /5 B 2/ 3/ /8 /5 B 2/ 3/ /8 /5 B 2/ 3/ /8 /5 B 2/ 3/ 606 Chapter 22 Elementary Graph Algorithms to cause problems in practice, as we can usually use any depth-first search result effectively, with essentially equivalent results. What is the running time of DFS? The loops on lines 1–3 and lines 5–7 of DFS take time ‚.V /, exclusive of the time to execute the calls to DFS-VISIT. As we did for breadth-first search, we use aggregate analysis. The procedure DFS-VISIT is called exactly once for each vertex 􏳪 2 V , since the vertex u on which DFS-VISIT is invoked must be white and the first thing DFS-VISIT does is paint vertex u gray. During an execution of DFS-VISIT.G;􏳪/, the loop on lines 4–7 executes jAdjŒ􏳪􏳩j times. Since X jAdjŒ􏳪􏳩j D ‚.E/ ; 􏳪2V the total cost of executing lines 4–7 of DFS-VISIT is ‚.E/. The running time of DFS is therefore ‚.V C E/. Properties of depth-first search Depth-first search yields valuable information about the structure of a graph. Per- haps the most basic property of depth-first search is that the predecessor sub- graph G􏳬 does indeed form a forest of trees, since the structure of the depth- first trees exactly mirrors the structure of recursive calls of DFS-VISIT. That is, u D 􏳪:􏳬 if and only if DFS-VISIT.G;􏳪/ was called during a search of u’s ad- jacency list. Additionally, vertex 􏳪 is a descendant of vertex u in the depth-first forest if and only if 􏳪 is discovered during the time in which u is gray. Another important property of depth-first search is that discovery and finishing times have parenthesis structure. If we represent the discovery of vertex u with a left parenthesis “.u” and represent its finishing by a right parenthesis “u/”, then the history of discoveries and finishings makes a well-formed expression in the sense that the parentheses are properly nested. For example, the depth-first search of Figure 22.5(a) corresponds to the parenthesization shown in Figure 22.5(b). The following theorem provides another way to characterize the parenthesis structure. Theorem 22.7 (Parenthesis theorem) In any depth-first search of a (directed or undirected) graph G D .V;E/, for any two vertices u and 􏳪, exactly one of the following three conditions holds: the intervals Œu:d;u:f􏳩 and Œ􏳪:d;􏳪:f􏳩 are entirely disjoint, and neither u nor 􏳪 is a descendant of the other in the depth-first forest, the interval Œu:d;u:f􏳩 is contained entirely within the interval Œ􏳪:d;􏳪:f􏳩, and u is a descendant of 􏳪 in a depth-first tree, or the interval Œ􏳪:d;􏳪:f􏳩 is contained entirely within the interval Œu:d;u:f􏳩, and 􏳪 is a descendant of u in a depth-first tree. 􏳮 􏳮 􏳮 22.3 Depth-first search 607 yzst 3/6 2/9 1/10 11/16 BF (a) CB 4/5 7/8 12/13 14/15 xCwCvCu (b) y s z 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (s (z (y (x x) y) (w w) z) s) (t (v v) (u u) t) v u w x st C B zFvCu C yw C B (c) x Figure 22.5 graph. Vertices are timestamped and edge types are indicated as in Figure 22.4. (b) Intervals for the discovery time and finishing time of each vertex correspond to the parenthesization shown. Each rectangle spans the interval given by the discovery and finishing times of the corresponding vertex. Only tree edges are shown. If two intervals overlap, then one is nested within the other, and the vertex corresponding to the smaller interval is a descendant of the vertex corresponding to the larger. (c) The graph of part (a) redrawn with all tree and forward edges going down within a depth-first tree and all back edges going up from a descendant to an ancestor. t Properties of depth-first search. (a) The result of a depth-first search of a directed 608 Chapter 22 Elementary Graph Algorithms Proof We begin with the case in which u:d < 􏳪:d. We consider two subcases, according to whether 􏳪:d < u:f or not. The first subcase occurs when 􏳪:d < u:f, so 􏳪 was discovered while u was still gray, which implies that 􏳪 is a descendant of u. Moreover, since 􏳪 was discovered more recently than u, all of its outgo- ing edges are explored, and 􏳪 is finished, before the search returns to and fin- ishes u. In this case, therefore, the interval Œ􏳪:d;􏳪:f􏳩 is entirely contained within the interval Œu:d;u:f􏳩. In the other subcase, u:f < 􏳪:d, and by inequality (22.2), u:d < u:f < 􏳪:d < 􏳪:f; thus the intervals Œu:d;u:f􏳩 and Œ􏳪:d;􏳪:f􏳩 are disjoint. Because the intervals are disjoint, neither vertex was discovered while the other was gray, and so neither vertex is a descendant of the other. The case in which 􏳪:d < u:d is similar, with the roles of u and 􏳪 reversed in the above argument. Corollary 22.8 (Nesting of descendants’ intervals) Vertex 􏳪 is a proper descendant of vertex u in the depth-first forest for a (directed or undirected) graph G if and only if u:d < 􏳪:d < 􏳪:f < u:f. Proof Immediate from Theorem 22.7. The next theorem gives another important characterization of when one vertex is a descendant of another in the depth-first forest. Theorem 22.9 (White-path theorem) In a depth-first forest of a (directed or undirected) graph G D .V;E/, vertex 􏳪 is a descendant of vertex u if and only if at the time u:d that the search discovers u, there is a path from u to 􏳪 consisting entirely of white vertices. Proof ): If 􏳪 D u, then the path from u to 􏳪 contains just vertex u, which is still white when we set the value of u:d. Now, suppose that 􏳪 is a proper descendant of u in the depth-first forest. By Corollary 22.8, u:d < 􏳪:d, and so 􏳪 is white at time u:d. Since 􏳪 can be any descendant of u, all vertices on the unique simple path from u to 􏳪 in the depth-first forest are white at time u:d. (: Suppose that there is a path of white vertices from u to 􏳪 at time u:d, but 􏳪 does not become a descendant of u in the depth-first tree. Without loss of general- ity, assume that every vertex other than 􏳪 along the path becomes a descendant of u. (Otherwise, let 􏳪 be the closest vertex to u along the path that doesn’t become a de- scendant of u.) Let w be the predecessor of 􏳪 in the path, so that w is a descendant of u (w and u may in fact be the same vertex). By Corollary 22.8, w:f 􏳥 u:f. Be- cause 􏳪 must be discovered after u is discovered, but before w is finished, we have u:d < 􏳪:d < w:f 􏳥 u:f. Theorem 22.7 then implies that the interval Œ􏳪:d;􏳪:f􏳩 22.3 Depth-first search 609 is contained entirely within the interval Œu: d; u: f 􏳩. By Corollary 22.8, 􏳪 must after all be a descendant of u. Classification of edges Another interesting property of depth-first search is that the search can be used to classify the edges of the input graph G D .V;E/. The type of each edge can provide important information about a graph. For example, in the next section, we shall see that a directed graph is acyclic if and only if a depth-first search yields no “back” edges (Lemma 22.11). We can define four edge types in terms of the depth-first forest G􏳬 produced by a depth-first search on G: 1. Treeedgesareedgesinthedepth-firstforestG􏳬.Edge.u;􏳪/isatreeedgeif􏳪 was first discovered by exploring edge .u; 􏳪/. 2. Back edges are those edges .u;􏳪/ connecting a vertex u to an ancestor 􏳪 in a depth-first tree. We consider self-loops, which may occur in directed graphs, to be back edges. 3. Forward edges are those nontree edges .u;􏳪/ connecting a vertex u to a de- scendant 􏳪 in a depth-first tree. 4. Cross edges are all other edges. They can go between vertices in the same depth-first tree, as long as one vertex is not an ancestor of the other, or they can go between vertices in different depth-first trees. In Figures 22.4 and 22.5, edge labels indicate edge types. Figure 22.5(c) also shows how to redraw the graph of Figure 22.5(a) so that all tree and forward edges head downward in a depth-first tree and all back edges go up. We can redraw any graph in this fashion. The DFS algorithm has enough information to classify some edges as it encoun- ters them. The key idea is that when we first explore an edge .u;􏳪/, the color of vertex 􏳪 tells us something about the edge: 1. W H I T E indicates a tree edge, 2. G R A Y indicates a back edge, and 3. B L A C K indicates a forward or cross edge. The first case is immediate from the specification of the algorithm. For the sec- ond case, observe that the gray vertices always form a linear chain of descendants corresponding to the stack of active DFS-VISIT invocations; the number of gray vertices is one more than the depth in the depth-first forest of the vertex most re- cently discovered. Exploration always proceeds from the deepest gray vertex, so 610 Chapter 22 Elementary Graph Algorithms an edge that reaches another gray vertex has reached an ancestor. The third case handles the remaining possibility; Exercise 22.3-5 asks you to show that such an edge .u;􏳪/ is a forward edge if u:d < 􏳪:d and a cross edge if u:d > 􏳪:d.
An undirected graph may entail some ambiguity in how we classify edges, since .u;􏳪/ and .􏳪;u/ are really the same edge. In such a case, we classify the edge as the first type in the classification list that applies. Equivalently (see Ex- ercise 22.3-6), we classify the edge according to whichever of .u; 􏳪/ or .􏳪; u/ the search encounters first.
We now show that forward and cross edges never occur in a depth-first search of an undirected graph.
Theorem 22.10
In a depth-first search of an undirected graph G, every edge of G is either a tree edge or a back edge.
Proof Let .u; 􏳪/ be an arbitrary edge of G, and suppose without loss of generality that u:d < 􏳪:d. Then the search must discover and finish 􏳪 before it finishes u (while u is gray), since 􏳪 is on u’s adjacency list. If the first time that the search explores edge .u;􏳪/, it is in the direction from u to 􏳪, then 􏳪 is undiscovered (white) until that time, for otherwise the search would have explored this edge already in the direction from 􏳪 to u. Thus, .u;􏳪/ becomes a tree edge. If the search explores .u; 􏳪/ first in the direction from 􏳪 to u, then .u; 􏳪/ is a back edge, since u is still gray at the time the edge is first explored. We shall see several applications of these theorems in the following sections. Exercises 22.3-1 Make a 3-by-3 chart with row and column labels WHITE, GRAY, and BLACK. In each cell .i;j/, indicate whether, at any point during a depth-first search of a di- rected graph, there can be an edge from a vertex of color i to a vertex of color j . For each possible edge, indicate what edge types it can be. Make a second such chart for depth-first search of an undirected graph. 22.3-2 Show how depth-first search works on the graph of Figure 22.6. Assume that the for loop of lines 5–7 of the DFS procedure considers the vertices in alphabetical order, and assume that each adjacency list is ordered alphabetically. Show the discovery and finishing times for each vertex, and show the classification of each edge. 22.3 Depth-first search 611 qr stu vwxy z Figure 22.6 A directed graph for use in Exercises 22.3-2 and 22.5-2. 22.3-3 Show the parenthesis structure of the depth-first search of Figure 22.4. 22.3-4 Show that using a single bit to store each vertex color suffices by arguing that the DFS procedure would produce the same result if line 3 of DFS-VISIT was removed. 22.3-5 Show that edge .u; 􏳪/ is a. atreeedgeorforwardedgeifandonlyifu:d<􏳪:d<􏳪:f f.C0/.
Proof We consider two cases, depending on which strongly connected compo- nent, C or C0, had the first discovered vertex during the depth-first search.
If d.C/ < d.C0/, let x be the first vertex discovered in C. At time x:d, all ver- tices in C and C 0 are white. At that time, G contains a path from x to each vertex in C consisting only of white vertices. Because .u; 􏳪/ 2 E, for any vertex w 2 C 0, there is also a path in G at time x:d from x to w consisting only of white vertices: x Y u ! 􏳪 Y w. By the white-path theorem, all vertices in C and C0 become descendants of x in the depth-first tree. By Corollary 22.8, x has the latest finishing time of any of its descendants, and so x:f D f.C/ > f.C0/.
If instead we have d.C/ > d.C0/, let y be the first vertex discovered in C0. At time y:d, all vertices in C0 are white and G contains a path from y to each vertex in C 0 consisting only of white vertices. By the white-path theorem, all ver- tices in C 0 become descendants of y in the depth-first tree, and by Corollary 22.8, y:f Df.C0/. Attimey:d,allverticesinC arewhite. Sincethereisanedge.u;􏳪/ from C to C0, Lemma 22.13 implies that there cannot be a path from C0 to C. Hence, no vertex in C is reachable from y. At time y:f , therefore, all vertices in C are still white. Thus, for any vertex w 2 C, we have w:f > y:f, which implies that f.C/ > f.C0/.
The following corollary tells us that each edge in GT that goes between different strongly connected components goes from a component with an earlier finishing time (in the first depth-first search) to a component with a later finishing time.
Corollary 22.15
Let C and C0 be distinct strongly connected components in directed graph G D .V;E/. Suppose that there is an edge .u;􏳪/ 2 ET, where u 2 C and 􏳪 2 C0. Then f.C/ < f.C0/. 22.5 Strongly connected components 619 Proof Since .u;􏳪/ 2 ET, we have .􏳪;u/ 2 E. Because the strongly con- nected components of G and GT are the same, Lemma 22.14 implies that f .C / < f .C 0/. Corollary 22.15 provides the key to understanding why the strongly connected components algorithm works. Let us examine what happens when we perform the second depth-first search, which is on GT. We start with the strongly connected component C whose finishing time f.C/ is maximum. The search starts from some vertex x 2 C , and it visits all vertices in C . By Corollary 22.15, GT contains no edges from C to any other strongly connected component, and so the search from x will not visit vertices in any other component. Thus, the tree rooted at x contains exactly the vertices of C. Having completed visiting all vertices in C, the search in line 3 selects as a root a vertex from some other strongly connected component C 0 whose finishing time f .C 0 / is maximum over all components other than C. Again, the search will visit all vertices in C0, but by Corollary 22.15, the only edges in GT from C0 to any other component must be to C, which we have already visited. In general, when the depth-first search of GT in line 3 visits any strongly connected component, any edges out of that component must be to components that the search already visited. Each depth-first tree, therefore, will be exactly one strongly connected component. The following theorem formalizes this argument. Theorem 22.16 The STRONGLY-CONNECTED-COMPONENTS procedure correctly computes the strongly connected components of the directed graph G provided as its input. Proof We argue by induction on the number of depth-first trees found in the depth-first search of GT in line 3 that the vertices of each tree form a strongly connected component. The inductive hypothesis is that the first k trees produced in line 3 are strongly connected components. The basis for the induction, when k D 0, is trivial. In the inductive step, we assume that each of the first k depth-first trees produced in line 3 is a strongly connected component, and we consider the .k C 1/st tree produced. Let the root of this tree be vertex u, and let u be in strongly connected component C . Because of how we choose roots in the depth-first search in line 3, u:f D f.C/ > f.C0/ for any strongly connected component C0 other than C that has yet to be visited. By the inductive hypothesis, at the time that the search visits u, all other vertices of C are white. By the white-path theorem, therefore, all other vertices of C are descendants of u in its depth-first tree. Moreover, by the inductive hypothesis and by Corollary 22.15, any edges in GT that leave C must be to strongly connected components that have already been visited. Thus, no vertex

620 Chapter 22 Elementary Graph Algorithms
in any strongly connected component other than C will be a descendant of u during the depth-first search of GT. Thus, the vertices of the depth-first tree in GT that is rooted at u form exactly one strongly connected component, which completes the inductive step and the proof.
Here is another way to look at how the second depth-first search operates. Con- sider the component graph .G T /SCC of G T . If we map each strongly connected component visited in the second depth-first search to a vertex of .GT/SCC, the sec- ond depth-first search visits vertices of .GT/SCC in the reverse of a topologically sorted order. If we reverse the edges of .G T /SCC , we get the graph ..G T /SCC /T . Because ..GT/SCC/T D GSCC (see Exercise 22.5-4), the second depth-first search visits the vertices of GSCC in topologically sorted order.
Exercises
22.5-1
How can the number of strongly connected components of a graph change if a new edge is added?
22.5-2
Show how the procedure STRONGLY-CONNECTED-COMPONENTS works on the graph of Figure 22.6. Specifically, show the finishing times computed in line 1 and the forest produced in line 3. Assume that the loop of lines 5–7 of DFS considers vertices in alphabetical order and that the adjacency lists are in alphabetical order.
22.5-3
Professor Bacon claims that the algorithm for strongly connected components would be simpler if it used the original (instead of the transpose) graph in the second depth-first search and scanned the vertices in order of increasing finishing times. Does this simpler algorithm always produce correct results?
22.5-4
Prove that for any directed graph G, we have ..GT/SCC/T D GSCC. That is, the transpose of the component graph of GT is the same as the component graph of G.
22.5-5
Give an O.V C E/-time algorithm to compute the component graph of a directed graph G D .V; E/. Make sure that there is at most one edge between two vertices in the component graph your algorithm produces.

Problems
22.5-6
Given a directed graph G D .V;E/, explain how to create another graph G0 D .V; E0/ such that (a) G0 has the same strongly connected components as G, (b) G0 has the same component graph as G, and (c) E0 is as small as possible. Describe a fast algorithm to compute G0.
22.5-7
A directed graph G D .V; E/ is semiconnected if, for all pairs of vertices u; 􏳪 2 V , we have u Y 􏳪 or 􏳪 Y u. Give an efficient algorithm to determine whether or not G is semiconnected. Prove that your algorithm is correct, and analyze its running time.
22-1 Classifying edges by breadth-first search
A depth-first forest classifies the edges of a graph into tree, back, forward, and cross edges. A breadth-first tree can also be used to classify the edges reachable from the source of the search into the same four categories.
a. Prove that in a breadth-first search of an undirected graph, the following prop- erties hold:
1. There are no back edges and no forward edges.
2. Foreachtreeedge.u;􏳪/,wehave􏳪:dDu:dC1.
3. For each cross edge .u;􏳪/, we have 􏳪:d D u:d or 􏳪:d D u:d C 1.
b. Prove that in a breadth-first search of a directed graph, the following properties hold:
1. There are no forward edges.
2. Foreachtreeedge.u;􏳪/,wehave􏳪:dDu:dC1. 3. For each cross edge .u; 􏳪/, we have 􏳪:d 􏳥 u:d C 1. 4. For each back edge .u;􏳪/, we have 0 􏳥 􏳪:d 􏳥 u:d.
22-2 Articulation points, bridges, and biconnected components
Let G D .V;E/ be a connected, undirected graph. An articulation point of G is a vertex whose removal disconnects G. A bridge of G is an edge whose removal disconnects G. A biconnected component of G is a maximal set of edges such that any two edges in the set lie on a common simple cycle. Figure 22.10 illustrates
Problems for Chapter 22 621

622 Chapter 22 Elementary Graph Algorithms
1
2
4
6
3
5
Figure 22.10 The articulation points, bridges, and biconnected components of a connected, undi- rected graph for use in Problem 22-2. The articulation points are the heavily shaded vertices, the bridges are the heavily shaded edges, and the biconnected components are the edges in the shaded regions, with a bcc numbering shown.
these definitions. We can determine articulation points, bridges, and biconnected components using depth-first search. Let G􏳬 D .V; E􏳬 / be a depth-first tree of G.
a. Prove that the root of G􏳬 is an articulation point of G if and only if it has at least two children in G􏳬 .
b. Let 􏳪 be a nonroot vertex of G􏳬 . Prove that 􏳪 is an articulation point of G if and only if 􏳪 has a child s such that there is no back edge from s or any descendant of s to a proper ancestor of 􏳪.
c. Let
􏳪:low D min
(
􏳪:d ;
w:d W .u;w/ is a back edge for some descendant u of 􏳪 :
Show how to compute 􏳪:low for all vertices 􏳪 2 V in O.E/ time.
d. Show how to compute all articulation points in O.E/ time.
e. Prove that an edge of G is a bridge if and only if it does not lie on any simple cycle of G.
f. Show how to compute all the bridges of G in O.E/ time.
g. Prove that the biconnected components of G partition the nonbridge edges of G.
h. Give an O.E/-time algorithm to label each edge e of G with a positive in- teger e:bcc such that e:bcc D e0:bcc if and only if e and e0 are in the same biconnected component.

Notes for Chapter 22 623
22-3 Euler tour
An Euler tour of a strongly connected, directed graph G D .V;E/ is a cycle that traverses each edge of G exactly once, although it may visit a vertex more than once.
a. ShowthatGhasanEulertourifandonlyifin-degree.􏳪/Dout-degree.􏳪/for each vertex 􏳪 2 V .
b. Describe an O.E/-time algorithm to find an Euler tour of G if one exists. (Hint: Merge edge-disjoint cycles.)
22-4 Reachability
Let G D .V;E/ be a directed graph in which each vertex u 2 V is labeled with a unique integer L.u/ from the set f1;2;:::;jVjg. For each vertex u 2 V, let R.u/ D f􏳪 2 V W u Y 􏳪g be the set of vertices that are reachable from u. Define min.u/ to be the vertex in R.u/ whose label is minimum, i.e., min.u/ is the vertex 􏳪 such that L.􏳪/ D min fL.w/ W w 2 R.u/g. Give an O.V CE/-time algorithm that computes min.u/ for all vertices u 2 V .
Chapter notes
Even [103] and Tarjan [330] are excellent references for graph algorithms. Breadth-first search was discovered by Moore [260] in the context of finding paths through mazes. Lee [226] independently discovered the same algorithm in
the context of routing wires on circuit boards.
Hopcroft and Tarjan [178] advocated the use of the adjacency-list representation
over the adjacency-matrix representation for sparse graphs and were the first to recognize the algorithmic importance of depth-first search. Depth-first search has been widely used since the late 1950s, especially in artificial intelligence programs.
Tarjan [327] gave a linear-time algorithm for finding strongly connected compo- nents. The algorithm for strongly connected components in Section 22.5 is adapted from Aho, Hopcroft, and Ullman [6], who credit it to S. R. Kosaraju (unpublished) and M. Sharir [314]. Gabow [119] also developed an algorithm for strongly con- nected components that is based on contracting cycles and uses two stacks to make it run in linear time. Knuth [209] was the first to give a linear-time algorithm for topological sorting.

23 Minimum Spanning Trees
Electronic circuit designs often need to make the pins of several components elec- trically equivalent by wiring them together. To interconnect a set of n pins, we can use an arrangement of n 􏳣 1 wires, each connecting two pins. Of all such arrange- ments, the one that uses the least amount of wire is usually the most desirable.
We can model this wiring problem with a connected, undirected graph G D .V; E/, where V is the set of pins, E is the set of possible interconnections between pairs of pins, and for each edge .u;􏳪/ 2 E, we have a weight w.u;􏳪/ specifying the cost (amount of wire needed) to connect u and 􏳪. We then wish to find an acyclic subset T 􏳧 E that connects all of the vertices and whose total weight
X
.u;􏳪/2T
is minimized. Since T is acyclic and connects all of the vertices, it must form a tree, which we call a spanning tree since it “spans” the graph G. We call the problem of determining the tree T the minimum-spanning-tree problem.1 Figure 23.1 shows an example of a connected graph and a minimum spanning tree.
In this chapter, we shall examine two algorithms for solving the minimum- spanning-tree problem: Kruskal’s algorithm and Prim’s algorithm. We can easily make each of them run in time O.E lg V / using ordinary binary heaps. By using Fibonacci heaps, Prim’s algorithm runs in time O.E C V lg V /, which improves over the binary-heap implementation if jV j is much smaller than jEj.
The two algorithms are greedy algorithms, as described in Chapter 16. Each step of a greedy algorithm must make one of several possible choices. The greedy strategy advocates making the choice that is the best at the moment. Such a strat- egy does not generally guarantee that it will always find globally optimal solutions
1The phrase “minimum spanning tree” is a shortened form of the phrase “minimum-weight spanning tree.” We are not, for example, minimizing the number of edges in T , since all spanning trees have exactly jV j 􏳣 1 edges by Theorem B.2.
w.T / D
w.u; 􏳪/

23.1 Growing a minimum spanning tree 625
87
bcd
49 2
a 11 i 4 14 e 76
8 10
hgf
12
Figure 23.1 A minimum spanning tree for a connected graph. The weights on edges are shown, and the edges in a minimum spanning tree are shaded. The total weight of the tree shown is 37. This minimum spanning tree is not unique: removing the edge .b; c/ and replacing it with the edge .a; h/ yields another spanning tree with weight 37.
to problems. For the minimum-spanning-tree problem, however, we can prove that certain greedy strategies do yield a spanning tree with minimum weight. Although you can read this chapter independently of Chapter 16, the greedy methods pre- sented here are a classic application of the theoretical notions introduced there.
Section 23.1 introduces a “generic” minimum-spanning-tree method that grows a spanning tree by adding one edge at a time. Section 23.2 gives two algorithms that implement the generic method. The first algorithm, due to Kruskal, is similar to the connected-components algorithm from Section 21.1. The second, due to Prim, resembles Dijkstra’s shortest-paths algorithm (Section 24.3).
Because a tree is a type of graph, in order to be precise we must define a tree in terms of not just its edges, but its vertices as well. Although this chapter focuses on trees in terms of their edges, we shall operate with the understanding that the vertices of a tree T are those that some edge of T is incident on.
23.1 Growing a minimum spanning tree
Assume that we have a connected, undirected graph G D .V;E/ with a weight function w W E ! R, and we wish to find a minimum spanning tree for G. The two algorithms we consider in this chapter use a greedy approach to the problem, although they differ in how they apply this approach.
This greedy strategy is captured by the following generic method, which grows the minimum spanning tree one edge at a time. The generic method manages a set of edges A, maintaining the following loop invariant:
Prior to each iteration, A is a subset of some minimum spanning tree.
At each step, we determine an edge .u; 􏳪/ that we can add to A without violating this invariant, in the sense that A [ f.u; 􏳪/g is also a subset of a minimum spanning

626 Chapter 23 Minimum Spanning Trees
tree. We call such an edge a safe edge for A, since we can add it safely to A while maintaining the invariant.
GENERIC-MST.G; w/
1 2 3 4 5
AD;
while A does not form a spanning tree
find an edge .u; 􏳪/ that is safe for A
A D A[f.u;􏳪/g return A
We use the loop invariant as follows:
Initialization: After line 1, the set A trivially satisfies the loop invariant.
Maintenance: The loop in lines 2–4 maintains the invariant by adding only safe edges.
Termination: All edges added to A are in a minimum spanning tree, and so the set A returned in line 5 must be a minimum spanning tree.
The tricky part is, of course, finding a safe edge in line 3. One must exist, since when line 3 is executed, the invariant dictates that there is a spanning tree T such that A 􏳧 T . Within the while loop body, A must be a proper subset of T , and therefore there must be an edge .u; 􏳪/ 2 T such that .u; 􏳪/ 62 A and .u; 􏳪/ is safe for A.
In the remainder of this section, we provide a rule (Theorem 23.1) for recogniz- ing safe edges. The next section describes two algorithms that use this rule to find safe edges efficiently.
We first need some definitions. A cut .S;V 􏳣 S/ of an undirected graph G D .V; E/ is a partition of V . Figure 23.2 illustrates this notion. We say that an edge .u;􏳪/ 2 E crosses the cut .S;V 􏳣 S/ if one of its endpoints is in S and the other is in V 􏳣 S . We say that a cut respects a set A of edges if no edge in A crosses the cut. An edge is a light edge crossing a cut if its weight is the minimum of any edge crossing the cut. Note that there can be more than one light edge crossing a cut in the case of ties. More generally, we say that an edge is a light edge satisfying a given property if its weight is the minimum of any edge satisfying the property.
Our rule for recognizing safe edges is given by the following theorem.
Theorem 23.1
Let G D .V; E/ be a connected, undirected graph with a real-valued weight func- tion w defined on E. Let A be a subset of E that is included in some minimum spanning tree for G, let .S; V 􏳣 S/ be any cut of G that respects A, and let .u; 􏳪/ bealightedgecrossing.S;V 􏳣S/.Then,edge.u;􏳪/issafeforA.

23.1 Growing a minimum spanning tree
627
h
8 a7
4 11 i 1 b6
2g 87d8
4bcd9 S2S
97c2 a 11 i 4 14 e e 14 4
V – S 8 7 6 10 V – S hgf 10f
12
(a) (b)
Figure 23.2 Two ways of viewing a cut .S; V 􏳣 S/ of the graph from Figure 23.1. (a) Black vertices are in the set S, and white vertices are in V 􏳣 S. The edges crossing the cut are those connecting white vertices with black vertices. The edge .d; c/ is the unique light edge crossing the cut. A subset A of the edges is shaded; note that the cut .S; V 􏳣 S/ respects A, since no edge of A crosses the cut. (b) The same graph with the vertices in the set S on the left and the vertices in the set V 􏳣 S on the right. An edge crosses the cut if it connects a vertex on the left with a vertex on the right.
Proof Let T be a minimum spanning tree that includes A, and assume that T does not contain the light edge .u;􏳪/, since if it does, we are done. We shall construct another minimum spanning tree T 0 that includes A [ f.u; 􏳪/g by using a cut-and-paste technique, thereby showing that .u; 􏳪/ is a safe edge for A.
The edge .u;􏳪/ forms a cycle with the edges on the simple path p from u to 􏳪 in T , as Figure 23.3 illustrates. Since u and 􏳪 are on opposite sides of the cut .S; V 􏳣 S/, at least one edge in T lies on the simple path p and also crosses the cut. Let .x; y/ be any such edge. The edge .x; y/ is not in A, because the cut respects A. Since .x;y/ is on the unique simple path from u to 􏳪 in T, remov- ing .x; y/ breaks T into two components. Adding .u; 􏳪/ reconnects them to form anewspanningtreeT0 DT 􏳣f.x;y/g[f.u;􏳪/g.
We next show that T 0 is a minimum spanning tree. Since .u; 􏳪/ is a light edge crossing .S; V 􏳣S/ and .x; y/ also crosses this cut, w.u; 􏳪/ 􏳥 w.x; y/. Therefore,
w.T0/ D w.T/􏳣w.x;y/Cw.u;􏳪/ 􏳥 w.T/:
S V–S

628 Chapter 23
Minimum Spanning Trees
u
x
p
y
Figure 23.3
v
The proof of Theorem 23.1. Black vertices are in S, and white vertices are in V 􏳣 S. The edges in the minimum spanning tree T are shown, but the edges in the graph G are not. The edges in A are shaded, and .u;􏳪/ is a light edge crossing the cut .S;V 􏳣 S/. The edge .x;y/ is an edge on the unique simple path p from u to 􏳪 in T . To form a minimum spanning tree T 0 that contains .u; 􏳪/, remove the edge .x; y/ from T and add the edge .u; 􏳪/.
But T is a minimum spanning tree, so that w.T / 􏳥 w.T 0/; thus, T 0 must be a minimum spanning tree also.
It remains to show that .u;􏳪/ is actually a safe edge for A. We have A 􏳧 T0, sinceA􏳧T and.x;y/62A;thus,A[f.u;􏳪/g􏳧T0.Consequently,sinceT0 isa minimum spanning tree, .u; 􏳪/ is safe for A.
Theorem 23.1 gives us a better understanding of the workings of the GENERIC- MST method on a connected graph G D .V;E/. As the method proceeds, the set A is always acyclic; otherwise, a minimum spanning tree including A would contain a cycle, which is a contradiction. At any point in the execution, the graph GA D .V;A/ is a forest, and each of the connected components of GA is a tree. (Some of the trees may contain just one vertex, as is the case, for example, when the method begins: A is empty and the forest contains jV j trees, one for each vertex.) Moreover, any safe edge .u; 􏳪/ for A connects distinct components of GA, since A [ f.u; 􏳪/g must be acyclic.
The while loop in lines 2–4 of GENERIC-MST executes jV j 􏳣 1 times because it finds one of the jV j 􏳣 1 edges of a minimum spanning tree in each iteration. Initially, when A D ;, there are jV j trees in GA, and each iteration reduces that number by 1. When the forest contains only a single tree, the method terminates.
The two algorithms in Section 23.2 use the following corollary to Theorem 23.1.

23.1 Growing a minimum spanning tree 629
Corollary 23.2
Let G D .V; E/ be a connected, undirected graph with a real-valued weight func- tion w defined on E. Let A be a subset of E that is included in some minimum spanning tree for G, and let C D .VC ; EC / be a connected component (tree) in the forest GA D .V; A/. If .u; 􏳪/ is a light edge connecting C to some other component in GA, then .u; 􏳪/ is safe for A.
Proof The cut .VC ;V 􏳣 VC / respects A, and .u;􏳪/ is a light edge for this cut. Therefore, .u; 􏳪/ is safe for A.
Exercises
23.1-1
Let .u;􏳪/ be a minimum-weight edge in a connected graph G. Show that .u;􏳪/ belongs to some minimum spanning tree of G.
23.1-2
Professor Sabatier conjectures the following converse of Theorem 23.1. Let G D .V; E/ be a connected, undirected graph with a real-valued weight function w de- fined on E. Let A be a subset of E that is included in some minimum spanning treeforG,let.S;V 􏳣S/beanycutofGthatrespectsA,andlet.u;􏳪/beasafe edge for A crossing .S; V 􏳣 S/. Then, .u; 􏳪/ is a light edge for the cut. Show that the professor’s conjecture is incorrect by giving a counterexample.
23.1-3
Show that if an edge .u; 􏳪/ is contained in some minimum spanning tree, then it is a light edge crossing some cut of the graph.
23.1-4
Give a simple example of a connected graph such that the set of edges f.u;􏳪/ W there exists a cut .S; V 􏳣 S/ such that .u; 􏳪/ is a light edge crossing .S; V 􏳣 S/g does not form a minimum spanning tree.
23.1-5
Let e be a maximum-weight edge on some cycle of connected graph G D .V; E/. Prove that there is a minimum spanning tree of G0 D .V; E 􏳣 feg/ that is also a minimum spanning tree of G. That is, there is a minimum spanning tree of G that does not include e.

630 Chapter 23 Minimum Spanning Trees
23.1-6
Show that a graph has a unique minimum spanning tree if, for every cut of the graph, there is a unique light edge crossing the cut. Show that the converse is not true by giving a counterexample.
23.1-7
Argue that if all edge weights of a graph are positive, then any subset of edges that connects all vertices and has minimum total weight must be a tree. Give an example to show that the same conclusion does not follow if we allow some weights to be nonpositive.
23.1-8
Let T be a minimum spanning tree of a graph G, and let L be the sorted list of the edge weights of T . Show that for any other minimum spanning tree T 0 of G, the list L is also the sorted list of edge weights of T 0.
23.1-9
Let T be a minimum spanning tree of a graph G D .V;E/, and let V 0 be a subset ofV.LetT0 bethesubgraphofT inducedbyV0,andletG0 bethesubgraphofG induced by V 0 . Show that if T 0 is connected, then T 0 is a minimum spanning tree of G0.
23.1-10
Given a graph G and a minimum spanning tree T , suppose that we decrease the weight of one of the edges in T . Show that T is still a minimum spanning tree for G. More formally, let T be a minimum spanning tree for G with edge weights given by weight function w. Choose one edge .x; y/ 2 T and a positive number k, and define the weight function w0 by
(
w.u;􏳪/ if .u;􏳪/ ¤ .x;y/ ; w.x;y/ 􏳣 k if .u;􏳪/ D .x;y/ :
w0.u;􏳪/ D
Show that T is a minimum spanning tree for G with edge weights given by w0.
23.1-11 ?
Given a graph G and a minimum spanning tree T , suppose that we decrease the weight of one of the edges not in T . Give an algorithm for finding the minimum spanning tree in the modified graph.

23.2 The algorithms of Kruskal and Prim 631
23.2 The algorithms of Kruskal and Prim
The two minimum-spanning-tree algorithms described in this section elaborate on the generic method. They each use a specific rule to determine a safe edge in line 3 of GENERIC-MST. In Kruskal’s algorithm, the set A is a forest whose vertices are all those of the given graph. The safe edge added to A is always a least-weight edge in the graph that connects two distinct components. In Prim’s algorithm, the set A forms a single tree. The safe edge added to A is always a least-weight edge connecting the tree to a vertex not in the tree.
Kruskal’s algorithm
Kruskal’s algorithm finds a safe edge to add to the growing forest by finding, of all the edges that connect any two trees in the forest, an edge .u;􏳪/ of least weight. Let C1 and C2 denote the two trees that are connected by .u; 􏳪/. Since .u; 􏳪/ must be a light edge connecting C1 to some other tree, Corollary 23.2 implies that .u; 􏳪/ is a safe edge for C1. Kruskal’s algorithm qualifies as a greedy algorithm because at each step it adds to the forest an edge of least possible weight.
Our implementation of Kruskal’s algorithm is like the algorithm to compute connected components from Section 21.1. It uses a disjoint-set data structure to maintain several disjoint sets of elements. Each set contains the vertices in one tree of the current forest. The operation FIND-SET.u/ returns a representative element from the set that contains u. Thus, we can determine whether two vertices u and 􏳪 belong to the same tree by testing whether FIND-SET.u/ equals FIND-SET.􏳪/. To combine trees, Kruskal’s algorithm calls the UNION procedure.
MST-KRUSKAL.G; w/
1 2 3 4 5 6 7 8 9
AD;
for each vertex 􏳪 2 G: V
MAKE-SET.􏳪/
sort the edges of G:E into nondecreasing order by weight w
for each edge .u;􏳪/ 2 G:E, taken in nondecreasing order by weight
if FIND-SET.u/ ¤ FIND-SET.􏳪/ A D A[f.u;􏳪/g UNION.u; 􏳪/
return A
Figure 23.4 shows how Kruskal’s algorithm works. Lines 1–3 initialize the set A to the empty set and create jV j trees, one containing each vertex. The for loop in lines 5–8 examines edges in order of weight, from lowest to highest. The loop

632 Chapter 23 Minimum Spanning Trees
87 87
bcd bcd
4949
22
(a) a 11 i 4 14 e (b) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
87 87
bcd bcd
4949
22
(c) a 11 i 4 14 e (d) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
87 87
bcd bcd
4949
22
(e) a 11 i 4 14 e (f) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
87 87
bcd bcd
4949
22
(g) a 11 i 4 14 e (h) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
Figure 23.4 The execution of Kruskal’s algorithm on the graph from Figure 23.1. Shaded edges belong to the forest A being grown. The algorithm considers each edge in sorted order by weight. An arrow points to the edge under consideration at each step of the algorithm. If the edge joins two distinct trees in the forest, it is added to the forest, thereby merging the two trees.
checks, for each edge .u;􏳪/, whether the endpoints u and 􏳪 belong to the same tree. If they do, then the edge .u; 􏳪/ cannot be added to the forest without creating a cycle, and the edge is discarded. Otherwise, the two vertices belong to different trees. In this case, line 7 adds the edge .u; 􏳪/ to A, and line 8 merges the vertices in the two trees.

23.2 The algorithms of Kruskal and Prim 633
87 87
bcd bcd
4949
22
(i) a 11 i 4 14 e (j) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
87 87
bcd bcd
4949
22
(k) a 11 i 4 14 e (l) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12
87 87
bcd bcd
4949
22
(m) a 11 i 4 14 e (n) a 11 i 4 14 e
76 76
8 10 8 10
hgf hgf
12 12 Figure 23.4, continued Further steps in the execution of Kruskal’s algorithm.
The running time of Kruskal’s algorithm for a graph G D .V;E/ depends on how we implement the disjoint-set data structure. We assume that we use the disjoint-set-forest implementation of Section 21.3 with the union-by-rank and path-compression heuristics, since it is the asymptotically fastest implementation known. Initializing the set A in line 1 takes O.1/ time, and the time to sort the edges in line 4 is O.E lg E/. (We will account for the cost of the jV j MAKE-SET operations in the for loop of lines 2–3 in a moment.) The for loop of lines 5–8 performs O.E/ FIND-SET and UNION operations on the disjoint-set forest. Along with the jV j MAKE-SET operations, these take a total of O..V C E/ ̨.V // time, where ̨ is the very slowly growing function defined in Section 21.4. Because we assume that G is connected, we have jEj 􏳦 jV j 􏳣 1, and so the disjoint-set opera- tions take O.E ̨.V // time. Moreover, since ̨.jV j/ D O.lg V / D O.lg E/, the to- tal running time of Kruskal’s algorithm is O.E lg E/. Observing that jEj < jV j2, we have lg jEj D O.lg V /, and so we can restate the running time of Kruskal’s algorithm as O.E lg V /. 634 Chapter 23 Minimum Spanning Trees Prim’s algorithm Like Kruskal’s algorithm, Prim’s algorithm is a special case of the generic min- imum-spanning-tree method from Section 23.1. Prim’s algorithm operates much like Dijkstra’s algorithm for finding shortest paths in a graph, which we shall see in Section 24.3. Prim’s algorithm has the property that the edges in the set A always form a single tree. As Figure 23.5 shows, the tree starts from an arbitrary root vertex r and grows until the tree spans all the vertices in V . Each step adds to the tree A a light edge that connects A to an isolated vertex—one on which no edge of A is incident. By Corollary 23.2, this rule adds only edges that are safe for A; therefore, when the algorithm terminates, the edges in A form a minimum spanning tree. This strategy qualifies as greedy since at each step it adds to the tree an edge that contributes the minimum amount possible to the tree’s weight. In order to implement Prim’s algorithm efficiently, we need a fast way to select a new edge to add to the tree formed by the edges in A. In the pseudocode below, the connected graph G and the root r of the minimum spanning tree to be grown are inputs to the algorithm. During execution of the algorithm, all vertices that are not in the tree reside in a min-priority queue Q based on a key attribute. For each vertex 􏳪, the attribute 􏳪:key is the minimum weight of any edge connecting 􏳪 to a vertex in the tree; by convention, 􏳪:key D 1 if there is no such edge. The attribute 􏳪:􏳬 names the parent of 􏳪 in the tree. The algorithm implicitly maintains the set A from GENERIC-MST as ADf.􏳪;􏳪:􏳬/W􏳪2V 􏳣frg􏳣Qg : When the algorithm terminates, the min-priority queue Q is empty; the minimum spanning tree A for G is thus ADf.􏳪;􏳪:􏳬/W􏳪2V 􏳣frgg : MST-PRIM.G; w; r/ 1 2 3 4 5 6 7 8 9 10 11 foreachu2G:V u:key D 1 u:􏳬 D NIL r:keyD0 QDG:V whileQ¤; u D EXTRACT-MIN.Q/ for each 􏳪 2 G:AdjŒu􏳩 if 􏳪 2 Q and w.u;􏳪/ < 􏳪:key 􏳪:􏳬 D u 􏳪:key D w.u;􏳪/ (a) a (c) a (e) a (g) a (i) a 87 87 bcd bcd 4949 22 11 i 4 14 e (b) a 11 i 4 14 e 76 76 8 10 8 10 hgf hgf 12 12 87 87 bcd bcd 4949 22 11 i 4 14 e (d) a 11 i 4 14 e 76 76 8 10 8 10 hgf hgf 12 12 87 87 bcd bcd 4949 22 11 i 4 14 e (f) a 11 i 4 14 e 76 76 8 10 8 10 hgf hgf 12 12 87 87 bcd bcd 4949 22 11 i 4 14 e (h) a 11 i 4 14 e 76 76 8 10 8 10 hgf hgf 12 12 87 bcd 49 2 11 i 4 14 e 23.2 The algorithms of Kruskal and Prim 635 76 8 10 Figure 23.5 The execution of Prim’s algorithm on the graph from Figure 23.1. The root vertex is a. Shaded edges are in the tree being grown, and black vertices are in the tree. At each step of the algorithm, the vertices in the tree determine a cut of the graph, and a light edge crossing the cut is added to the tree. In the second step, for example, the algorithm has a choice of adding either edge .b; c/ or edge .a; h/ to the tree since both are light edges crossing the cut. hgf 12 636 Chapter 23 Minimum Spanning Trees Figure 23.5 shows how Prim’s algorithm works. Lines 1–5 set the key of each vertex to 1 (except for the root r, whose key is set to 0 so that it will be the first vertex processed), set the parent of each vertex to NIL, and initialize the min- priority queue Q to contain all the vertices. The algorithm maintains the following three-part loop invariant: Prior to each iteration of the while loop of lines 6–11, 1.ADf.􏳪;􏳪:􏳬/W􏳪2V 􏳣frg􏳣Qg. 2. The vertices already placed into the minimum spanning tree are those in V 􏳣Q. 3. For all vertices 􏳪 2 Q, if 􏳪:􏳬 ¤ NIL, then 􏳪:key < 1 and 􏳪:key is the weight of a light edge .􏳪;􏳪:􏳬/ connecting 􏳪 to some vertex already placed into the minimum spanning tree. Line 7 identifies a vertex u 2 Q incident on a light edge that crosses the cut .V 􏳣 Q; Q/ (with the exception of the first iteration, in which u D r due to line 4). Removing u from the set Q adds it to the set V 􏳣 Q of vertices in the tree, thus adding .u;u:􏳬/ to A. The for loop of lines 8–11 updates the key and 􏳬 attributes of every vertex 􏳪 adjacent to u but not in the tree, thereby maintaining the third part of the loop invariant. The running time of Prim’s algorithm depends on how we implement the min- priority queue Q. If we implement Q as a binary min-heap (see Chapter 6), we can use the BUILD-MIN-HEAP procedure to perform lines 1–5 in O.V / time. The body of the while loop executes jV j times, and since each EXTRACT-MIN opera- tion takes O.lg V / time, the total time for all calls to EXTRACT-MIN is O.V lg V /. The for loop in lines 8–11 executes O.E/ times altogether, since the sum of the lengths of all adjacency lists is 2jEj. Within the for loop, we can implement the test for membership in Q in line 9 in constant time by keeping a bit for each vertex that tells whether or not it is in Q, and updating the bit when the vertex is removed from Q. The assignment in line 11 involves an implicit DECREASE-KEY opera- tion on the min-heap, which a binary min-heap supports in O.lg V / time. Thus, thetotaltimeforPrim’salgorithmisO.V lgV CElgV/DO.ElgV/,whichis asymptotically the same as for our implementation of Kruskal’s algorithm. We can improve the asymptotic running time of Prim’s algorithm by using Fi- bonacci heaps. Chapter 19 shows that if a Fibonacci heap holds jV j elements, an EXTRACT-MIN operation takes O.lg V / amortized time and a DECREASE-KEY operation (to implement line 11) takes O.1/ amortized time. Therefore, if we use a Fibonacci heap to implement the min-priority queue Q, the running time of Prim’s algorithm improves to O.E C V lg V /. 23.2 The algorithms of Kruskal and Prim 637 Exercises 23.2-1 Kruskal’s algorithm can return different spanning trees for the same input graph G, depending on how it breaks ties when the edges are sorted into order. Show that for each minimum spanning tree T of G, there is a way to sort the edges of G in Kruskal’s algorithm so that the algorithm returns T . 23.2-2 Suppose that we represent the graph G D .V;E/ as an adjacency matrix. Give a simple implementation of Prim’s algorithm for this case that runs in O.V 2/ time. 23.2-3 For a sparse graph G D .V; E/, where jEj D ‚.V /, is the implementation of Prim’s algorithm with a Fibonacci heap asymptotically faster than the binary-heap implementation? What about for a dense graph, where jE j D ‚.V 2 /? How must the sizes jEj and jV j be related for the Fibonacci-heap implementation to be asymptotically faster than the binary-heap implementation? 23.2-4 Suppose that all edge weights in a graph are integers in the range from 1 to jV j. How fast can you make Kruskal’s algorithm run? What if the edge weights are integers in the range from 1 to W for some constant W ? 23.2-5 Suppose that all edge weights in a graph are integers in the range from 1 to jV j. How fast can you make Prim’s algorithm run? What if the edge weights are integers in the range from 1 to W for some constant W ? 23.2-6 ? Suppose that the edge weights in a graph are uniformly distributed over the half- open interval Œ0;1/. Which algorithm, Kruskal’s or Prim’s, can you make run faster? 23.2-7 ? Suppose that a graph G has a minimum spanning tree already computed. How quickly can we update the minimum spanning tree if we add a new vertex and incident edges to G? 23.2-8 Professor Borden proposes a new divide-and-conquer algorithm for computing minimum spanning trees, which goes as follows. Given a graph G D .V;E/, partition the set V of vertices into two sets V1 and V2 such that jV1j and jV2j differ 638 Chapter 23 Minimum Spanning Trees Problems by at most 1. Let E1 be the set of edges that are incident only on vertices in V1, and let E2 be the set of edges that are incident only on vertices in V2. Recursively solve a minimum-spanning-tree problem on each of the two subgraphs G1 D .V1;E1/ and G2 D .V2; E2/. Finally, select the minimum-weight edge in E that crosses the cut .V1;V2/, and use this edge to unite the resulting two minimum spanning trees into a single spanning tree. Either argue that the algorithm correctly computes a minimum spanning tree of G, or provide an example for which the algorithm fails. 23-1 Second-best minimum spanning tree Let G D .V;E/ be an undirected, connected graph whose weight function is w W E ! R, and suppose that jEj 􏳦 jV j and all edge weights are distinct. We define a second-best minimum spanning tree as follows. Let T be the set of all spanning trees of G, and let T0 be a minimum spanning tree of G. Then a second-best minimum spanning tree is a spanning tree T such that w.T/ D minT 002T 􏳣fT 0g fw.T 00/g. a. Show that the minimum spanning tree is unique, but that the second-best mini- mum spanning tree need not be unique. b. Let T be the minimum spanning tree of G. Prove that G contains edges .u;􏳪/ 2 T and .x;y/ 62 T such that T 􏳣 f.u;􏳪/g [ f.x;y/g is a second-best minimum spanning tree of G. c. Let T be a spanning tree of G and, for any two vertices u;􏳪 2 V , let maxŒu;􏳪􏳩 denote an edge of maximum weight on the unique simple path between u and 􏳪 in T . Describe an O.V 2/-time algorithm that, given T , computes maxŒu; 􏳪􏳩 for all u; 􏳪 2 V . d. Give an efficient algorithm to compute the second-best minimum spanning tree of G. 23-2 Minimum spanning tree in sparse graphs For a very sparse connected graph G D .V;E/, we can further improve upon the O.E C V lg V / running time of Prim’s algorithm with Fibonacci heaps by prepro- cessing G to decrease the number of vertices before running Prim’s algorithm. In particular, we choose, for each vertex u, the minimum-weight edge .u; 􏳪/ incident on u, and we put .u;􏳪/ into the minimum spanning tree under construction. We Problems for Chapter 23 639 then contract all chosen edges (see Section B.4). Rather than contracting these edges one at a time, we first identify sets of vertices that are united into the same new vertex. Then we create the graph that would have resulted from contracting these edges one at a time, but we do so by “renaming” edges according to the sets into which their endpoints were placed. Several edges from the original graph may be renamed the same as each other. In such a case, only one edge results, and its weight is the minimum of the weights of the corresponding original edges. Initially, we set the minimum spanning tree T being constructed to be empty, and for each edge .u;􏳪/ 2 E, we initialize the attributes .u;􏳪/:orig D .u;􏳪/ and .u;􏳪/:c D w.u;􏳪/. We use the orig attribute to reference the edge from the initial graph that is associated with an edge in the contracted graph. The c attribute holds the weight of an edge, and as edges are contracted, we update it according to the above scheme for choosing edge weights. The procedure MST-REDUCE takes inputs G and T , and it returns a contracted graph G0 with updated attributes orig0 and c0. The procedure also accumulates edges of G into the minimum spanning tree T . MST-REDUCE.G; T / 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 foreach􏳪2G:V 􏳪:mark D FALSE MAKE-SET.􏳪/ foreachu2G:V if u:mark == FALSE choose 􏳪 2 G:AdjŒu􏳩 such that .u;􏳪/:c is minimized UNION.u; 􏳪/ TDT[f.u;􏳪/:origg u:mark D 􏳪:mark D TRUE fFIND-SET.􏳪/ W 􏳪 2 G:Vg ; G0:V D G0:E D foreach.x;y/2G:E u D FIND-SET.x/ 􏳪 D FIND-SET.y/ if .u;􏳪/ 62 G0:E else G0:EDG0:E[f.u;􏳪/g .u; 􏳪/:orig0 D .x; y/:orig .u; 􏳪/:c0 D .x; y/:c if .x; y/:c < .u; 􏳪/:c0 .u;􏳪/:orig0 D .x;y/:orig .u;􏳪/:c0 D .x;y/:c construct adjacency lists G0:Adj for G0 return G0 and T 640 Chapter 23 Minimum Spanning Trees a. Let T be the set of edges returned by MST-REDUCE, and let A be the minimum spanning tree of the graph G0 formed by the call MST-PRIM.G0; c0; r/, where c0 is the weight attribute on the edges of G0:E and r is any vertex in G0:V. Prove that T [ f.x; y/:orig0 W .x; y/ 2 Ag is a minimum spanning tree of G. b. ArguethatjG0:Vj􏳥jVj=2. c. Show how to implement MST-REDUCE so that it runs in O.E/ time. (Hint: Use simple data structures.) d. Suppose that we run k phases of MST-REDUCE, using the output G0 produced by one phase as the input G to the next phase and accumulating edges in T . Argue that the overall running time of the k phases is O.kE/. e. Suppose that after running k phases of MST-REDUCE, as in part (d), we run Prim’s algorithm by calling MST-PRIM.G0;c0;r/, where G0, with weight at- tribute c0, is returned by the last phase and r is any vertex in G0:V. Show how to pick k so that the overall running time is O.E lg lg V /. Argue that your choice of k minimizes the overall asymptotic running time. f. For what values of jEj (in terms of jV j) does Prim’s algorithm with preprocess- ing asymptotically beat Prim’s algorithm without preprocessing? 23-3 Bottleneck spanning tree A bottleneck spanning tree T of an undirected graph G is a spanning tree of G whose largest edge weight is minimum over all spanning trees of G. We say that the value of the bottleneck spanning tree is the weight of the maximum-weight edge in T . a. Argue that a minimum spanning tree is a bottleneck spanning tree. Part (a) shows that finding a bottleneck spanning tree is no harder than finding a minimum spanning tree. In the remaining parts, we will show how to find a bottleneck spanning tree in linear time. b. Give a linear-time algorithm that given a graph G and an integer b, determines whether the value of the bottleneck spanning tree is at most b. c. Use your algorithm for part (b) as a subroutine in a linear-time algorithm for the bottleneck-spanning-tree problem. (Hint: You may want to use a subroutine that contracts sets of edges, as in the MST-REDUCE procedure described in Problem 23-2.) Notes for Chapter 23 641 23-4 Alternative minimum-spanning-tree algorithms In this problem, we give pseudocode for three different algorithms. Each one takes a connected graph and a weight function as input and returns a set of edges T . For each algorithm, either prove that T is a minimum spanning tree or prove that T is not a minimum spanning tree. Also describe the most efficient implementation of each algorithm, whether or not it computes a minimum spanning tree. a. MAYBE-MST-A.G;w/ 1 sort the edges into nonincreasing order of edge weights w 2TDE 3 4 5 6 for each edge e, taken in nonincreasing order by weight if T 􏳣 feg is a connected graph T D T 􏳣 feg return T b. MAYBE-MST-B.G;w/ 1TD; 2 3 4 5 for each edge e, taken in arbitrary order if T [ feg has no cycles T D T [ feg return T c. MAYBE-MST-C.G; w/ 1TD; 2 3 4 5 6 7 for each edge e, taken in arbitrary order T D T [ feg ifT hasacyclec let e0 be a maximum-weight edge on c T D T 􏳣 fe0g return T Chapter notes Tarjan [330] surveys the minimum-spanning-tree problem and provides excellent advanced material. Graham and Hell [151] compiled a history of the minimum- spanning-tree problem. Tarjan attributes the first minimum-spanning-tree algorithm to a 1926 paper by O. Boru ̇ vka. Boru ̇ vka’s algorithm consists of running O .lg V / iterations of the 642 Chapter 23 Minimum Spanning Trees procedure MST-REDUCE described in Problem 23-2. Kruskal’s algorithm was reported by Kruskal [222] in 1956. The algorithm commonly known as Prim’s algorithm was indeed invented by Prim [285], but it was also invented earlier by V. Jarn ́ık in 1930. The reason underlying why greedy algorithms are effective at finding minimum spanning trees is that the set of forests of a graph forms a graphic matroid. (See Section 16.4.) When jEj D 􏳫.V lg V /, Prim’s algorithm, implemented with Fibonacci heaps, runs in O.E/ time. For sparser graphs, using a combination of the ideas from Prim’s algorithm, Kruskal’s algorithm, and Boru ̇vka’s algorithm, together with ad- vanced data structures, Fredman and Tarjan [114] give an algorithm that runs in O.E lg􏳤 V / time. Gabow, Galil, Spencer, and Tarjan [120] improved this algo- rithm to run in O.E lg lg􏳤 V / time. Chazelle [60] gives an algorithm that runs in O.E ̨y.E; V // time, where ̨y.E; V / is the functional inverse of Ackermann’s function. (See the chapter notes for Chapter 21 for a brief discussion of Acker- mann’s function and its inverse.) Unlike previous minimum-spanning-tree algo- rithms, Chazelle’s algorithm does not follow the greedy method. A related problem is spanning-tree verification, in which we are given a graph G D .V;E/ and a tree T 􏳧 E, and we wish to determine whether T is a minimum spanning tree of G. King [203] gives a linear-time algorithm to verify a spanning tree, building on earlier work of Komlo ́s [215] and Dixon, Rauch, and Tarjan [90]. The above algorithms are all deterministic and fall into the comparison-based model described in Chapter 8. Karger, Klein, and Tarjan [195] give a randomized minimum-spanning-tree algorithm that runs in O.V C E/ expected time. This algorithm uses recursion in a manner similar to the linear-time selection algorithm in Section 9.3: a recursive call on an auxiliary problem identifies a subset of the edges E0 that cannot be in any minimum spanning tree. Another recursive call on E 􏳣 E0 then finds the minimum spanning tree. The algorithm also uses ideas from Boru ̇vka’s algorithm and King’s algorithm for spanning-tree verification. Fredman and Willard [116] showed how to find a minimum spanning tree in O.V CE/ time using a deterministic algorithm that is not comparison based. Their algorithm assumes that the data are b-bit integers and that the computer memory consists of addressable b-bit words. 24 Single-Source Shortest Paths Professor Patrick wishes to find the shortest possible route from Phoenix to Indi- anapolis. Given a road map of the United States on which the distance between each pair of adjacent intersections is marked, how can she determine this shortest route? One possible way would be to enumerate all the routes from Phoenix to Indi- anapolis, add up the distances on each route, and select the shortest. It is easy to see, however, that even disallowing routes that contain cycles, Professor Patrick would have to examine an enormous number of possibilities, most of which are simply not worth considering. For example, a route from Phoenix to Indianapolis that passes through Seattle is obviously a poor choice, because Seattle is several hundred miles out of the way. In this chapter and in Chapter 25, we show how to solve such problems ef- ficiently. In a shortest-paths problem, we are given a weighted, directed graph G D .V;E/, with weight function w W E ! R mapping edges to real-valued weights. The weight w.p/ of path p D h􏳪0;􏳪1;:::;􏳪ki is the sum of the weights of its constituent edges: (p ı.u;􏳪/D minfw.p/WuY􏳪g ifthereisapathfromuto􏳪; 1 otherwise : A shortest path from vertex u to vertex 􏳪 is then defined as any path p with weight w.p/ D ı.u; 􏳪/. In the Phoenix-to-Indianapolis example, we can model the road map as a graph: vertices represent intersections, edges represent road segments between intersec- tions, and edge weights represent road distances. Our goal is to find a shortest path from a given intersection in Phoenix to a given intersection in Indianapolis. Xk iD1 w.􏳪i􏳣1;􏳪i/ : We define the shortest-path weight ı.u; 􏳪/ from u to 􏳪 by w.p/ D 644 Chapter 24 Single-Source Shortest Paths Edge weights can represent metrics other than distances, such as time, cost, penalties, loss, or any other quantity that accumulates linearly along a path and that we would want to minimize. The breadth-first-search algorithm from Section 22.2 is a shortest-paths algo- rithm that works on unweighted graphs, that is, graphs in which each edge has unit weight. Because many of the concepts from breadth-first search arise in the study of shortest paths in weighted graphs, you might want to review Section 22.2 before proceeding. Variants In this chapter, we shall focus on the single-source shortest-paths problem: given a graph G D .V;E/, we want to find a shortest path from a given source vertex s 2 V to each vertex 􏳪 2 V . The algorithm for the single-source problem can solve many other problems, including the following variants. Single-destination shortest-paths problem: Find a shortest path to a given des- tination vertex t from each vertex 􏳪. By reversing the direction of each edge in the graph, we can reduce this problem to a single-source problem. Single-pair shortest-path problem: Find a shortest path from u to 􏳪 for given vertices u and 􏳪. If we solve the single-source problem with source vertex u, we solve this problem also. Moreover, all known algorithms for this problem have the same worst-case asymptotic running time as the best single-source algorithms. All-pairs shortest-paths problem: Find a shortest path from u to 􏳪 for every pair of vertices u and 􏳪. Although we can solve this problem by running a single- source algorithm once from each vertex, we usually can solve it faster. Addi- tionally, its structure is interesting in its own right. Chapter 25 addresses the all-pairs problem in detail. Optimal substructure of a shortest path Shortest-paths algorithms typically rely on the property that a shortest path be- tween two vertices contains other shortest paths within it. (The Edmonds-Karp maximum-flow algorithm in Chapter 26 also relies on this property.) Recall that optimal substructure is one of the key indicators that dynamic programming (Chapter 15) and the greedy method (Chapter 16) might apply. Dijkstra’s algo- rithm, which we shall see in Section 24.3, is a greedy algorithm, and the Floyd- Warshall algorithm, which finds shortest paths between all pairs of vertices (see Section 25.2), is a dynamic-programming algorithm. The following lemma states the optimal-substructure property of shortest paths more precisely. Chapter 24 Single-Source Shortest Paths 645 Lemma 24.1 (Subpaths of shortest paths are shortest paths) Given a weighted, directed graph G D .V; E/ with weight function w W E ! R, let p D h􏳪0;􏳪1;:::;􏳪ki be a shortest path from vertex 􏳪0 to vertex 􏳪k and, for any iandjsuchthat0􏳥i􏳥j􏳥k,letpij Dh􏳪i;􏳪iC1;:::;􏳪jibethesubpathofp from vertex 􏳪i to vertex 􏳪j . Then, pij is a shortest path from 􏳪i to 􏳪j . p 0 i p ij pj k Proof If we decompose path p into 􏳪0 Y 􏳪i Y 􏳪j Y 􏳪k, then we have that w.p/Dw.p0i/Cw.pij/Cw.pjk/.Now,assumethatthereisapathp0 from􏳪i ij 0 p 0 i p i0 j p j k to􏳪j withweightw.pij/ 0, the shortest path from s to c is hs; ci, with weight ı.s; c/ D w.s; c/ D 5. Similarly, the shortest path from s to d is hs; c; d i, with weight ı.s; d / D w.s; c/Cw.c; d / D 11. Analogously, there are infinitely many paths from s to e: hs; ei, hs; e; f; ei, hs; e; f; e; f; ei, and so on. Because the cycle he; f; ei has weight 3 C .􏳣6/ D 􏳣3 < 0, however, there is no shortest path from s to e. By traversing the negative-weight cycle he; f; ei arbitrarily many times, we can find paths from s to e with arbitrarily large negative weights, and so ı.s; e/ D 􏳣1. Similarly, ı.s; f / D 􏳣1. Because g is reachable from f , we can also find paths with arbitrarily large negative weights from s to g, and so ı.s; g/ D 􏳣1. Vertices h, i , and j also form a negative-weight cycle. They are not reachable from s, however, and so ı.s;h/ D ı.s;i/ D ı.s;j/ D 1. 646 Chapter 24 Single-Source Shortest Paths ab 3 –4 –1 hi 34∞2∞ sc6dg 0 5 5 11 8 –∞ –8 3 –3 2e3f7 ∞ j –∞ –∞ –6 Figure 24.1 Negative edge weights in a directed graph. The shortest-path weight from source s appears within each vertex. Because vertices e and f form a negative-weight cycle reachable from s, they have shortest-path weights of 􏳣1. Because vertex g is reachable from a vertex whose shortest- path weight is 􏳣1, it, too, has a shortest-path weight of 􏳣1. Vertices such as h, i, and j are not reachable from s, and so their shortest-path weights are 1, even though they lie on a negative-weight cycle. Some shortest-paths algorithms, such as Dijkstra’s algorithm, assume that all edge weights in the input graph are nonnegative, as in the road-map example. Oth- ers, such as the Bellman-Ford algorithm, allow negative-weight edges in the in- put graph and produce a correct answer as long as no negative-weight cycles are reachable from the source. Typically, if there is such a negative-weight cycle, the algorithm can detect and report its existence. Cycles Can a shortest path contain a cycle? As we have just seen, it cannot contain a negative-weight cycle. Nor can it contain a positive-weight cycle, since remov- ing the cycle from the path produces a path with the same source and destination vertices and a lower path weight. That is, if p D h􏳪0; 􏳪1; :::; 􏳪ki is a path and c D h􏳪i;􏳪iC1;:::;􏳪ji is a positive-weight cycle on this path (so that 􏳪i D 􏳪j and w.c/ > 0), then the path p0 D h􏳪0; 􏳪1; :::; 􏳪i; 􏳪jC1; 􏳪jC2; :::; 􏳪ki has weight w.p0/ D w.p/ 􏳣 w.c/ < w.p/, and so p cannot be a shortest path from 􏳪0 to 􏳪k. That leaves only 0-weight cycles. We can remove a 0-weight cycle from any path to produce another path whose weight is the same. Thus, if there is a shortest path from a source vertex s to a destination vertex 􏳪 that contains a 0-weight cycle, then there is another shortest path from s to 􏳪 without this cycle. As long as a shortest path has 0-weight cycles, we can repeatedly remove these cycles from the path until we have a shortest path that is cycle-free. Therefore, without loss of generality we can assume that when we are finding shortest paths, they have no cycles, i.e., they are simple paths. Since any acyclic path in a graph G D .V;E/ Chapter 24 Single-Source Shortest Paths 647 contains at most jV j distinct vertices, it also contains at most jV j 􏳣 1 edges. Thus, we can restrict our attention to shortest paths of at most jV j 􏳣 1 edges. Representing shortest paths We often wish to compute not only shortest-path weights, but the vertices on short- est paths as well. We represent shortest paths similarly to how we represented breadth-first trees in Section 22.2. Given a graph G D .V;E/, we maintain for each vertex 􏳪 2 V a predecessor 􏳪:􏳬 that is either another vertex or NIL. The shortest-paths algorithms in this chapter set the 􏳬 attributes so that the chain of pre- decessors originating at a vertex 􏳪 runs backwards along a shortest path from s to 􏳪. Thus, given a vertex 􏳪 for which 􏳪:􏳬 ¤ NIL, the procedure PRINT-PATH.G;s;􏳪/ from Section 22.2 will print a shortest path from s to 􏳪. In the midst of executing a shortest-paths algorithm, however, the 􏳬 values might not indicate shortest paths. As in breadth-first search, we shall be interested in the predecessor subgraph G􏳬 D .V􏳬 ; E􏳬 / induced by the 􏳬 values. Here again, we define the vertex set V􏳬 to be the set of vertices of G with non-NIL predecessors, plus the source s: V􏳬 D f􏳪 2 V W 􏳪:􏳬 ¤ NILg [ fsg : The directed edge set E􏳬 is the set of edges induced by the 􏳬 values for vertices in V􏳬 : E􏳬 Df.􏳪:􏳬;􏳪/2EW􏳪2V􏳬􏳣fsgg: We shall prove that the 􏳬 values produced by the algorithms in this chapter have the property that at termination G􏳬 is a “shortest-paths tree”—informally, a rooted tree containing a shortest path from the source s to every vertex that is reachable from s. A shortest-paths tree is like the breadth-first tree from Section 22.2, but it contains shortest paths from the source defined in terms of edge weights instead of numbers of edges. To be precise, let G D .V;E/ be a weighted, directed graph with weight function w W E ! R, and assume that G contains no negative-weight cycles reachable from the source vertex s 2 V , so that shortest paths are well defined. A shortest-paths tree rooted at s is a directed subgraph G 0 D .V 0 ; E 0 /, whereV0 􏳧V andE0 􏳧E,suchthat 1. V 0 is the set of vertices reachable from s in G, 2. G0 forms a rooted tree with root s, and 3. forall􏳪2V0,theuniquesimplepathfromsto􏳪inG0 isashortestpathfroms to 􏳪 in G. 648 Chapter 24 Single-Source Shortest Paths t6x t6x t6x 393939 333 s021427 s021427 s021427 535353 5 11 5 11 5 11 y6z y6z y6z (a) (b) (c) Figure 24.2 (a) A weighted, directed graph with shortest-path weights from source s. (b) The shaded edges form a shortest-paths tree rooted at the source s. (c) Another shortest-paths tree with the same root. Shortest paths are not necessarily unique, and neither are shortest-paths trees. For example, Figure 24.2 shows a weighted, directed graph and two shortest-paths trees with the same root. Relaxation The algorithms in this chapter use the technique of relaxation. For each vertex 􏳪 2 V , we maintain an attribute 􏳪:d, which is an upper bound on the weight of a shortest path from source s to 􏳪. We call 􏳪:d a shortest-path estimate. We initialize the shortest-path estimates and predecessors by the following ‚.V /-time procedure: INITIALIZE-SINGLE-SOURCE.G; s/ for each vertex 􏳪 2 G:V 􏳪:d D 1 1 2 3 4 s:dD0 􏳪:􏳬 D NIL After initialization, we have 􏳪:􏳬 D NIL for all 􏳪 2 V, s:d D 0, and 􏳪:d D 1 for 􏳪 2 V 􏳣 fsg. The process of relaxing an edge .u;􏳪/ consists of testing whether we can im- prove the shortest path to 􏳪 found so far by going through u and, if so, updat- ing 􏳪:d and 􏳪:􏳬. A relaxation step1 may decrease the value of the shortest-path 1It may seem strange that the term “relaxation” is used for an operation that tightens an upper bound. The use of the term is historical. The outcome of a relaxation step can be viewed as a relaxation of the constraint 􏳪:d 􏳥 u:d C w.u;􏳪/, which, by the triangle inequality (Lemma 24.10), must be satisfied if u:d D ı.s; u/ and 􏳪:d D ı.s; 􏳪/. That is, if 􏳪:d 􏳥 u:d C w.u; 􏳪/, there is no “pressure” to satisfy this constraint, so the constraint is “relaxed.” Chapter 24 Single-Source Shortest Paths 649 uvuv 529 526 RELAX(u,v,w) RELAX(u,v,w) uvuv 527 526 (a) (b) Figure 24.3 Relaxing an edge .u; 􏳪/ with weight w.u; 􏳪/ D 2. The shortest-path estimate of each vertex appears within the vertex. (a) Because 􏳪:d > u:d C w.u;􏳪/ prior to relaxation, the value of 􏳪: d decreases. (b) Here, 􏳪: d 􏳥 u: d C w.u; 􏳪/ before relaxing the edge, and so the relaxation step leaves 􏳪:d unchanged.
estimate 􏳪:d and update 􏳪’s predecessor attribute 􏳪:􏳬. The following code per- forms a relaxation step on edge .u; 􏳪/ in O.1/ time:
RELAX.u; 􏳪; w/
1 if􏳪:d>u:dCw.u;􏳪/
2 􏳪:d D u:dCw.u;􏳪/
3 􏳪:􏳬 D u
Figure 24.3 shows two examples of relaxing an edge, one in which a shortest-path estimate decreases and one in which no estimate changes.
Each algorithm in this chapter calls INITIALIZE-SINGLE-SOURCE and then re- peatedly relaxes edges. Moreover, relaxation is the only means by which shortest- path estimates and predecessors change. The algorithms in this chapter differ in how many times they relax each edge and the order in which they relax edges. Dijk- stra’s algorithm and the shortest-paths algorithm for directed acyclic graphs relax each edge exactly once. The Bellman-Ford algorithm relaxes each edge jV j 􏳣 1 times.
Properties of shortest paths and relaxation
To prove the algorithms in this chapter correct, we shall appeal to several prop- erties of shortest paths and relaxation. We state these properties here, and Sec- tion 24.5 proves them formally. For your reference, each property stated here in- cludes the appropriate lemma or corollary number from Section 24.5. The latter five of these properties, which refer to shortest-path estimates or the predecessor subgraph, implicitly assume that the graph is initialized with a call to INITIALIZE- SINGLE-SOURCE.G;s/ and that the only way that shortest-path estimates and the predecessor subgraph change are by some sequence of relaxation steps.

650 Chapter 24 Single-Source Shortest Paths
Triangle inequality (Lemma 24.10)
For any edge .u;􏳪/ 2 E, we have ı.s;􏳪/ 􏳥 ı.s;u/ C w.u;􏳪/.
Upper-bound property (Lemma 24.11)
We always have 􏳪:d 􏳦 ı.s; 􏳪/ for all vertices 􏳪 2 V , and once 􏳪:d achieves the value ı.s; 􏳪/, it never changes.
No-path property (Corollary 24.12)
If there is no path from s to 􏳪, then we always have 􏳪:d D ı.s;􏳪/ D 1.
Convergence property (Lemma 24.14)
If s Y u ! 􏳪 is a shortest path in G for some u; 􏳪 2 V , and if u: d D ı.s; u/ at any time prior to relaxing edge .u; 􏳪/, then 􏳪:d D ı.s; 􏳪/ at all times afterward.
Path-relaxation property (Lemma 24.15)
If p D h􏳪0;􏳪1;:::;􏳪ki is a shortest path from s D 􏳪0 to 􏳪k, and we relax the edges of p in the order .􏳪0;􏳪1/;.􏳪1;􏳪2/;:::;.􏳪k􏳣1;􏳪k/, then 􏳪k:d D ı.s;􏳪k/. This property holds regardless of any other relaxation steps that occur, even if they are intermixed with relaxations of the edges of p.
Predecessor-subgraph property (Lemma 24.17)
Once 􏳪:d D ı.s; 􏳪/ for all 􏳪 2 V , the predecessor subgraph is a shortest-paths tree rooted at s.
Chapter outline
Section 24.1 presents the Bellman-Ford algorithm, which solves the single-source shortest-paths problem in the general case in which edges can have negative weight. The Bellman-Ford algorithm is remarkably simple, and it has the further benefit of detecting whether a negative-weight cycle is reachable from the source. Sec- tion 24.2 gives a linear-time algorithm for computing shortest paths from a single source in a directed acyclic graph. Section 24.3 covers Dijkstra’s algorithm, which has a lower running time than the Bellman-Ford algorithm but requires the edge weights to be nonnegative. Section 24.4 shows how we can use the Bellman-Ford algorithm to solve a special case of linear programming. Finally, Section 24.5 proves the properties of shortest paths and relaxation stated above.
We require some conventions for doing arithmetic with infinities. We shall as- sume that for any real number a ¤ 􏳣1, we have aC1 D 1Ca D 1. Also, to make our proofs hold in the presence of negative-weight cycles, we shall assume that for any real number a ¤ 1, we have a C .􏳣1/ D .􏳣1/ C a D 􏳣1.
All algorithms in this chapter assume that the directed graph G is stored in the adjacency-list representation. Additionally, stored with each edge is its weight, so that as we traverse each adjacency list, we can determine the edge weights in O.1/ time per edge.

24.1 The Bellman-Ford algorithm 651
24.1 The Bellman-Ford algorithm
The Bellman-Ford algorithm solves the single-source shortest-paths problem in the general case in which edge weights may be negative. Given a weighted, di- rected graph G D .V;E/ with source s and weight function w W E ! R, the Bellman-Ford algorithm returns a boolean value indicating whether or not there is a negative-weight cycle that is reachable from the source. If there is such a cy- cle, the algorithm indicates that no solution exists. If there is no such cycle, the algorithm produces the shortest paths and their weights.
The algorithm relaxes edges, progressively decreasing an estimate 􏳪:d on the weight of a shortest path from the source s to each vertex 􏳪 2 V until it achieves the actual shortest-path weight ı.s;􏳪/. The algorithm returns TRUE if and only if the graph contains no negative-weight cycles that are reachable from the source.
BELLMAN-FORD.G; w; s/
1 2 3 4 5 6 7 8
INITIALIZE-SINGLE-SOURCE.G;s/ foriD1tojG:Vj􏳣1
for each edge .u; 􏳪/ 2 G:E RELAX.u; 􏳪; w/
for each edge .u; 􏳪/ 2 G:E if 􏳪:d > u:d C w.u; 􏳪/
return FALSE return TRUE
Figure 24.4 shows the execution of the Bellman-Ford algorithm on a graph with 5 vertices. After initializing the d and 􏳬 values of all vertices in line 1, the algorithm makes jV j 􏳣 1 passes over the edges of the graph. Each pass is one iteration of the for loop of lines 2–4 and consists of relaxing each edge of the graph once. Figures 24.4(b)–(e) show the state of the algorithm after each of the four passes over the edges. After making jV j 􏳣 1 passes, lines 5–8 check for a negative-weight cycle and return the appropriate boolean value. (We’ll see a little later why this check works.)
The Bellman-Ford algorithm runs in time O.VE/, since the initialization in line 1 takes ‚.V / time, each of the jV j 􏳣 1 passes over the edges in lines 2–4 takes ‚.E/ time, and the for loop of lines 5–7 takes O.E/ time.
To prove the correctness of the Bellman-Ford algorithm, we start by showing that if there are no negative-weight cycles, the algorithm computes correct shortest-path weights for all vertices reachable from the source.

652 Chapter 24 Single-Source Shortest Paths
t5x t5x t5x 6 ∞ –2 ∞ 6 6 –2 ∞ 6 6 –2 4
–3 –3 –3 s0 8 –47 s0 8 –47 s0 8 –47
727272 ∞9∞ 79∞ 792
yzyzyz
(a) (b) (c)
t5x t5x 6 2 –2 4 6 2 –2 4
–3
s0 8 –47 s0 8 –47
72 72
7 9 2 7 9 –2
yz yz
(d) (e)
Figure 24.4 The execution of the Bellman-Ford algorithm. The source is vertex s. The d val- ues appear within the vertices, and shaded edges indicate predecessor values: if edge .u;􏳪/ is shaded, then 􏳪:􏳬 D u. In this particular example, each pass relaxes the edges in the order .t;x/;.t;y/;.t; ́/;.x;t/;.y;x/;.y; ́/;. ́;x/;. ́;s/;.s;t/;.s;y/. (a) The situation just before the first pass over the edges. (b)–(e) The situation after each successive pass over the edges. The d and 􏳬 values in part (e) are the final values. The Bellman-Ford algorithm returns TRUE in this example.
Lemma 24.2
Let G D .V;E/ be a weighted, directed graph with source s and weight func- tion w W E ! R, and assume that G contains no negative-weight cycles that are reachable from s. Then, after the jV j 􏳣 1 iterations of the for loop of lines 2–4 of BELLMAN-FORD, we have 􏳪:d D ı.s;􏳪/ for all vertices 􏳪 that are reachable from s.
Proof We prove the lemma by appealing to the path-relaxation property. Con- sider any vertex 􏳪 that is reachable from s, and let p D h􏳪0; 􏳪1; :::; 􏳪ki, where 􏳪0 D s and 􏳪k D 􏳪, be any shortest path from s to 􏳪. Because shortest paths are simple, p has at most jV j 􏳣 1 edges, and so k 􏳥 jV j 􏳣 1. Each of the jV j 􏳣 1 itera- tions of the for loop of lines 2–4 relaxes all jEj edges. Among the edges relaxed in the ith iteration, for i D 1;2;:::;k, is .􏳪i􏳣1;􏳪i/. By the path-relaxation property, therefore, 􏳪:d D 􏳪k:d D ı.s;􏳪k/ D ı.s;􏳪/.
–3

24.1 The Bellman-Ford algorithm 653
Corollary 24.3
Let G D .V;E/ be a weighted, directed graph with source vertex s and weight function w W E ! R, and assume that G contains no negative-weight cycles that are reachable from s. Then, for each vertex 􏳪 2 V , there is a path from s to 􏳪 if and only if BELLMAN-FORD terminates with 􏳪:d < 1 when it is run on G. Proof The proof is left as Exercise 24.1-2. Theorem 24.4 (Correctness of the Bellman-Ford algorithm) Let BELLMAN-FORD be run on a weighted, directed graph G D .V;E/ with source s and weight function w W E ! R. If G contains no negative-weight cycles that are reachable from s, then the algorithm returns TRUE, we have 􏳪:d D ı.s;􏳪/ for all vertices 􏳪 2 V , and the predecessor subgraph G􏳬 is a shortest-paths tree rooted at s. If G does contain a negative-weight cycle reachable from s, then the algorithm returns FALSE. Proof Suppose that graph G contains no negative-weight cycles that are reach- able from the source s. We first prove the claim that at termination, 􏳪:d D ı.s;􏳪/ for all vertices 􏳪 2 V . If vertex 􏳪 is reachable from s, then Lemma 24.2 proves this claim. If 􏳪 is not reachable from s, then the claim follows from the no-path prop- erty. Thus, the claim is proven. The predecessor-subgraph property, along with the claim, implies that G􏳬 is a shortest-paths tree. Now we use the claim to show that BELLMAN-FORD returns TRUE. At termination, we have for all edges .u;􏳪/ 2 E, 􏳪:d D ı.s;􏳪/ 􏳥 ı.s; u/ C w.u; 􏳪/ (by the triangle inequality) D u:dCw.u;􏳪/; and so none of the tests in line 6 causes BELLMAN-FORD to return FALSE. There- fore, it returns TRUE. Now, suppose that graph G contains a negative-weight cycle that is reachable from the source s; let this cycle be c D h􏳪0;􏳪1;:::;􏳪ki, where 􏳪0 D 􏳪k. Then, Xk w.􏳪i􏳣1;􏳪i/ < 0 : (24.1) iD1 Assume for the purpose of contradiction that the Bellman-Ford algorithm returns TRUE. Thus, 􏳪i:d 􏳥 􏳪i􏳣1:d C w.􏳪i􏳣1;􏳪i/ for i D 1;2;:::;k. Summing the inequalities around cycle c gives us 654 Chapter 24 Single-Source Shortest Paths Xk iD1 􏳪i:d 􏳥 D Xk iD1 Xk iD1 .􏳪i􏳣1:dCw.􏳪i􏳣1;􏳪i// Xk Xk 􏳪i􏳣1:d C Xk iD1 w.􏳪i􏳣1;􏳪i/ : Since 􏳪0 D 􏳪k, each vertex in c appears exactly once in each of the summations PkiD1 􏳪i:d and PkiD1 􏳪i􏳣1:d, and so 􏳪i:d D Moreover, by Corollary 24.3, 􏳪i :d is finite for i D 1; 2; : : : ; k. Thus, Xk iD1 which contradicts inequality (24.1). We conclude that the Bellman-Ford algorithm returns TRUE if graph G contains no negative-weight cycles reachable from the source, and FALSE otherwise. Exercises 24.1-1 Run the Bellman-Ford algorithm on the directed graph of Figure 24.4, using ver- tex ́ as the source. In each pass, relax edges in the same order as in the figure, and show the d and 􏳬 values after each pass. Now, change the weight of edge . ́;x/ to 4 and run the algorithm again, using s as the source. 24.1-2 Prove Corollary 24.3. 24.1-3 Given a weighted, directed graph G D .V;E/ with no negative-weight cycles, let m be the maximum over all vertices 􏳪 2 V of the minimum number of edges in a shortest path from the source s to 􏳪. (Here, the shortest path is by weight, not the number of edges.) Suggest a simple change to the Bellman-Ford algorithm that allows it to terminate in m C 1 passes, even if m is not known in advance. 24.1-4 Modify the Bellman-Ford algorithm so that it sets 􏳪:d to 􏳣1 for all vertices 􏳪 for which there is a negative-weight cycle on some path from the source to 􏳪. iD1 0 􏳥 iD1 w.􏳪i􏳣1;􏳪i/ ; 􏳪i􏳣1:d : 24.2 Single-source shortest paths in directed acyclic graphs 655 24.1-5 ? Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R. Give an O.VE/-time algorithm to find, for each vertex 􏳪 2 V , the value ı􏳤.􏳪/ D minu2V fı.u;􏳪/g. 24.1-6 ? Suppose that a weighted, directed graph G D .V; E/ has a negative-weight cycle. Give an efficient algorithm to list the vertices of one such cycle. Prove that your algorithm is correct. 24.2 Single-source shortest paths in directed acyclic graphs By relaxing the edges of a weighted dag (directed acyclic graph) G D .V;E/ according to a topological sort of its vertices, we can compute shortest paths from a single source in ‚.V C E/ time. Shortest paths are always well defined in a dag, since even if there are negative-weight edges, no negative-weight cycles can exist. The algorithm starts by topologically sorting the dag (see Section 22.4) to im- pose a linear ordering on the vertices. If the dag contains a path from vertex u to vertex 􏳪, then u precedes 􏳪 in the topological sort. We make just one pass over the vertices in the topologically sorted order. As we process each vertex, we relax each edge that leaves the vertex. DAG-SHORTEST-PATHS .G; w; s/ 1 2 3 4 5 topologically sort the vertices of G INITIALIZE-SINGLE-SOURCE.G;s/ for each vertex u, taken in topologically sorted order for each vertex 􏳪 2 G:AdjŒu􏳩 RELAX.u; 􏳪; w/ Figure 24.5 shows the execution of this algorithm. The running time of this algorithm is easy to analyze. As shown in Section 22.4, the topological sort of line 1 takes ‚.V C E/ time. The call of INITIALIZE- SINGLE-SOURCE in line 2 takes ‚.V / time. The for loop of lines 3–5 makes one iteration per vertex. Altogether, the for loop of lines 4–5 relaxes each edge exactly once. (We have used an aggregate analysis here.) Because each iteration of the inner for loop takes ‚.1/ time, the total running time is ‚.V CE/, which is linear in the size of an adjacency-list representation of the graph. The following theorem shows that the DAG-SHORTEST-PATHS procedure cor- rectly computes the shortest paths. 656 Chapter 24 Single-Source Shortest Paths 61 61 r 5 s 2 t 7 x –1 y –2 z r 5 s 2 t 7 x –1 y –2 z ∞0∞∞∞∞ ∞0∞∞∞∞ 342342 (a) (b) 61 61 rstxyz rstxyz 5 2 7 –1 –2 5 2 7 –1 –2 ∞026∞∞ ∞02664 342342 (c) (d) 61 61 rstxyz rstxyz 5 2 7 –1 –2 5 2 7 –1 –2 ∞02654 ∞02653 342342 (e) (f) 61 rstxyz 5 2 7 –1 –2 ∞02653 342 (g) Figure 24.5 The execution of the algorithm for shortest paths in a directed acyclic graph. The vertices are topologically sorted from left to right. The source vertex is s. The d values appear within the vertices, and shaded edges indicate the 􏳬 values. (a) The situation before the first iteration of the for loop of lines 3–5. (b)–(g) The situation after each iteration of the for loop of lines 3–5. The newly blackened vertex in each iteration was used as u in that iteration. The values shown in part (g) are the final values. Theorem 24.5 If a weighted, directed graph G D .V;E/ has source vertex s and no cycles, then at the termination of the DAG-SHORTEST-PATHS procedure, 􏳪:d D ı.s;􏳪/ for all vertices 􏳪 2 V , and the predecessor subgraph G􏳬 is a shortest-paths tree. Proof We first show that 􏳪:d D ı.s;􏳪/ for all vertices 􏳪 2 V at termina- tion. If 􏳪 is not reachable from s, then 􏳪:d D ı.s;􏳪/ D 1 by the no-path property. Now, suppose that 􏳪 is reachable from s, so that there is a short- est path p D h􏳪0;􏳪1;:::;􏳪ki, where 􏳪0 D s and 􏳪k D 􏳪. Because we pro- 24.2 Single-source shortest paths in directed acyclic graphs 657 cess the vertices in topologically sorted order, we relax the edges on p in the order .􏳪0;􏳪1/;.􏳪1;􏳪2/;:::;.􏳪k􏳣1;􏳪k/. The path-relaxation property implies that 􏳪i :d D ı.s; 􏳪i / at termination for i D 0; 1; : : : ; k. Finally, by the predecessor- subgraph property, G􏳬 is a shortest-paths tree. An interesting application of this algorithm arises in determining critical paths in PERT chart2 analysis. Edges represent jobs to be performed, and edge weights represent the times required to perform particular jobs. If edge .u;􏳪/ enters ver- tex 􏳪 and edge .􏳪; x/ leaves 􏳪, then job .u; 􏳪/ must be performed before job .􏳪; x/. A path through this dag represents a sequence of jobs that must be performed in a particular order. A critical path is a longest path through the dag, corresponding to the longest time to perform any sequence of jobs. Thus, the weight of a critical path provides a lower bound on the total time to perform all the jobs. We can find a critical path by either negating the edge weights and running DAG-SHORTEST-PATHS, or running DAG-SHORTEST-PATHS, with the modification that we replace “1” by “􏳣1” in line 2 of INITIALIZE-SINGLE-SOURCE and “>” by “<” in the RELAX procedure. Exercises 24.2-1 Run DAG-SHORTEST-PATHS on the directed graph of Figure 24.5, using vertex r as the source. 24.2-2 Suppose we change line 3 of DAG-SHORTEST-PATHS to read 3 for the first jV j 􏳣 1 vertices, taken in topologically sorted order Show that the procedure would remain correct. 24.2-3 The PERT chart formulation given above is somewhat unnatural. In a more natu- ral structure, vertices would represent jobs and edges would represent sequencing constraints; that is, edge .u; 􏳪/ would indicate that job u must be performed before job 􏳪. We would then assign weights to vertices, not edges. Modify the DAG- SHORTEST-PATHS procedure so that it finds a longest path in a directed acyclic graph with weighted vertices in linear time. 􏳮 􏳮 2“PERT” is an acronym for “program evaluation and review technique.” 658 Chapter 24 Single-Source Shortest Paths 24.3 24.2-4 Give an efficient algorithm to count the total number of paths in a directed acyclic graph. Analyze your algorithm. Dijkstra’s algorithm Dijkstra’s algorithm solves the single-source shortest-paths problem on a weighted, directed graph G D .V; E/ for the case in which all edge weights are nonnegative. In this section, therefore, we assume that w.u; 􏳪/ 􏳦 0 for each edge .u; 􏳪/ 2 E. As we shall see, with a good implementation, the running time of Dijkstra’s algorithm is lower than that of the Bellman-Ford algorithm. Dijkstra’s algorithm maintains a set S of vertices whose final shortest-path weights from the source s have already been determined. The algorithm repeat- edly selects the vertex u 2 V 􏳣 S with the minimum shortest-path estimate, adds u to S, and relaxes all edges leaving u. In the following implementation, we use a min-priority queue Q of vertices, keyed by their d values. DIJKSTRA.G;w;s/ 1 INITIALIZE-SINGLE-SOURCE.G;s/ 2SD; 3 4 5 6 7 8 QDG:V whileQ¤; u D EXTRACT-MIN.Q/ S D S [ fug for each vertex 􏳪 2 G:AdjŒu􏳩 RELAX.u; 􏳪; w/ Dijkstra’s algorithm relaxes edges as shown in Figure 24.6. Line 1 initializes the d and 􏳬 values in the usual way, and line 2 initializes the set S to the empty set. The algorithm maintains the invariant that Q D V 􏳣 S at the start of each iteration of the while loop of lines 4–8. Line 3 initializes the min-priority queue Q to contain all the vertices in V ; since S D ; at that time, the invariant is true after line 3. Each time through the while loop of lines 4–8, line 5 extracts a vertex u from Q D V 􏳣 S and line 6 adds it to set S , thereby maintaining the invariant. (The first time through this loop, u D s.) Vertex u, therefore, has the smallest shortest-path estimate of any vertex in V 􏳣 S. Then, lines 7–8 relax each edge .u; 􏳪/ leaving u, thus updating the estimate 􏳪:d and the predecessor 􏳪:􏳬 if we can improve the shortest path to 􏳪 found so far by going through u. Observe that the algorithm never inserts vertices into Q after line 3 and that each vertex is extracted from Q 24.3 Dijkstra’s algorithm 659 t1x t1x t1x 10∞ ∞ 1010 ∞ 108 14 s0 23946 s0 23946 s0 23946 575757 ∞2∞ 52∞ 527 yzyzyz (a) (b) (c) t1x t1x t1x 8 13 8 9 8 9 10 10 10 s0 23946 s0 23946 s0 23946 575757 575757 y2z y2z y2z (d) (e) (f) Figure 24.6 The execution of Dijkstra’s algorithm. The source s is the leftmost vertex. The shortest-path estimates appear within the vertices, and shaded edges indicate predecessor values. Black vertices are in the set S , and white vertices are in the min-priority queue Q D V 􏳣 S . (a) The situation just before the first iteration of the while loop of lines 4–8. The shaded vertex has the mini- mum d value and is chosen as vertex u in line 5. (b)–(f) The situation after each successive iteration of the while loop. The shaded vertex in each part is chosen as vertex u in line 5 of the next iteration. The d values and predecessors shown in part (f) are the final values. and added to S exactly once, so that the while loop of lines 4–8 iterates exactly jV j times. Because Dijkstra’s algorithm always chooses the “lightest” or “closest” vertex in V 􏳣 S to add to set S , we say that it uses a greedy strategy. Chapter 16 explains greedy strategies in detail, but you need not have read that chapter to understand Dijkstra’s algorithm. Greedy strategies do not always yield optimal results in gen- eral, but as the following theorem and its corollary show, Dijkstra’s algorithm does indeed compute shortest paths. The key is to show that each time it adds a vertex u to set S, we have u:d D ı.s;u/. Theorem 24.6 (Correctness of Dijkstra’s algorithm) Dijkstra’s algorithm, run on a weighted, directed graph G D .V;E/ with non- negative weight function w and source s, terminates with u:d D ı.s;u/ for all vertices u 2 V . 660 Chapter 24 Single-Source Shortest Paths S s p1 x Figure 24.7 The proof of Theorem 24.6. Set S is nonempty just before vertex u is added to it. We p1 p2 p2 y u decompose a shortest path p from source s to vertex u into s Y x ! y Y u, where y is the first vertex on the path that is not in S and x 2 S immediately precedes y. Vertices x and y are distinct, but we may have s D x or y D u. Path p2 may or may not reenter set S. Proof We use the following loop invariant: At the start of each iteration of the while loop of lines 4–8, 􏳪:d D ı.s;􏳪/ for each vertex 􏳪 2 S. It suffices to show for each vertex u 2 V , we have u: d D ı.s; u/ at the time when u is added to set S. Once we show that u:d D ı.s;u/, we rely on the upper-bound property to show that the equality holds at all times thereafter. Initialization: Initially, S D ;, and so the invariant is trivially true. Maintenance: Wewishtoshowthatineachiteration,u:dDı.s;u/forthevertex added to set S. For the purpose of contradiction, let u be the first vertex for which u:d ¤ ı.s;u/ when it is added to set S. We shall focus our attention on the situation at the beginning of the iteration of the while loop in which u is added to S and derive the contradiction that u:d D ı.s;u/ at that time by examining a shortest path from s to u. We must have u ¤ s because s is the first vertex added to set S and s:d D ı.s;s/ D 0 at that time. Because u ¤ s, we also have that S ¤ ; just before u is added to S. There must be some path from s to u, for otherwise u:d D ı.s;u/ D 1 by the no-path property, which would violate our assumption that u:d ¤ ı.s;u/. Because there is at least one path, there is a shortest path p from s to u. Prior to adding u to S, path p connects a vertex in S, namely s, to a vertex in V 􏳣 S, namely u. Let us consider the first vertex y along p such that y 2 V 􏳣 S, and let x 2 S be y’s predecessor along p. Thus, as Figure 24.7 illustrates, we can decompose path p p1 p2 intosYx!yYu.(Eitherofpathsp1 orp2 mayhavenoedges.) We claim that y:d D ı.s;y/ when u is added to S. To prove this claim, ob- serve that x 2 S. Then, because we chose u as the first vertex for which u:d ¤ ı.s;u/ when it is added to S, we had x:d D ı.s;x/ when x was added 24.3 Dijkstra’s algorithm 661 to S. Edge .x;y/ was relaxed at that time, and the claim follows from the convergence property. We can now obtain a contradiction to prove that u:d D ı.s;u/. Because y appears before u on a shortest path from s to u and all edge weights are non- negative (notably those on path p2), we have ı.s; y/ 􏳥 ı.s; u/, and thus y:d D ı.s;y/ 􏳥 ı.s; u/ (24.2) 􏳥 u:d (by the upper-bound property) . But because both vertices u and y were in V 􏳣 S when u was chosen in line 5, we have u:d 􏳥 y:d. Thus, the two inequalities in (24.2) are in fact equalities, giving y:d D ı.s;y/ D ı.s;u/ D u:d : Consequently, u:d D ı.s;u/, which contradicts our choice of u. We conclude that u: d D ı.s; u/ when u is added to S , and that this equality is maintained at all times thereafter. Termination: At termination, Q D ; which, along with our earlier invariant that Q D V 􏳣 S , implies that S D V . Thus, u: d D ı.s; u/ for all vertices u 2 V . Corollary 24.7 If we run Dijkstra’s algorithm on a weighted, directed graph G D .V;E/ with nonnegative weight function w and source s, then at termination, the predecessor subgraph G􏳬 is a shortest-paths tree rooted at s. Proof Immediate from Theorem 24.6 and the predecessor-subgraph property. Analysis How fast is Dijkstra’s algorithm? It maintains the min-priority queue Q by call- ing three priority-queue operations: INSERT (implicit in line 3), EXTRACT-MIN (line 5), and DECREASE-KEY (implicit in RELAX, which is called in line 8). The algorithm calls both INSERT and EXTRACT-MIN once per vertex. Because each vertex u 2 V is added to set S exactly once, each edge in the adjacency list AdjŒu􏳩 is examined in the for loop of lines 7–8 exactly once during the course of the al- gorithm. Since the total number of edges in all the adjacency lists is jEj, this for loop iterates a total of jEj times, and thus the algorithm calls DECREASE-KEY at most jEj times overall. (Observe once again that we are using aggregate analysis.) The running time of Dijkstra’s algorithm depends on how we implement the min-priority queue. Consider first the case in which we maintain the min-priority 662 Chapter 24 Single-Source Shortest Paths queue by taking advantage of the vertices being numbered 1 to jV j. We simply store 􏳪:d in the 􏳪th entry of an array. Each INSERT and DECREASE-KEY operation takes O.1/ time, and each EXTRACT-MIN operation takes O.V / time (since we have to search through the entire array), for a total time of O.V 2 C E/ D O.V 2/. If the graph is sufficiently sparse—in particular, E D o.V 2= lg V /—we can improve the algorithm by implementing the min-priority queue with a binary min- heap. (As discussed in Section 6.5, the implementation should make sure that vertices and corresponding heap elements maintain handles to each other.) Each EXTRACT-MIN operation then takes time O.lg V /. As before, there are jV j such operations. The time to build the binary min-heap is O.V /. Each DECREASE-KEY operation takes time O.lg V /, and there are still at most jEj such operations. The total running time is therefore O..V C E/ lg V /, which is O.E lg V / if all vertices are reachable from the source. This running time improves upon the straightfor- ward O.V 2/-time implementation if E D o.V 2= lg V /. We can in fact achieve a running time of O.V lg V C E/ by implementing the min-priority queue with a Fibonacci heap (see Chapter 19). The amortized cost of each of the jV j EXTRACT-MIN operations is O.lg V /, and each DECREASE- KEY call, of which there are at most jEj, takes only O.1/ amortized time. His- torically, the development of Fibonacci heaps was motivated by the observation that Dijkstra’s algorithm typically makes many more DECREASE-KEY calls than EXTRACT-MIN calls, so that any method of reducing the amortized time of each DECREASE-KEY operation to o.lg V / without increasing the amortized time of EXTRACT-MIN would yield an asymptotically faster implementation than with bi- nary heaps. Dijkstra’s algorithm resembles both breadth-first search (see Section 22.2) and Prim’s algorithm for computing minimum spanning trees (see Section 23.2). It is like breadth-first search in that set S corresponds to the set of black vertices in a breadth-first search; just as vertices in S have their final shortest-path weights, so do black vertices in a breadth-first search have their correct breadth-first distances. Dijkstra’s algorithm is like Prim’s algorithm in that both algorithms use a min- priority queue to find the “lightest” vertex outside a given set (the set S in Dijkstra’s algorithm and the tree being grown in Prim’s algorithm), add this vertex into the set, and adjust the weights of the remaining vertices outside the set accordingly. Exercises 24.3-1 Run Dijkstra’s algorithm on the directed graph of Figure 24.2, first using vertex s as the source and then using vertex ́ as the source. In the style of Figure 24.6, show the d and 􏳬 values and the vertices in set S after each iteration of the while loop. 24.3 Dijkstra’s algorithm 663 24.3-2 Give a simple example of a directed graph with negative-weight edges for which Dijkstra’s algorithm produces incorrect answers. Why doesn’t the proof of Theo- rem 24.6 go through when negative-weight edges are allowed? 24.3-3 Suppose we change line 4 of Dijkstra’s algorithm to the following. 4 while jQj > 1
This change causes the while loop to execute jV j 􏳣 1 times instead of jV j times. Is this proposed algorithm correct?
24.3-4
Professor Gaedel has written a program that he claims implements Dijkstra’s al- gorithm. The program produces 􏳪:d and 􏳪:􏳬 for each vertex 􏳪 2 V . Give an O.V CE/-time algorithm to check the output of the professor’s program. It should determine whether the d and 􏳬 attributes match those of some shortest-paths tree. You may assume that all edge weights are nonnegative.
24.3-5
Professor Newman thinks that he has worked out a simpler proof of correctness for Dijkstra’s algorithm. He claims that Dijkstra’s algorithm relaxes the edges of every shortest path in the graph in the order in which they appear on the path, and therefore the path-relaxation property applies to every vertex reachable from the source. Show that the professor is mistaken by constructing a directed graph for which Dijkstra’s algorithm could relax the edges of a shortest path out of order.
24.3-6
We are given a directed graph G D .V; E/ on which each edge .u; 􏳪/ 2 E has an associated value r.u;􏳪/, which is a real number in the range 0 􏳥 r.u;􏳪/ 􏳥 1 that represents the reliability of a communication channel from vertex u to vertex 􏳪. We interpret r.u;􏳪/ as the probability that the channel from u to 􏳪 will not fail, and we assume that these probabilities are independent. Give an efficient algorithm to find the most reliable path between two given vertices.
24.3-7
Let G D .V;E/ be a weighted, directed graph with positive weight function w W E ! f1; 2; : : : ; W g for some positive integer W , and assume that no two ver- tices have the same shortest-path weights from source vertex s. Now suppose that we define an unweighted, directed graph G0 D .V [ V 0; E0/ by replacing each edge .u; 􏳪/ 2 E with w.u; 􏳪/ unit-weight edges in series. How many vertices does G0 have? Now suppose that we run a breadth-first search on G0. Show that

664 Chapter 24 Single-Source Shortest Paths
the order in which the breadth-first search of G0 colors vertices in V black is the same as the order in which Dijkstra’s algorithm extracts the vertices of V from the priority queue when it runs on G.
24.3-8
Let G D .V;E/ be a weighted, directed graph with nonnegative weight function w W E ! f0; 1; : : : ; W g for some nonnegative integer W . Modify Dijkstra’s algo- rithm to compute the shortest paths from a given source vertex s in O.W V C E/ time.
24.3-9
Modify your algorithm from Exercise 24.3-8 to run in O..V C E/ lg W / time. (Hint: How many distinct shortest-path estimates can there be in V 􏳣 S at any point in time?)
24.3-10
Suppose that we are given a weighted, directed graph G D .V; E/ in which edges that leave the source vertex s may have negative weights, all other edge weights are nonnegative, and there are no negative-weight cycles. Argue that Dijkstra’s algorithm correctly finds shortest paths from s in this graph.
24.4 Difference constraints and shortest paths
Chapter 29 studies the general linear-programming problem, in which we wish to optimize a linear function subject to a set of linear inequalities. In this section, we investigate a special case of linear programming that we reduce to finding shortest paths from a single source. We can then solve the single-source shortest-paths problem that results by running the Bellman-Ford algorithm, thereby also solving the linear-programming problem.
Linear programming
In the general linear-programming problem, we are given an m 􏳨 n matrix A, an m-vector b, and an n-vector c. We wish to find a vector x of n elements that maximizestheobjectivefunctionPniD1cixi subjecttothemconstraintsgivenby Ax 􏳥 b.
Although the simplex algorithm, which is the focus of Chapter 29, does not always run in time polynomial in the size of its input, there are other linear- programming algorithms that do run in polynomial time. We offer here two reasons to understand the setup of linear-programming problems. First, if we know that we

24.4 Difference constraints and shortest paths 665
can cast a given problem as a polynomial-sized linear-programming problem, then we immediately have a polynomial-time algorithm to solve the problem. Second, faster algorithms exist for many special cases of linear programming. For exam- ple, the single-pair shortest-path problem (Exercise 24.4-4) and the maximum-flow problem (Exercise 26.1-5) are special cases of linear programming.
Sometimes we don’t really care about the objective function; we just wish to find any feasible solution, that is, any vector x that satisfies Ax 􏳥 b, or to determine that no feasible solution exists. We shall focus on one such feasibility problem.
Systems of difference constraints
In a system of difference constraints, each row of the linear-programming matrix A contains one 1 and one 􏳣1, and all other entries of A are 0. Thus, the constraints given by Ax 􏳥 b are a set of m difference constraints involving n unknowns, in which each constraint is a simple linear inequality of the form
xj 􏳣 xi 􏳥 bk ;
􏳼 ̆􏳼 ̆
where 1 􏳥 i; j 􏳥 n, i ¤ j , and 1 􏳥 k 􏳥 m.
For example, consider the problem of finding a 5-vector x D .xi / that satisfies
1 􏳣1 0 0 0 ˇ 􏳢 0 1000􏳣1x 􏳣1
0100􏳣11
1 5
􏳥 4 :
􏳣1 􏳣3 􏳣3
􏳣10100 􏳣1 0 0 1 0 00􏳣110 00􏳣101 000􏳣11
x2 x3 x4 x5
This problem is equivalent to finding values for the unknowns x1;x2;x3;x4;x5, satisfying the following 8 difference constraints:
x1􏳣x2 􏳥 x1􏳣x5 􏳥 x2􏳣x5 􏳥 x3􏳣x1 􏳥 x4􏳣x1 􏳥 x4􏳣x3 􏳥
x5􏳣x3 􏳥
x5􏳣x4 􏳥
0, 􏳣1 , 1, 5, 4, 􏳣1 , 􏳣3 , 􏳣3 .
(24.3) (24.4) (24.5) (24.6) (24.7) (24.8) (24.9)
(24.10)

666 Chapter 24 Single-Source Shortest Paths
One solution to this problem is x D .􏳣5; 􏳣3; 0; 􏳣1; 􏳣4/, which you can verify di- rectly by checking each inequality. In fact, this problem has more than one solution. Another is x0 D .0; 2; 5; 4; 1/. These two solutions are related: each component of x0 is 5 larger than the corresponding component of x. This fact is not mere coincidence.
Lemma 24.8
Let x D .x1;x2;:::;xn/ be a solution to a system Ax 􏳥 b of difference con- straints, and let d be any constant. Then x C d D .x1 C d;x2 C d;:::;xn C d/ is a solution to Ax 􏳥 b as well.
Proof Foreachxi andxj,wehave.xj Cd/􏳣.xi Cd/Dxj 􏳣xi. Thus,ifx satisfies Ax 􏳥 b, so does x C d.
Systems of difference constraints occur in many different applications. For ex- ample, the unknowns xi may be times at which events are to occur. Each constraint states that at least a certain amount of time, or at most a certain amount of time, must elapse between two events. Perhaps the events are jobs to be performed dur- ing the assembly of a product. If we apply an adhesive that takes 2 hours to set at time x1 and we have to wait until it sets to install a part at time x2, then we have the constraint that x2 􏳦 x1 C 2 or, equivalently, that x1 􏳣 x2 􏳥 􏳣2. Alternatively, we might require that the part be installed after the adhesive has been applied but no later than the time that the adhesive has set halfway. In this case, we get the pair of constraints x2 􏳦 x1 and x2 􏳥 x1 C1 or, equivalently, x1 􏳣x2 􏳥 0 and x2 􏳣x1 􏳥 1.
Constraint graphs
We can interpret systems of difference constraints from a graph-theoretic point of view. In a system Ax 􏳥 b of difference constraints, we view the m 􏳨 n linear-programming matrix A as the transpose of an incidence matrix (see Exer- cise 22.1-7) for a graph with n vertices and m edges. Each vertex 􏳪i in the graph, for i D 1;2;:::;n, corresponds to one of the n unknown variables xi. Each di- rected edge in the graph corresponds to one of the m inequalities involving two unknowns.
More formally, given a system Ax 􏳥 b of difference constraints, the correspond- ing constraint graph is a weighted, directed graph G D .V; E/, where
V D f􏳪0;􏳪1;:::;􏳪ng
and
EDf.􏳪i;􏳪j/Wxj 􏳣xi 􏳥bk isaconstraintg [f.􏳪0;􏳪1/;.􏳪0;􏳪2/;.􏳪0;􏳪3/;:::;.􏳪0;􏳪n/g :

24.4 Difference constraints and shortest paths 667
0 v0 0
v2 –3 5
–1 0 v3
0
0
v1 –5
–1 0
v5
–4 1–3
–3
4
0
0
–1 v4
The constraint graph corresponding to the system (24.3)–(24.10) of difference con- straints. The value of ı.􏳪0; 􏳪i / appears in each vertex 􏳪i . One feasible solution to the system is x D .􏳣5; 􏳣3; 0; 􏳣1; 􏳣4/.
The constraint graph contains the additional vertex 􏳪0, as we shall see shortly, to guarantee that the graph has some vertex which can reach all other vertices. Thus, the vertex set V consists of a vertex 􏳪i for each unknown xi , plus an additional vertex 􏳪0. The edge set E contains an edge for each difference constraint, plus an edge .􏳪0; 􏳪i / for each unknown xi . If xj 􏳣 xi 􏳥 bk is a difference constraint, then the weight of edge .􏳪i;􏳪j / is w.􏳪i;􏳪j / D bk. The weight of each edge leav- ing 􏳪0 is 0. Figure 24.8 shows the constraint graph for the system (24.3)–(24.10) of difference constraints.
The following theorem shows that we can find a solution to a system of differ- ence constraints by finding shortest-path weights in the corresponding constraint graph.
Theorem 24.9
Given a system Ax 􏳥 b of difference constraints, let G D .V;E/ be the corre- sponding constraint graph. If G contains no negative-weight cycles, then
x D .ı.􏳪0; 􏳪1/; ı.􏳪0; 􏳪2/; ı.􏳪0; 􏳪3/; : : : ; ı.􏳪0; 􏳪n// (24.11) is a feasible solution for the system. If G contains a negative-weight cycle, then
there is no feasible solution for the system.
Proof We first show that if the constraint graph contains no negative-weight cycles, then equation (24.11) gives a feasible solution. Consider any edge .􏳪i;􏳪j/2E. By the triangle inequality, ı.􏳪0;􏳪j/ 􏳥 ı.􏳪0;􏳪i/ C w.􏳪i;􏳪j/ or, equivalently, ı.􏳪0; 􏳪j / 􏳣 ı.􏳪0; 􏳪i / 􏳥 w.􏳪i ; 􏳪j /. Thus, letting xi D ı.􏳪0; 􏳪i / and
Figure 24.8

668 Chapter 24 Single-Source Shortest Paths
xj D ı.􏳪0; 􏳪j / satisfies the difference constraint xj 􏳣 xi 􏳥 w.􏳪i ; 􏳪j / that corre- sponds to edge .􏳪i ; 􏳪j /.
Now we show that if the constraint graph contains a negative-weight cycle, then the system of difference constraints has no feasible solution. Without loss of gen- erality, let the negative-weight cycle be c D h􏳪1; 􏳪2; :::; 􏳪ki, where 􏳪1 D 􏳪k. (The vertex 􏳪0 cannot be on cycle c, because it has no entering edges.) Cycle c corresponds to the following difference constraints:
x2􏳣x1 􏳥 x3􏳣x2 􏳥
: xk􏳣1 􏳣 xk􏳣2 􏳥
xk 􏳣xk􏳣1 􏳥
w.􏳪1;􏳪2/; w.􏳪2;􏳪3/;
w.􏳪k􏳣2;􏳪k􏳣1/; w.􏳪k􏳣1;􏳪k/:
We will assume that x has a solution satisfying each of these k inequalities and then derive a contradiction. The solution must also satisfy the inequality that results when we sum the k inequalities together. If we sum the left-hand sides, each unknown xi is added in once and subtracted out once (remember that 􏳪1 D 􏳪k implies x1 D xk), so that the left-hand side of the sum is 0. The right-hand side sums to w.c/, and thus we obtain 0 􏳥 w.c/. But since c is a negative-weight cycle, w.c/ < 0, and we obtain the contradiction that 0 􏳥 w.c/ < 0. Solving systems of difference constraints Theorem 24.9 tells us that we can use the Bellman-Ford algorithm to solve a system of difference constraints. Because the constraint graph contains edges from the source vertex 􏳪0 to all other vertices, any negative-weight cycle in the constraint graph is reachable from 􏳪0. If the Bellman-Ford algorithm returns TRUE, then the shortest-path weights give a feasible solution to the system. In Figure 24.8, for example, the shortest-path weights provide the feasible solution x D .􏳣5;􏳣3;0;􏳣1;􏳣4/, and by Lemma 24.8, x D .d 􏳣5;d 􏳣3;d;d 􏳣1;d 􏳣4/ is also a feasible solution for any constant d . If the Bellman-Ford algorithm returns FALSE, there is no feasible solution to the system of difference constraints. A system of difference constraints with m constraints on n unknowns produces a graph with n C 1 vertices and n C m edges. Thus, using the Bellman-Ford algorithm, we can solve the system in O..n C 1/.n C m// D O.n2 C nm/ time. Exercise 24.4-5 asks you to modify the algorithm to run in O.nm/ time, even if m is much less than n. 24.4 Difference constraints and shortest paths 669 Exercises 24.4-1 Find a feasible solution or determine that no feasible solution exists for the follow- ing system of difference constraints: x1􏳣x2 􏳥1, x1􏳣x4 􏳥􏳣4, x2􏳣x3 􏳥 2, x2􏳣x5 􏳥 7, x2􏳣x6 􏳥 5, x3􏳣x6 􏳥 10, x4􏳣x2 􏳥 2, x5􏳣x1 􏳥􏳣1, x5􏳣x4 􏳥3, x6􏳣x3 􏳥􏳣8. 24.4-2 Find a feasible solution or determine that no feasible solution exists for the follow- ing system of difference constraints: x1􏳣x2 􏳥4, x1􏳣x5 􏳥5, x2􏳣x4 􏳥􏳣6, x3􏳣x2 􏳥 1, x4􏳣x1 􏳥 3, x4􏳣x3 􏳥 5, x4􏳣x5 􏳥 10, x5􏳣x3 􏳥􏳣4, x5􏳣x4 􏳥􏳣8. 24.4-3 Can any shortest-path weight from the new vertex 􏳪0 in a constraint graph be posi- tive? Explain. 24.4-4 Express the single-pair shortest-path problem as a linear program. 670 Chapter 24 Single-Source Shortest Paths 24.4-5 Show how to modify the Bellman-Ford algorithm slightly so that when we use it to solve a system of difference constraints with m inequalities on n unknowns, the running time is O.nm/. 24.4-6 Suppose that in addition to a system of difference constraints, we want to handle equality constraints of the form xi D xj C bk . Show how to adapt the Bellman- Ford algorithm to solve this variety of constraint system. 24.4-7 Show how to solve a system of difference constraints by a Bellman-Ford-like algo- rithm that runs on a constraint graph without the extra vertex 􏳪0. 24.4-8 ? Let Ax 􏳥 b be a system of m difference constraints in n unknowns. Show that the Bellman-Ford algorithm, when run on the corresponding constraint graph, maxi- mizesPniD1xi subjecttoAx􏳥bandxi 􏳥0forallxi. 24.4-9 ? Show that the Bellman-Ford algorithm, when run on the constraint graph for a sys- tem Ax 􏳥 b of difference constraints, minimizes the quantity .max fxi g􏳣min fxi g/ subject to Ax 􏳥 b. Explain how this fact might come in handy if the algorithm is used to schedule construction jobs. 24.4-10 Suppose that every row in the matrix A of a linear program Ax 􏳥 b corresponds to adifferenceconstraint,asingle-variableconstraintoftheformxi 􏳥bk,orasingle- variable constraint of the form 􏳣xi 􏳥 bk. Show how to adapt the Bellman-Ford algorithm to solve this variety of constraint system. 24.4-11 Give an efficient algorithm to solve a system Ax 􏳥 b of difference constraints when all of the elements of b are real-valued and all of the unknowns xi must be integers. 24.4-12 ? Give an efficient algorithm to solve a system Ax 􏳥 b of difference constraints when all of the elements of b are real-valued and a specified subset of some, but not necessarily all, of the unknowns xi must be integers. 24.5 Proofs of shortest-paths properties 671 24.5 Proofs of shortest-paths properties Throughout this chapter, our correctness arguments have relied on the triangle inequality, upper-bound property, no-path property, convergence property, path- relaxation property, and predecessor-subgraph property. We stated these properties without proof at the beginning of this chapter. In this section, we prove them. The triangle inequality In studying breadth-first search (Section 22.2), we proved as Lemma 22.1 a sim- ple property of shortest distances in unweighted graphs. The triangle inequality generalizes the property to weighted graphs. Lemma 24.10 (Triangle inequality) Let G D .V;E/ be a weighted, directed graph with weight function w W E ! R and source vertex s. Then, for all edges .u; 􏳪/ 2 E, we have ı.s;􏳪/ 􏳥 ı.s;u/ C w.u;􏳪/ : Proof Suppose that p is a shortest path from source s to vertex 􏳪. Then p has no more weight than any other path from s to 􏳪. Specifically, path p has no more weight than the particular path that takes a shortest path from source s to vertex u and then takes edge .u; 􏳪/. Exercise 24.5-3 asks you to handle the case in which there is no shortest path from s to 􏳪. Effects of relaxation on shortest-path estimates The next group of lemmas describes how shortest-path estimates are affected when we execute a sequence of relaxation steps on the edges of a weighted, directed graph that has been initialized by INITIALIZE-SINGLE-SOURCE. Lemma 24.11 (Upper-bound property) Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R. Let s 2 V be the source vertex, and let the graph be initialized by INITIALIZE- SINGLE-SOURCE.G; s/. Then, 􏳪:d 􏳦 ı.s; 􏳪/ for all 􏳪 2 V , and this invariant is maintained over any sequence of relaxation steps on the edges of G. Moreover, once 􏳪:d achieves its lower bound ı.s;􏳪/, it never changes. 672 Chapter 24 Single-Source Shortest Paths Proof We prove the invariant 􏳪:d 􏳦 ı.s;􏳪/ for all vertices 􏳪 2 V by induction over the number of relaxation steps. For the basis, 􏳪:d 􏳦 ı.s;􏳪/ is certainly true after initialization, since 􏳪:d D 1 implies 􏳪:d 􏳦 ı.s;􏳪/ for all 􏳪 2 V 􏳣 fsg, and since s:d D 0 􏳦 ı.s;s/ (note that ı.s; s/ D 􏳣1 if s is on a negative-weight cycle and 0 otherwise). For the inductive step, consider the relaxation of an edge .u; 􏳪/. By the inductive hypothesis, x:d 􏳦 ı.s;x/ for all x 2 V prior to the relaxation. The only d value that may change is 􏳪:d. If it changes, we have 􏳪:d D u:dCw.u;􏳪/ 􏳦 ı.s; u/ C w.u; 􏳪/ (by the inductive hypothesis) 􏳦 ı.s; 􏳪/ (by the triangle inequality) , and so the invariant is maintained. To see that the value of 􏳪:d never changes once 􏳪:d D ı.s;􏳪/, note that having achieved its lower bound, 􏳪:d cannot decrease because we have just shown that 􏳪:d 􏳦 ı.s;􏳪/, and it cannot increase because relaxation steps do not increase d values. Corollary 24.12 (No-path property) Suppose that in a weighted, directed graph G D .V;E/ with weight function w W E ! R, no path connects a source vertex s 2 V to a given vertex 􏳪 2 V . Then, after the graph is initialized by INITIALIZE-SINGLE-SOURCE.G;s/, we have 􏳪:d D ı.s;􏳪/ D 1, and this equality is maintained as an invariant over any sequence of relaxation steps on the edges of G. Proof By the upper-bound property, we always have 1 D ı.s;􏳪/ 􏳥 􏳪:d, and thus 􏳪:d D 1 D ı.s;􏳪/. Lemma 24.13 Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R, and let .u;􏳪/ 2 E. Then, immediately after relaxing edge .u;􏳪/ by executing RELAX.u;􏳪;w/, we have 􏳪:d 􏳥 u:d C w.u;􏳪/. Proof If, just prior to relaxing edge .u;􏳪/, we have 􏳪:d > u:d C w.u;􏳪/, then 􏳪:d D u:d C w.u;􏳪/ afterward. If, instead, 􏳪:d 􏳥 u:d C w.u;􏳪/ just before the relaxation, then neither u:d nor 􏳪:d changes, and so 􏳪:d 􏳥 u:d C w.u;􏳪/ afterward.
Lemma 24.14 (Convergence property)
Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R, let s 2 V be a source vertex, and let s Y u ! 􏳪 be a shortest path in G for

24.5 Proofs of shortest-paths properties 673
some vertices u; 􏳪 2 V . Suppose that G is initialized by INITIALIZE-SINGLE- SOURCE.G;s/ and then a sequence of relaxation steps that includes the call RELAX.u; 􏳪; w/ is executed on the edges of G. If u:d D ı.s; u/ at any time prior to the call, then 􏳪:d D ı.s;􏳪/ at all times after the call.
Proof By the upper-bound property, if u:d D ı.s;u/ at some point prior to re- laxing edge .u;􏳪/, then this equality holds thereafter. In particular, after relaxing edge .u; 􏳪/, we have
􏳪:d 􏳥 u:dCw.u;􏳪/ (byLemma24.13) D ı.s; u/ C w.u; 􏳪/
D ı.s; 􏳪/ (by Lemma 24.1) .
By the upper-bound property, 􏳪:d 􏳦 ı.s;􏳪/, from which we conclude that
􏳪:d D ı.s;􏳪/, and this equality is maintained thereafter.
Lemma 24.15 (Path-relaxation property)
Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R, and let s 2 V be a source vertex. Consider any shortest path p D h􏳪0;􏳪1;:::;􏳪ki from s D 􏳪0 to 􏳪k. If G is initialized by INITIALIZE-SINGLE-SOURCE.G;s/ and then a sequence of relaxation steps occurs that includes, in order, relaxing the edges .􏳪0;􏳪1/;.􏳪1;􏳪2/;:::;.􏳪k􏳣1;􏳪k/, then 􏳪k:d D ı.s;􏳪k/ after these relaxations and at all times afterward. This property holds no matter what other edge relaxations occur, including relaxations that are intermixed with relaxations of the edges of p.
Proof We show by induction that after the ith edge of path p is relaxed, we have 􏳪i : d D ı.s; 􏳪i /. For the basis, i D 0, and before any edges of p have been relaxed, we have from the initialization that 􏳪0:d D s:d D 0 D ı.s; s/. By the upper-bound property, the value of s:d never changes after initialization.
For the inductive step, we assume that 􏳪i􏳣1:d D ı.s;􏳪i􏳣1/, and we examine what happens when we relax edge .􏳪i􏳣1;􏳪i/. By the convergence property, after relaxing this edge, we have 􏳪i : d D ı.s; 􏳪i /, and this equality is maintained at all times thereafter.
Relaxation and shortest-paths trees
We now show that once a sequence of relaxations has caused the shortest-path es- timates to converge to shortest-path weights, the predecessor subgraph G􏳬 induced by the resulting 􏳬 values is a shortest-paths tree for G. We start with the follow- ing lemma, which shows that the predecessor subgraph always forms a rooted tree whose root is the source.

674 Chapter 24 Single-Source Shortest Paths
Lemma 24.16
Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R, let s 2 V be a source vertex, and assume that G contains no negative-weight cycles that are reachable from s. Then, after the graph is initialized by INITIALIZE- SINGLE-SOURCE.G;s/, the predecessor subgraph G􏳬 forms a rooted tree with root s, and any sequence of relaxation steps on edges of G maintains this property as an invariant.
Proof Initially, the only vertex in G􏳬 is the source vertex, and the lemma is triv- ially true. Consider a predecessor subgraph G􏳬 that arises after a sequence of relaxation steps. We shall first prove that G􏳬 is acyclic. Suppose for the sake of contradiction that some relaxation step creates a cycle in the graph G􏳬 . Let the cy- cle be c D h􏳪0;􏳪1;:::;􏳪ki, where 􏳪k D 􏳪0. Then, 􏳪i:􏳬 D 􏳪i􏳣1 for i D 1;2;:::;k and, without loss of generality, we can assume that relaxing edge .􏳪k􏳣1; 􏳪k / created the cycle in G􏳬 .
We claim that all vertices on cycle c are reachable from the source s. Why? Each vertex on c has a non-NIL predecessor, and so each vertex on c was assigned a finite shortest-path estimate when it was assigned its non-NIL 􏳬 value. By the upper-bound property, each vertex on cycle c has a finite shortest-path weight, which implies that it is reachable from s.
We shall examine the shortest-path estimates on c just prior to the call RELAX.􏳪k􏳣1;􏳪k;w/ and show that c is a negative-weight cycle, thereby contra- dicting the assumption that G contains no negative-weight cycles that are reachable fromthesource.Justbeforethecall,wehave􏳪i:􏳬D􏳪i􏳣1 foriD1;2;:::;k􏳣1. Thus, for i D 1;2;:::;k 􏳣 1, the last update to 􏳪i:d was by the assignment 􏳪i:d D 􏳪i􏳣1:dCw.􏳪i􏳣1;􏳪i/. If􏳪i􏳣1:dchangedsincethen,itdecreased. Therefore, just before the call RELAX.􏳪k􏳣1;􏳪k;w/, we have
􏳪i:d􏳦􏳪i􏳣1:dCw.􏳪i􏳣1;􏳪i/ foralli D1;2;:::;k􏳣1: (24.12) Because 􏳪k:􏳬 is changed by the call, immediately beforehand we also have the
strict inequality
􏳪k:d > 􏳪k􏳣1:d C w.􏳪k􏳣1;􏳪k/ :
Summing this strict inequality with the k 􏳣 1 inequalities (24.12), we obtain the sum of the shortest-path estimates around cycle c:
Xk iD1
􏳪i:d > D
Xk iD1
Xk iD1
.􏳪i􏳣1:dCw.􏳪i􏳣1;􏳪i// Xk
􏳪i􏳣1:d C
w.􏳪i􏳣1;􏳪i/ :
iD1

24.5 Proofs of shortest-paths properties
675
x
z sv
Xk iD1
Xk iD1
u
y
Figure 24.9 Showing that a simple path in G􏳬 from source s to vertex 􏳪 is unique. If there are two paths p1 (s Y u Y x ! ́ Y 􏳪) and p2 (s Y u Y y ! ́ Y 􏳪), where x ¤ y, then ́:􏳬 D x and ́:􏳬 D y, a contradiction.
But
0 >
Thus, the sum of weights around the cycle c is negative, which provides the desired contradiction.
We have now proven that G􏳬 is a directed, acyclic graph. To show that it forms a rooted tree with root s, it suffices (see Exercise B.5-2) to prove that for each vertex 􏳪 2 V􏳬, there is a unique simple path from s to 􏳪 in G􏳬.
We first must show that a path from s exists for each vertex in V􏳬 . The ver- tices in V􏳬 are those with non-NIL 􏳬 values, plus s. The idea here is to prove by induction that a path exists from s to all vertices in V􏳬 . We leave the details as Exercise 24.5-6.
To complete the proof of the lemma, we must now show that for any vertex 􏳪 2 V􏳬 , the graph G􏳬 contains at most one simple path from s to 􏳪. Suppose other- wise. That is, suppose that, as Figure 24.9 illustrates, G􏳬 contains two simple paths fromstosomevertex􏳪: p1,whichwedecomposeintosYuYx! ́Y􏳪, and p2, which we decompose into s Y u Y y ! ́ Y 􏳪, where x ¤ y (though u could be s and ́ could be 􏳪). But then, ́:􏳬 D x and ́:􏳬 D y, which implies the contradiction that x D y. We conclude that G􏳬 contains a unique simple path from s to 􏳪, and thus G􏳬 forms a rooted tree with root s.
We can now show that if, after we have performed a sequence of relaxation steps, all vertices have been assigned their true shortest-path weights, then the predeces- sor subgraph G􏳬 is a shortest-paths tree.
􏳪i:d D
since each vertex in the cycle c appears exactly once in each summation. This
Xk iD1
􏳪i􏳣1:d ; equality implies
w.􏳪i􏳣1;􏳪i/ :

676 Chapter 24 Single-Source Shortest Paths
Lemma 24.17 (Predecessor-subgraph property)
Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R, let s 2 V be a source vertex, and assume that G contains no negative-weight cycles that are reachable from s. Let us call INITIALIZE-SINGLE-SOURCE.G;s/ and then execute any sequence of relaxation steps on edges of G that produces 􏳪:d D ı.s; 􏳪/ for all 􏳪 2 V . Then, the predecessor subgraph G􏳬 is a shortest-paths tree rooted at s.
Proof We must prove that the three properties of shortest-paths trees given on page 647 hold for G􏳬 . To show the first property, we must show that V􏳬 is the set of vertices reachable from s. By definition, a shortest-path weight ı.s;􏳪/ is finite if and only if 􏳪 is reachable from s, and thus the vertices that are reachable from s are exactly those with finite d values. But a vertex 􏳪 2 V 􏳣 fsg has been assigned a finite value for 􏳪:d if and only if 􏳪:􏳬 ¤ NIL. Thus, the vertices in V􏳬 are exactly those reachable from s.
The second property follows directly from Lemma 24.16.
It remains, therefore, to prove the last property of shortest-paths trees: for each vertex􏳪2V􏳬,theuniquesimplepathsYp 􏳪inG􏳬 isashortestpathfromsto􏳪 in G. Let p D h􏳪0;􏳪1;:::;􏳪ki, where 􏳪0 D s and 􏳪k D 􏳪. For i D 1;2;:::;k, we have both 􏳪i:d D ı.s;􏳪i/ and 􏳪i:d 􏳦 􏳪i􏳣1:d C w.􏳪i􏳣1;􏳪i/, from which we conclude w.􏳪i􏳣1;􏳪i/ 􏳥 ı.s;􏳪i/ 􏳣 ı.s;􏳪i􏳣1/. Summing the weights along path p yields
Xk
w.p/ D w.􏳪i􏳣1;􏳪i/ iD1
Xk
􏳥 .ı.s;􏳪i/􏳣ı.s;􏳪i􏳣1//
iD1
D ı.s;􏳪k/􏳣ı.s;􏳪0/
D ı.s;􏳪k/
(becausethesumtelescopes) (because ı.s;􏳪0/ D ı.s;s/ D 0) .
Thus, w.p/ 􏳥 ı.s; 􏳪k /. Since ı.s; 􏳪k / is a lower bound on the weight of any path from s to 􏳪k, we conclude that w.p/ D ı.s;􏳪k/, and thus p is a shortest path from s to 􏳪 D 􏳪k.
Exercises
24.5-1
Give two shortest-paths trees for the directed graph of Figure 24.2 (on page 648) other than the two shown.

24.5 Proofs of shortest-paths properties 677
24.5-2
Give an example of a weighted, directed graph G D .V;E/ with weight function w W E ! R and source vertex s such that G satisfies the following property: For every edge .u; 􏳪/ 2 E, there is a shortest-paths tree rooted at s that contains .u; 􏳪/ and another shortest-paths tree rooted at s that does not contain .u; 􏳪/.
24.5-3
Embellish the proof of Lemma 24.10 to handle cases in which shortest-path weights are 1 or 􏳣1.
24.5-4
Let G D .V;E/ be a weighted, directed graph with source vertex s, and let G be initialized by INITIALIZE-SINGLE-SOURCE.G;s/. Prove that if a sequence of relaxation steps sets s:􏳬 to a non-NIL value, then G contains a negative-weight cycle.
24.5-5
Let G D .V; E/ be a weighted, directed graph with no negative-weight edges. Let s 2 V be the source vertex, and suppose that we allow 􏳪:􏳬 to be the predecessor of 􏳪 on any shortest path to 􏳪 from source s if 􏳪 2 V 􏳣 fsg is reachable from s, and NIL otherwise. Give an example of such a graph G and an assignment of 􏳬 values that produces a cycle in G􏳬 . (By Lemma 24.16, such an assignment cannot be produced by a sequence of relaxation steps.)
24.5-6
Let G D .V; E/ be a weighted, directed graph with weight function w W E ! R and no negative-weight cycles. Let s 2 V be the source vertex, and let G be initial- ized by INITIALIZE-SINGLE-SOURCE.G; s/. Prove that for every vertex 􏳪 2 V􏳬 , there exists a path from s to 􏳪 in G􏳬 and that this property is maintained as an invariant over any sequence of relaxations.
24.5-7
Let G D .V;E/ be a weighted, directed graph that contains no negative-weight cycles. Let s 2 V be the source vertex, and let G be initialized by INITIALIZE- SINGLE-SOURCE.G; s/. Prove that there exists a sequence of jV j 􏳣 1 relaxation steps that produces 􏳪:d D ı.s; 􏳪/ for all 􏳪 2 V .
24.5-8
Let G be an arbitrary weighted, directed graph with a negative-weight cycle reach- able from the source vertex s. Show how to construct an infinite sequence of relax- ations of the edges of G such that every relaxation causes a shortest-path estimate to change.

678 Chapter 24 Single-Source Shortest Paths
Problems
24-1 Yen’s improvement to Bellman-Ford
Suppose that we order the edge relaxations in each pass of the Bellman-Ford al- gorithm as follows. Before the first pass, we assign an arbitrary linear order 􏳪1;􏳪2;:::;􏳪jVj to the vertices of the input graph G D .V;E/. Then, we parti- tiontheedgesetEintoEf [Eb,whereEf Df.􏳪i;􏳪j/2EWi jg. (Assume that G contains no self-loops, so that every edge is in either Ef or Eb.) Define Gf D .V;Ef / and Gb D .V;Eb/.
a. Prove that Gf is acyclic with topological sort h􏳪1; 􏳪2; : : : ; 􏳪jV ji and that Gb is acyclic with topological sort h􏳪jV j; 􏳪jV j􏳣1; : : : ; 􏳪1i.
Suppose that we implement each pass of the Bellman-Ford algorithm in the fol- lowing way. We visit each vertex in the order 􏳪1; 􏳪2; : : : ; 􏳪jV j, relaxing edges of Ef that leave the vertex. We then visit each vertex in the order 􏳪jV j; 􏳪jV j􏳣1; : : : ; 􏳪1, relaxing edges of Eb that leave the vertex.
b. Prove that with this scheme, if G contains no negative-weight cycles that are reachable from the source vertex s, then after only djV j =2e passes over the edges, 􏳪:d D ı.s; 􏳪/ for all vertices 􏳪 2 V .
c. Does this scheme improve the asymptotic running time of the Bellman-Ford algorithm?
24-2 Nesting boxes
A d-dimensional box with dimensions .x1;x2;:::;xd/ nests within another box with dimensions .y1;y2;:::;yd/ if there exists a permutation 􏳬 on f1;2;:::;dg suchthatx􏳬.1/ 1 :
Analyze the running time of your algorithm.
b. Give an efficient algorithm to print out such a sequence if one exists. Analyze the running time of your algorithm.
24-4 Gabow’s scaling algorithm for single-source shortest paths
A scaling algorithm solves a problem by initially considering only the highest- order bit of each relevant input value (such as an edge weight). It then refines the initial solution by looking at the two highest-order bits. It progressively looks at more and more high-order bits, refining the solution each time, until it has exam- ined all bits and computed the correct solution.
In this problem, we examine an algorithm for computing the shortest paths from a single source by scaling edge weights. We are given a directed graph G D .V; E/ with nonnegative integer edge weights w. Let W D max.u;􏳪/2E fw.u;􏳪/g. Our goal is to develop an algorithm that runs in O.E lg W / time. We assume that all vertices are reachable from the source.
The algorithm uncovers the bits in the binary representation of the edge weights one at a time, from the most significant bit to the least significant bit. Specifically, let k D dlg.W C 1/e be the number of bits in the binary representation of W , and for i D 1;2;:::;k, let wi.u;􏳪/ D 􏳼w.u;􏳪/=2k􏳣i ̆. That is, wi.u;􏳪/ is the “scaled-down” version of w.u;􏳪/ given by the i most significant bits of w.u;􏳪/. (Thus, wk.u;􏳪/ D w.u;􏳪/ for all .u;􏳪/ 2 E.) For example, if k D 5 and w.u;􏳪/ D 25, which has the binary representation h11001i, then w3.u;􏳪/ D h110i D 6. As another example with k D 5, if w.u;􏳪/ D h00100i D 4, then w3.u; 􏳪/ D h001i D 1. Let us define ıi .u; 􏳪/ as the shortest-path weight from vertex u to vertex 􏳪 using weight function wi. Thus, ık.u;􏳪/ D ı.u;􏳪/ for all u; 􏳪 2 V . For a given source vertex s, the scaling algorithm first computes the

680 Chapter 24 Single-Source Shortest Paths
shortest-path weights ı1.s; 􏳪/ for all 􏳪 2 V , then computes ı2.s; 􏳪/ for all 􏳪 2 V , and so on, until it computes ık .s; 􏳪/ for all 􏳪 2 V . We assume throughout that jEj 􏳦 jV j 􏳣 1, and we shall see that computing ıi from ıi􏳣1 takes O.E/ time, so that the entire algorithm takes O.kE/ D O.E lg W / time.
a. Supposethatforallvertices􏳪2V,wehaveı.s;􏳪/􏳥jEj.Showthatwecan compute ı.s; 􏳪/ for all 􏳪 2 V in O.E/ time.
b. Show that we can compute ı1.s; 􏳪/ for all 􏳪 2 V in O.E/ time.
Let us now focus on computing ıi from ıi􏳣1.
c. Prove that for i D 2;3;:::;k, we have either wi.u;􏳪/ D 2wi􏳣1.u;􏳪/ or wi.u;􏳪/D2wi􏳣1.u;􏳪/C1. Then,provethat
2ıi􏳣1.s; 􏳪/ 􏳥 ıi .s; 􏳪/ 􏳥 2ıi􏳣1.s; 􏳪/ C jV j 􏳣 1
for all 􏳪 2 V .
d. Define for i D 2;3;:::;k and all .u;􏳪/ 2 E,
wyi.u;􏳪/ D wi.u;􏳪/ C 2ıi􏳣1.s;u/ 􏳣 2ıi􏳣1.s;􏳪/ :
Provethatfori D2;3;:::;kandallu;􏳪 2V,the“reweighted”valuewyi.u;􏳪/
of edge .u; 􏳪/ is a nonnegative integer.
e. Now, define ıy .s; 􏳪/ as the shortest-path weight from s to 􏳪 using the weight
i
f u n c t i o n wy i . P r o v e t h a t f o r i D 2 ; 3 ; : : : ; k a n d a l l 􏳪 2 V ,
ı.s;􏳪/Dıy.s;􏳪/C2ı .s;􏳪/ i i i􏳣1
a n d t h a t ıy . s ; 􏳪 / 􏳥 j E j . i
f. Show how to compute ıi.s;􏳪/ from ıi􏳣1.s;􏳪/ for all 􏳪 2 V in O.E/ time, and conclude that we can compute ı.s; 􏳪/ for all 􏳪 2 V in O.E lg W / time.
24-5 Karp’s minimum mean-weight cycle algorithm
Let G D .V;E/ be a directed graph with weight function w W E ! R, and let n D jV j. We define the mean weight of a cycle c D he1 ; e2 ; : : : ; ek i of edges in E to be
1 Xk
􏳲.c/D k
w.ei/:
iD1

Problems for Chapter 24 681
Let 􏳲􏳤 D minc 􏳲.c/, where c ranges over all directed cycles in G. We call a cycle c for which 􏳲.c/ D 􏳲􏳤 a minimum mean-weight cycle. This problem investigates an efficient algorithm for computing 􏳲􏳤.
Assume without loss of generality that every vertex 􏳪 2 V is reachable from a source vertex s 2 V . Let ı.s; 􏳪/ be the weight of a shortest path from s to 􏳪, and let ık.s;􏳪/ be the weight of a shortest path from s to 􏳪 consisting of exactly k edges. If there is no path from s to 􏳪 with exactly k edges, then ık .s; 􏳪/ D 1.
a. Show that if 􏳲􏳤 D 0, then G contains no negative-weight cycles and ı.s; 􏳪/ D min0􏳥k􏳥n􏳣1 ık.s;􏳪/ for all vertices 􏳪 2 V .
b. Show that if 􏳲􏳤 D 0, then
max ın.s;􏳪/􏳣ık.s;􏳪/􏳦0
0􏳥k􏳥n􏳣1 n 􏳣 k
for all vertices 􏳪 2 V . (Hint: Use both properties from part (a).)
c. Let c be a 0-weight cycle, and let u and 􏳪 be any two vertices on c. Suppose that 􏳲􏳤 D 0 and that the weight of the simple path from u to 􏳪 along the cycle is x. Prove that ı.s; 􏳪/ D ı.s; u/ C x. (Hint: The weight of the simple path from 􏳪 to u along the cycle is 􏳣x.)
d. Show that if 􏳲􏳤 D 0, then on each minimum mean-weight cycle there exists a vertex 􏳪 such that
max ın.s;􏳪/􏳣ık.s;􏳪/D0: 0􏳥k􏳥n􏳣1 n 􏳣 k
(Hint: Show how to extend a shortest path to any vertex on a minimum mean- weight cycle along the cycle to make a shortest path to the next vertex on the cycle.)
e. Show that if 􏳲􏳤 D 0, then
min max ın.s;􏳪/􏳣ık.s;􏳪/D0:
􏳪2V 0􏳥k􏳥n􏳣1 n􏳣k
f. Show that if we add a constant t to the weight of each edge of G, then 􏳲􏳤
increases by t. Use this fact to show that 􏳲􏳤Dmin max ın.s;􏳪/􏳣ık.s;􏳪/:
􏳪2V 0􏳥k􏳥n􏳣1 n􏳣k
g. GiveanO.VE/-timealgorithmtocompute􏳲􏳤.

682 Chapter 24 Single-Source Shortest Paths
24-6 Bitonic shortest paths
A sequence is bitonic if it monotonically increases and then monotonically de- creases, or if by a circular shift it monotonically increases and then monotonically decreases. For example the sequences h1; 4; 6; 8; 3; 􏳣2i, h9; 2; 􏳣4; 􏳣10; 􏳣5i, and h1; 2; 3; 4i are bitonic, but h1; 3; 12; 4; 2; 10i is not bitonic. (See Problem 15-3 for the bitonic euclidean traveling-salesman problem.)
Suppose that we are given a directed graph G D .V;E/ with weight function w W E ! R, where all edge weights are unique, and we wish to find single-source shortest paths from a source vertex s. We are given one additional piece of infor- mation: for each vertex 􏳪 2 V , the weights of the edges along any shortest path from s to 􏳪 form a bitonic sequence.
Give the most efficient algorithm you can to solve this problem, and analyze its running time.
Chapter notes
Dijkstra’s algorithm [88] appeared in 1959, but it contained no mention of a priority queue. The Bellman-Ford algorithm is based on separate algorithms by Bellman [38] and Ford [109]. Bellman describes the relation of shortest paths to difference constraints. Lawler [224] describes the linear-time algorithm for shortest paths in a dag, which he considers part of the folklore.
When edge weights are relatively small nonnegative integers, we have more ef-
ficient algorithms to solve the single-source shortest-paths problem. The sequence
of values returned by the EXTRACT-MIN calls in Dijkstra’s algorithm monoton-
ically increases over time. As discussed in the chapter notes for Chapter 6, in
this case several data structures can implement the various priority-queue opera-
tions more efficiently than a binary heap or a Fibonacci heap. Ahuja, Mehlhorn,
lg W / time on graphs with nonnegative edge weights, where W is the largest weight of any edge in the graph. The best bounds are by Thorup [337], who gives an algorithm that runs in O.E lg lg V / time, and by Raman [291], who gives an algorithm that runs in O 􏳣E C V min ̊.lg V /1=3C􏳮 ; .lg W /1=4C􏳮 􏳻􏳵 time. These two algorithms use an amount of space that depends on the word size of the underlying machine. Al- though the amount of space used can be unbounded in the size of the input, it can
be reduced to be linear in the size of the input using randomized hashing.
For undirected graphs with integer weights, Thorup [336] gives an O.V C E/- time algorithm for single-source shortest paths. In contrast to the algorithms men- tioned in the previous paragraph, this algorithm is not an implementation of Dijk-
Orlin, and Tarjan [8] give an algorithm that runs in O.E C V
p

Notes for Chapter 24 683
stra’s algorithm, since the sequence of values returned by EXTRACT-MIN calls does not monotonically increase over time.
For graphs with negative edge weights, an algorithm due to Gabow and Tar-
V E lg.V W // time, and one by Goldberg [137] runs in O. V E lg W / time, where W D max.u;􏳪/2E fjw.u; 􏳪/jg.
Cherkassky, Goldberg, and Radzik [64] conducted extensive experiments com- paring various shortest-path algorithms.
jan [122] runs in O. p
p

25 All-Pairs Shortest Paths
In this chapter, we consider the problem of finding shortest paths between all pairs of vertices in a graph. This problem might arise in making a table of distances be- tween all pairs of cities for a road atlas. As in Chapter 24, we are given a weighted, directed graph G D .V;E/ with a weight function w W E ! R that maps edges to real-valued weights. We wish to find, for every pair of vertices u; 􏳪 2 V , a shortest (least-weight) path from u to 􏳪, where the weight of a path is the sum of the weights of its constituent edges. We typically want the output in tabular form: the entry in u’s row and 􏳪’s column should be the weight of a shortest path from u to 􏳪.
We can solve an all-pairs shortest-paths problem by running a single-source shortest-paths algorithm jV j times, once for each vertex as the source. If all edge weights are nonnegative, we can use Dijkstra’s algorithm. If we use the linear-array implementation of the min-priority queue, the running time is O.V 3 C VE/ D O.V 3/. The binary min-heap implementation of the min-priority queue yields a running time of O.VE lg V /, which is an improvement if the graph is sparse. Alternatively, we can implement the min-priority queue with a Fibonacci heap, yielding a running time of O.V 2 lg V C VE/.
If the graph has negative-weight edges, we cannot use Dijkstra’s algorithm. In- stead, we must run the slower Bellman-Ford algorithm once from each vertex. The resulting running time is O.V 2E/, which on a dense graph is O.V 4/. In this chap- ter we shall see how to do better. We also investigate the relation of the all-pairs shortest-paths problem to matrix multiplication and study its algebraic structure.
Unlike the single-source algorithms, which assume an adjacency-list represen- tation of the graph, most of the algorithms in this chapter use an adjacency- matrix representation. (Johnson’s algorithm for sparse graphs, in Section 25.3, uses adjacency lists.) For convenience, we assume that the vertices are numbered 1;2;:::;jVj,sothattheinputisann􏳨nmatrixW representingtheedgeweights of an n-vertex directed graph G D .V; E/. That is, W D .wij /, where

Chapter 25 All-Pairs Shortest Paths
􏳾 0
wij D the weight of directed edge .i;j/
1
685
We allow negative-weight edges, but we assume for the time being that the input graph contains no negative-weight cycles.
The tabular output of the all-pairs shortest-paths algorithms presented in this chapter is an n 􏳨 n matrix D D .dij /, where entry dij contains the weight of a shortest path from vertex i to vertex j . That is, if we let ı.i; j / denote the shortest- path weight from vertex i to vertex j (as in Chapter 24), then dij D ı.i;j/ at termination.
To solve the all-pairs shortest-paths problem on an input adjacency matrix, we need to compute not only the shortest-path weights but also a predecessor matrix …D.􏳬ij/,where􏳬ij isNILifeitheriDjorthereisnopathfromitoj, and otherwise 􏳬ij is the predecessor of j on some shortest path from i. Just as the predecessor subgraph G􏳬 from Chapter 24 is a shortest-paths tree for a given source vertex, the subgraph induced by the ith row of the … matrix should be a shortest-paths tree with root i . For each vertex i 2 V , we define the predecessor subgraphofGforiasG􏳬;i D.V􏳬;i;E􏳬;i/,where
V􏳬;i D fj 2 V W 􏳬ij ¤ NILg [ fig and
E􏳬;i Df.􏳬ij;j/Wj 2V􏳬;i 􏳣figg :
If G􏳬;i is a shortest-paths tree, then the following procedure, which is a modified version of the PRINT-PATH procedure from Chapter 22, prints a shortest path from vertex i to vertex j .
PRINT-ALL-PAIRS-SHORTEST-PATH….;i;j/
1 2 3 4 5 6
ifi==j print i
elseif􏳬ij ==NIL
print “no path from” i “to” j “exists”
else PRINT-ALL-PAIRS-SHORTEST-PATH….; i; 􏳬ij / print j
In order to highlight the essential features of the all-pairs algorithms in this chapter, we won’t cover the creation and properties of predecessor matrices as extensively as we dealt with predecessor subgraphs in Chapter 24. Some of the exercises cover the basics.
if i D j ;
if i ¤ j and .i;j/ 2 E ; (25.1) if i ¤ j and .i; j / 62 E :

686 Chapter 25 All-Pairs Shortest Paths
Chapter outline
Section 25.1 presents a dynamic-programming algorithm based on matrix multi- plication to solve the all-pairs shortest-paths problem. Using the technique of “re- peated squaring,” we can achieve a running time of ‚.V 3 lg V /. Section 25.2 gives another dynamic-programming algorithm, the Floyd-Warshall algorithm, which runs in time ‚.V 3/. Section 25.2 also covers the problem of finding the tran- sitive closure of a directed graph, which is related to the all-pairs shortest-paths problem. Finally, Section 25.3 presents Johnson’s algorithm, which solves the all- pairs shortest-paths problem in O.V 2 lg V C VE/ time and is a good choice for large, sparse graphs.
Before proceeding, we need to establish some conventions for adjacency-matrix
representations. First, we shall generally assume that the input graph G D .V;E/
has n vertices, so that n D jV j. Second, we shall use the convention of denoting
matrices by uppercase letters, such as W , L, or D, and their individual elements
by subscripted lowercase letters, such as wij , lij , or dij . Some matrices will have
parenthesized superscripts, as in L.m/ D 􏳣l.m/􏳵 or D.m/ D 􏳣d.m/􏳵, to indicate ij ij
iterates. Finally, for a given n 􏳨 n matrix A, we shall assume that the value of n is stored in the attribute A:rows.
25.1 Shortest paths and matrix multiplication
This section presents a dynamic-programming algorithm for the all-pairs shortest- paths problem on a directed graph G D .V;E/. Each major loop of the dynamic program will invoke an operation that is very similar to matrix multiplication, so that the algorithm will look like repeated matrix multiplication. We shall start by developing a ‚.V 4/-time algorithm for the all-pairs shortest-paths problem and then improve its running time to ‚.V 3 lg V /.
Before proceeding, let us briefly recap the steps given in Chapter 15 for devel- oping a dynamic-programming algorithm.
1. Characterize the structure of an optimal solution.
2. Recursively define the value of an optimal solution.
3. Compute the value of an optimal solution in a bottom-up fashion.
We reserve the fourth step—constructing an optimal solution from computed in- formation—for the exercises.

25.1 Shortest paths and matrix multiplication 687
The structure of a shortest path
We start by characterizing the structure of an optimal solution. For the all-pairs
shortest-paths problem on a graph G D .V;E/, we have proven (Lemma 24.1)
that all subpaths of a shortest path are shortest paths. Suppose that we represent
the graph by an adjacency matrix W D .wij /. Consider a shortest path p from
vertex i to vertex j , and suppose that p contains at most m edges. Assuming that
there are no negative-weight cycles, m is finite. If i D j , then p has weight 0
and no edges. If vertices i and j are distinct, then we decompose path p into p0 0
iYk!j,wherepathp nowcontainsatmostm􏳣1edges.ByLemma24.1, p0 is a shortest path from i to k, and so ı.i;j/ D ı.i;k/ C wkj .
A recursive solution to the all-pairs shortest-paths problem
Now, let l.m/ be the minimum weight of any path from vertex i to vertex j that ij
contains at most m edges. When m D 0, there is a shortest path from i to j with no edges if and only if i D j . Thus,
(
l.0/ D ij
For m 􏳦 1, we compute l.m/ as the minimum of l.m􏳣1/ (the weight of a shortest ij ij
path from i to j consisting of at most m 􏳣 1 edges) and the minimum weight of any path from i to j consisting of at most m edges, obtained by looking at all possible predecessors k of j . Thus, we recursively define
0 if i D j ; 1 ifi¤j:
.m/ 􏳰 .m􏳣1/ ̊ .m􏳣1/ lij D min lij ; min lik
􏳻􏳳
Cwkj
1􏳥k􏳥n
D min ̊l.m􏳣1/ C w 􏳻 :
(25.2)
1􏳥k􏳥n ik kj
Thelatterequalityfollowssincewjj D0forallj. What are the actual shortest-path weights ı.i; j /?
graph
ı.i;j/ D l.n􏳣1/ D l.n/ D l.nC1/ D 􏳵􏳵􏳵 : (25.3) ij ij ij
If the
no negative-weight cycles, then for every pair of vertices i and j for which ı.i; j / < 1, there is a shortest path from i to j that is simple and thus contains at most n 􏳣 1 edges. A path from vertex i to vertex j with more than n 􏳣 1 edges cannot have lower weight than a shortest path from i to j . The actual shortest-path weights are therefore given by contains 688 Chapter 25 All-Pairs Shortest Paths Computing the shortest-path weights bottom up Taking as our input the matrix W D .wij /, we now compute a series of matrices L.1/;L.2/;:::;L.n􏳣1/, where for m D 1;2;:::;n 􏳣 1, we have L.m/ D 􏳣l.m/􏳵. ij The final matrix L.n􏳣1/ contains the actual shortest-path weights. Observe that l.1/ Dwij forallverticesi;j 2V,andsoL.1/ DW. ij The heart of the algorithm is the following procedure, which, given matrices L.m􏳣1/ and W , returns the matrix L.m/. That is, it extends the shortest paths com- puted so far by one more edge. EXTEND-SHORTEST-PATHS.L;W / n D L:rows letL0 D􏳣l0 􏳵beanewn􏳨nmatrix foriD1ton for j D 1 to n l0D1 ij (It is written without the superscripts to make its input and output matrices inde- pendent of m.) Its running time is ‚.n3/ due to the three nested for loops. Now we can see the relation to matrix multiplication. Suppose we wish to com- pute the matrix product C D A􏳵B of two n􏳨n matrices A and B. Then, for i;j D 1;2;:::;n, we compute 1 2 3 4 5 6 7 8 ij for k D 1 to n l0 Dmin.l0;l Cw / ij ijikkj return L0 The procedure computes a matrix L0 D .l0 /, which it returns at the end. It does so ij by computing equation (25.2) for all i and j, using L for L.m􏳣1/ and L0 for L.m/. Xn aik 􏳵bkj : Observe that if we make the substitutions l.m􏳣1/ ! a; w!b; l.m/ ! c; min ! C; C!􏳵 cij D (25.4) kD1 in equation (25.2), we obtain equation (25.4). Thus, if we make these changes to EXTEND-SHORTEST-PATHS and also replace 1 (the identity for min) by 0 (the 25.1 Shortest paths and matrix multiplication 689 identity for C), we obtain the same ‚.n3/-time procedure for multiplying square matrices that we saw in Section 4.2: SQUARE-MATRIX-MULTIPLY.A;B/ 1 2 3 4 5 6 7 8 n D A:rows letC beanewn􏳨nmatrix foriD1ton for j D 1 to n cij D0 for k D 1 to n cij DcijCaik􏳵bkj return C Returning to the all-pairs shortest-paths problem, we compute the shortest-path weights by extending shortest paths edge by edge. Letting A 􏳵 B denote the ma- trix “product” returned by EXTEND-SHORTEST-PATHS.A; B/, we compute the se- quence of n 􏳣 1 matrices L.1/ D L.0/􏳵W DW; L.2/ D L.1/􏳵W DW2; L.3/ D L.2/􏳵W DW3; : L.n􏳣1/ D L.n􏳣2/ 􏳵W D Wn􏳣1 : As we argued above, the matrix L.n􏳣1/ D W n􏳣1 contains the shortest-path weights. The following procedure computes this sequence in ‚.n4/ time. SLOW-ALL-PAIRS-SHORTEST-PATHS.W / 1 2 3 4 5 6 n D W:rows L.1/DW formD2ton􏳣1 letL.m/ beanewn􏳨nmatrix L.m/ D EXTEND-SHORTEST-PATHS.L.m􏳣1/; W / return L.n􏳣1/ Figure 25.1 shows a graph and the matrices L.m/ computed by the procedure SLOW-ALL-PAIRS-SHORTEST-PATHS. Improving the running time Our goal, however, is not to compute all the L.m/ matrices: we are interested only in matrix L.n􏳣1/. Recall that in the absence of negative-weight cycles, equa- 690 Chapter 25 All-Pairs Shortest Paths 2 34 13 –4 2 54 6 2 1 􏳣5 0 1 2 􏳣1 􏳣5 0 􏳣2 11160 81160 71 8 –5 3 8 1 􏳣4 ̆ 1 0 1 1 7 􏳼0 3 3 0 􏳣4 1 7 L.1/D 1 4 0 1 1 L.2/D 1 4 0 5 11 􏳼0 8 2 􏳣4 ̆ 􏳼0 3 􏳣3 2 􏳣4 ̆ 3 0 􏳣4 1 􏳣1 L.3/D 7 4 0 5 11 2 􏳣1 􏳣5 0 􏳣2 85160 L.4/D 􏳼0 1 􏳣3 2 􏳣4 ̆ 3 0􏳣41􏳣1 7 4 0 5 3 2􏳣1􏳣50􏳣2 85160 Figure 25.1 A directed graph and the sequence of matrices L.m/ computed by SLOW-ALL-PAIRS- SHORTEST-PATHS. You might want to verify that L.5/, defined as L.4/ 􏳵 W , equals L.4/, and thus L.m/ DL.4/ forallm􏳦4. tion (25.3) implies L.m/ D L.n􏳣1/ for all integers m 􏳦 n 􏳣 1. Just as tradi- tional matrix multiplication is associative, so is matrix multiplication defined by the EXTEND-SHORTEST-PATHS procedure (see Exercise 25.1-4). Therefore, we can compute L.n􏳣1/ with only dlg.n 􏳣 1/e matrix products by computing the se- quence L.1/ D W; L.2/DW2 DW􏳵W; L.4/DW4 DW2􏳵W2 L.8/DW8 DW4􏳵W4; : L.2dlg.n􏳣1/e/ D W 2dlg.n􏳣1/e D W 2dlg.n􏳣1/e􏳣1 􏳵 W 2dlg.n􏳣1/e􏳣1 : Since 2dlg.n􏳣1/e 􏳦 n 􏳣 1, the final product L.2dlg.n􏳣1/e/ is equal to L.n􏳣1/. The following procedure computes the above sequence of matrices by using this technique of repeated squaring. 25.1 Shortest paths and matrix multiplication 691 11223 –4 710–8 2 –1 5 435 6 Figure 25.2 A weighted, directed graph for use in Exercises 25.1-1, 25.2-1, and 25.3-1. FASTER-ALL-PAIRS-SHORTEST-PATHS.W / 1 2 3 4 5 6 7 8 n D W:rows L.1/DW mD1 whilem

26 Maximum Flow
Just as we can model a road map as a directed graph in order to find the shortest path from one point to another, we can also interpret a directed graph as a “flow network” and use it to answer questions about material flows. Imagine a mate- rial coursing through a system from a source, where the material is produced, to a sink, where it is consumed. The source produces the material at some steady rate, and the sink consumes the material at the same rate. The “flow” of the mate- rial at any point in the system is intuitively the rate at which the material moves. Flow networks can model many problems, including liquids flowing through pipes, parts through assembly lines, current through electrical networks, and information through communication networks.
We can think of each directed edge in a flow network as a conduit for the mate- rial. Each conduit has a stated capacity, given as a maximum rate at which the ma- terial can flow through the conduit, such as 200 gallons of liquid per hour through a pipe or 20 amperes of electrical current through a wire. Vertices are conduit junctions, and other than the source and sink, material flows through the vertices without collecting in them. In other words, the rate at which material enters a ver- tex must equal the rate at which it leaves the vertex. We call this property “flow conservation,” and it is equivalent to Kirchhoff’s current law when the material is electrical current.
In the maximum-flow problem, we wish to compute the greatest rate at which we can ship material from the source to the sink without violating any capacity constraints. It is one of the simplest problems concerning flow networks and, as we shall see in this chapter, this problem can be solved by efficient algorithms. Moreover, we can adapt the basic techniques used in maximum-flow algorithms to solve other network-flow problems.
This chapter presents two general methods for solving the maximum-flow prob- lem. Section 26.1 formalizes the notions of flow networks and flows, formally defining the maximum-flow problem. Section 26.2 describes the classical method of Ford and Fulkerson for finding maximum flows. An application of this method,

26.1 Flow networks 709
finding a maximum matching in an undirected bipartite graph, appears in Sec- tion 26.3. Section 26.4 presents the push-relabel method, which underlies many of the fastest algorithms for network-flow problems. Section 26.5 covers the “relabel- to-front” algorithm, a particular implementation of the push-relabel method that runs in time O.V 3/. Although this algorithm is not the fastest algorithm known, it illustrates some of the techniques used in the asymptotically fastest algorithms, and it is reasonably efficient in practice.
26.1 Flow networks
In this section, we give a graph-theoretic definition of flow networks, discuss their properties, and define the maximum-flow problem precisely. We also introduce some helpful notation.
Flow networks and flows
A flow network G D .V;E/ is a directed graph in which each edge .u;􏳪/ 2 E has a nonnegative capacity c.u;􏳪/ 􏳦 0. We further require that if E contains an edge .u;􏳪/, then there is no edge .􏳪;u/ in the reverse direction. (We shall see shortly how to work around this restriction.) If .u;􏳪/ 62 E, then for convenience we define c.u; 􏳪/ D 0, and we disallow self-loops. We distinguish two vertices in a flow network: a source s and a sink t. For convenience, we assume that each vertex lies on some path from the source to the sink. That is, for each vertex 􏳪 2 V , the flow network contains a path s Y 􏳪 Y t. The graph is therefore connected and, since each vertex other than s has at least one entering edge, jEj 􏳦 jV j 􏳣 1. Figure 26.1 shows an example of a flow network.
We are now ready to define flows more formally. Let G D .V;E/ be a flow network with a capacity function c. Let s be the source of the network, and let t be the sink. A flow in G is a real-valued function f W V 􏳨 V ! R that satisfies the following two properties:
Capacityconstraint: Forallu;􏳪2V,werequire0􏳥f.u;􏳪/􏳥c.u;􏳪/. Flow conservation: For all u 2 V 􏳣 fs; t g, we require
XX
f .􏳪; u/ D f .u; 􏳪/ : 􏳪2V
􏳪2V
When .u;􏳪/ 62 E, there can be no flow from u to 􏳪, and f.u;􏳪/ D 0.

710 Chapter 26
Maximum Flow
Vancouver
Winnipeg
v4 v2 11/14 v4 Regina
(b)
Edmonton v1
Saskatoon v3
12
v2 14 Calgary
(a)
v1 12/12 v3 stst
(a) A flow network G D .V;E/ for the Lucky Puck Company’s trucking problem. The Vancouver factory is the source s, and the Winnipeg warehouse is the sink t. The company ships pucks through intermediate cities, but only c.u; 􏳪/ crates per day can go from city u to city 􏳪. Each edge is labeled with its capacity. (b) A flow f in G with value jf j D 19. Each edge .u; 􏳪/ is labeled by f .u; 􏳪/=c.u; 􏳪/. The slash notation merely separates the flow and capacity; it does not indicate division.
We call the nonnegative quantity f .u; 􏳪/ the flow from vertex u to vertex 􏳪. The valuejfjofaflowf isdefinedas
XX
jf j D f .s; 􏳪/ 􏳣 f .􏳪; s/ ; (26.1) 􏳪2V 􏳪2V
that is, the total flow out of the source minus the flow into the source. (Here, the j􏳵j notation denotes flow value, not absolute value or cardinality.) Typically, a flow network will not have any edges into the source, and the flow into the source, given
f .􏳪; s/, will be 0. We include it, however, because when we introduce residual networks later in this chapter, the flow into the source will become significant. In the maximum-flow problem, we are given a flow network G
with source s and sink t, and we wish to find a flow of maximum value.
Before seeing an example of a network-flow problem, let us briefly explore the definition of flow and the two flow properties. The capacity constraint simply says that the flow from one vertex to another must be nonnegative and must not exceed the given capacity. The flow-conservation property says that the total flow into a vertex other than the source or sink must equal the total flow out of that
vertex—informally, “flow in equals flow out.”
An example of flow
A flow network can model the trucking problem shown in Figure 26.1(a). The Lucky Puck Company has a factory (source s) in Vancouver that manufactures hockey pucks, and it has a warehouse (sink t) in Winnipeg that stocks them. Lucky
Figure 26.1
by the summation P
􏳪2V
16
4
11/16
4/4
4
7
1/4
7/7
9
4/9
13
20
8/13
15/20

26.1 Flow networks 711
v1 12 v3 v1 12 v3
10
s tsv′ t 10
v2 14 v4 v2 14 v4 (a) (b)
Figure 26.2 Converting a network with antiparallel edges to an equivalent one with no antiparallel edges. (a) A flow network containing both the edges .􏳪1; 􏳪2/ and .􏳪2; 􏳪1/. (b) An equivalent network with no antiparallel edges. We add the new vertex 􏳪0, and we replace edge .􏳪1; 􏳪2/ by the pair of edges .􏳪1; 􏳪0/ and .􏳪0; 􏳪2/, both with the same capacity as .􏳪1; 􏳪2/.
Puck leases space on trucks from another firm to ship the pucks from the factory to the warehouse. Because the trucks travel over specified routes (edges) between cities (vertices) and have a limited capacity, Lucky Puck can ship at most c.u;􏳪/ crates per day between each pair of cities u and 􏳪 in Figure 26.1(a). Lucky Puck has no control over these routes and capacities, and so the company cannot alter the flow network shown in Figure 26.1(a). They need to determine the largest number p of crates per day that they can ship and then to produce this amount, since there is no point in producing more pucks than they can ship to their warehouse. Lucky Puck is not concerned with how long it takes for a given puck to get from the factory to the warehouse; they care only that p crates per day leave the factory and p crates per day arrive at the warehouse.
We can model the “flow” of shipments with a flow in this network because the number of crates shipped per day from one city to another is subject to a capacity constraint. Additionally, the model must obey flow conservation, for in a steady state, the rate at which pucks enter an intermediate city must equal the rate at which they leave. Otherwise, crates would accumulate at intermediate cities.
Modeling problems with antiparallel edges
Suppose that the trucking firm offered Lucky Puck the opportunity to lease space for 10 crates in trucks going from Edmonton to Calgary. It would seem natural to add this opportunity to our example and form the network shown in Figure 26.2(a). This network suffers from one problem, however: it violates our original assump- tion that if an edge .􏳪1;􏳪2/ 2 E, then .􏳪2;􏳪1/ 62 E. We call the two edges .􏳪1;􏳪2/ and .􏳪2;􏳪1/ antiparallel. Thus, if we wish to model a flow problem with antipar- allel edges, we must transform the network into an equivalent one containing no
16
4
16
4
10 4
7
4
7
9
9
13
20
13
20

712 Chapter 26 Maximum Flow
antiparallel edges. Figure 26.2(b) displays this equivalent network. We choose one of the two antiparallel edges, in this case .􏳪1 ; 􏳪2 /, and split it by adding a new vertex 􏳪0 and replacing edge .􏳪1;􏳪2/ with the pair of edges .􏳪1;􏳪0/ and .􏳪0;􏳪2/. We also set the capacity of both new edges to the capacity of the original edge. The resulting network satisfies the property that if an edge is in the network, the reverse edge is not. Exercise 26.1-1 asks you to prove that the resulting network is equivalent to the original one.
Thus, we see that a real-world flow problem might be most naturally modeled by a network with antiparallel edges. It will be convenient to disallow antipar- allel edges, however, and so we have a straightforward way to convert a network containing antiparallel edges into an equivalent one with no antiparallel edges.
Networks with multiple sources and sinks
A maximum-flow problem may have several sources and sinks, rather than just one of each. The Lucky Puck Company, for example, might actually have a set of m factories fs1;s2;:::;smg and a set of n warehouses ft1;t2;:::;tng, as shown in Figure 26.3(a). Fortunately, this problem is no harder than ordinary maximum flow.
We can reduce the problem of determining a maximum flow in a network with multiple sources and multiple sinks to an ordinary maximum-flow problem. Fig- ure 26.3(b) shows how to convert the network from (a) to an ordinary flow network with only a single source and a single sink. We add a supersource s and add a directed edge .s;si/ with capacity c.s;si/ D 1 for each i D 1;2;:::;m. We also create a new supersink t and add a directed edge .ti ; t/ with capacity c.ti ; t/ D 1 for each i D 1; 2; : : : ; n. Intuitively, any flow in the network in (a) corresponds to a flow in the network in (b), and vice versa. The single source s simply provides as much flow as desired for the multiple sources si , and the single sink t likewise consumes as much flow as desired for the multiple sinks ti . Exercise 26.1-2 asks you to prove formally that the two problems are equivalent.
Exercises
26.1-1
Show that splitting an edge in a flow network yields an equivalent network. More formally, suppose that flow network G contains edge .u;􏳪/, and we create a new flow network G0 by creating a new vertex x and replacing .u;􏳪/ by new edges .u; x/ and .x; 􏳪/ with c.u; x/ D c.x; 􏳪/ D c.u; 􏳪/. Show that a maximum flow in G0 has the same value as a maximum flow in G.

s1
s2
s3
s4
s5
s1
t1 s2
t2 s∞ s3 t3 s4
s5
t1
t2 ∞ t t3
26.1
Flow networks
713
(a)
Figure 26.3
with a single source and a single sink. (a) A flow network with five sources S D fs1; s2; s3; s4; s5g and three sinks T D ft1; t2; t3g. (b) An equivalent single-source, single-sink flow network. We add a supersource s and an edge with infinite capacity from s to each of the multiple sources. We also add a supersink t and an edge with infinite capacity from each of the multiple sinks to t.
26.1-2
Extend the flow properties and definitions to the multiple-source, multiple-sink problem. Show that any flow in a multiple-source, multiple-sink flow network corresponds to a flow of identical value in the single-source, single-sink network obtained by adding a supersource and a supersink, and vice versa.
26.1-3
Suppose that a flow network G D .V; E/ violates the assumption that the network contains a path s Y 􏳪 Y t for all vertices 􏳪 2 V . Let u be a vertex for which there is no path s Y u Y t. Show that there must exist a maximum flow f in G such that f .u; 􏳪/ D f .􏳪; u/ D 0 for all vertices 􏳪 2 V .
Converting a multiple-source, multiple-sink maximum-flow problem into a problem
(b)
∞
12
8 15
720 12
218 815
7 20
2 18
∞
∞
∞
∞
10 3 14 13
56 11
14
13
11
10 3
56
∞

714 Chapter 26 Maximum Flow
26.1-4
Let f be a flow in a network, and let ̨ be a real number. The scalar flow product, denoted ̨f , is a function from V 􏳨 V to R defined by
. ̨f /.u;􏳪/ D ̨ 􏳵 f.u;􏳪/ :
Prove that the flows in a network form a convex set. That is, show that if f1 and f2
areflows,thensois ̨f1 C.1􏳣 ̨/f2 forall ̨intherange0􏳥 ̨􏳥1. 26.1-5
State the maximum-flow problem as a linear-programming problem.
26.1-6
Professor Adam has two children who, unfortunately, dislike each other. The prob- lem is so severe that not only do they refuse to walk to school together, but in fact each one refuses to walk on any block that the other child has stepped on that day. The children have no problem with their paths crossing at a corner. Fortunately both the professor’s house and the school are on corners, but beyond that he is not sure if it is going to be possible to send both of his children to the same school. The professor has a map of his town. Show how to formulate the problem of de- termining whether both his children can go to the same school as a maximum-flow problem.
26.1-7
Suppose that, in addition to edge capacities, a flow network has vertex capacities. That is each vertex 􏳪 has a limit l.􏳪/ on how much flow can pass though 􏳪. Show how to transform a flow network G D .V; E/ with vertex capacities into an equiv- alent flow network G0 D .V 0; E0/ without vertex capacities, such that a maximum flow in G0 has the same value as a maximum flow in G. How many vertices and edges does G0 have?
26.2 The Ford-Fulkerson method
This section presents the Ford-Fulkerson method for solving the maximum-flow problem. We call it a “method” rather than an “algorithm” because it encompasses several implementations with differing running times. The Ford-Fulkerson method depends on three important ideas that transcend the method and are relevant to many flow algorithms and problems: residual networks, augmenting paths, and cuts. These ideas are essential to the important max-flow min-cut theorem (The- orem 26.6), which characterizes the value of a maximum flow in terms of cuts of

26.2 The Ford-Fulkerson method 715
the flow network. We end this section by presenting one specific implementation of the Ford-Fulkerson method and analyzing its running time.
The Ford-Fulkerson method iteratively increases the value of the flow. We start with f.u;􏳪/ D 0 for all u;􏳪 2 V, giving an initial flow of value 0. At each iteration, we increase the flow value in G by finding an “augmenting path” in an associated “residual network” Gf . Once we know the edges of an augmenting path in Gf , we can easily identify specific edges in G for which we can change the flow so that we increase the value of the flow. Although each iteration of the Ford-Fulkerson method increases the value of the flow, we shall see that the flow on any particular edge of G may increase or decrease; decreasing the flow on some edges may be necessary in order to enable an algorithm to send more flow from the source to the sink. We repeatedly augment the flow until the residual network has no more augmenting paths. The max-flow min-cut theorem will show that upon termination, this process yields a maximum flow.
FORD-FULKERSON-METHOD.G; s; t/
1 initialize flow f to 0
2 while there exists an augmenting path p in the residual network Gf
3 augment flow f along p
4 return f
In order to implement and analyze the Ford-Fulkerson method, we need to intro- duce several additional concepts.
Residual networks
Intuitively, given a flow network G and a flow f , the residual network Gf consists of edges with capacities that represent how we can change the flow on edges of G. An edge of the flow network can admit an amount of additional flow equal to the edge’s capacity minus the flow on that edge. If that value is positive, we place that edge into Gf with a “residual capacity” of cf .u; 􏳪/ D c.u; 􏳪/ 􏳣 f .u; 􏳪/. The only edges of G that are in Gf are those that can admit more flow; those edges .u; 􏳪/ whose flow equals their capacity have cf .u; 􏳪/ D 0, and they are not in Gf .
The residual network Gf may also contain edges that are not in G, however. As an algorithm manipulates the flow, with the goal of increasing the total flow, it might need to decrease the flow on a particular edge. In order to represent a pos- sible decrease of a positive flow f .u; 􏳪/ on an edge in G, we place an edge .􏳪; u/ into Gf with residual capacity cf .􏳪; u/ D f .u; 􏳪/—that is, an edge that can admit flow in the opposite direction to .u;􏳪/, at most canceling out the flow on .u;􏳪/. These reverse edges in the residual network allow an algorithm to send back flow

716 Chapter 26 Maximum Flow
it has already sent along an edge. Sending flow back along an edge is equiva- lent to decreasing the flow on the edge, which is a necessary operation in many algorithms.
More formally, suppose that we have a flow network G D .V; E/ with source s andsinkt. Letf beaflowinG,andconsiderapairofverticesu;􏳪2V. We define the re􏳾sidual capacity cf .u;􏳪/ by
c.u;􏳪/􏳣f.u;􏳪/ if.u;􏳪/2E;
cf .u;􏳪/ D f.􏳪;u/ if .􏳪;u/ 2 E ; (26.2)
0 otherwise :
Because of our assumption that .u; 􏳪/ 2 E implies .􏳪; u/ 62 E, exactly one case in equation (26.2) applies to each ordered pair of vertices.
As an example of equation (26.2), if c.u; 􏳪/ D 16 and f .u; 􏳪/ D 11, then we can increase f.u;􏳪/ by up to cf .u;􏳪/ D 5 units before we exceed the capacity constraint on edge .u;􏳪/. We also wish to allow an algorithm to return up to 11 units of flow from 􏳪 to u, and hence cf .􏳪;u/ D 11.
Given a flow network G D .V; E/ and a flow f , the residual network of G inducedbyfisGf D.V;Ef/,where
Ef Df.u;􏳪/2V 􏳨V Wcf.u;􏳪/>0g : (26.3)
That is, as promised above, each edge of the residual network, or residual edge, can admit a flow that is greater than 0. Figure 26.4(a) repeats the flow network G and flow f of Figure 26.1(b), and Figure 26.4(b) shows the corresponding residual network Gf . The edges in Ef are either edges in E or their reversals, and thus
jEf j 􏳥 2 jEj :
ObservethattheresidualnetworkGf issimilartoaflownetworkwithcapacities given by cf . It does not satisfy our definition of a flow network because it may contain both an edge .u;􏳪/ and its reversal .􏳪;u/. Other than this difference, a residual network has the same properties as a flow network, and we can define a flow in the residual network as one that satisfies the definition of a flow, but with respect to capacities cf in the network Gf .
A flow in a residual network provides a roadmap for adding flow to the original flow network. If f is a flow in G and f 0 is a flow in the corresponding residual network Gf , we define f “f 0, the augmentation of flow f by f 0, to be a function fromV 􏳨V toR,definedby
(
.f “f0/.u;􏳪/D
f.u;􏳪/Cf0.u;􏳪/􏳣f0.􏳪;u/ if.u;􏳪/2E; (26.4) 0 otherwise :

26.2 The Ford-Fulkerson method 717
v 12/12 v v 12 v 13 13
stst vvv3v
2 11/14 4
(a) (b)
2 4 11
v1 12/12 v3 stst
v1 12 v3
vvv3v 2 11/14 4 2 4
11 (c) (d)
Figure 26.4 (a) The flow network G and flow f of Figure 26.1(b). (b) The residual network Gf with augmenting path p shaded; its residual capacity is cf .p/ D cf .􏳪2; 􏳪3/ D 4. Edges with residual capacity equal to 0, such as .􏳪1; 􏳪3/, are not shown, a convention we follow in the remainder of this section. (c) The flow in G that results from augmenting along path p by its residual capacity 4. Edges carrying no flow, such as .􏳪3;􏳪2/, are labeled only by their capacity, another convention we follow throughout. (d) The residual network induced by the flow in (c).
The intuition behind this definition follows the definition of the residual network. We increase the flow on .u; 􏳪/ by f 0.u; 􏳪/ but decrease it by f 0.􏳪; u/ because pushing flow on the reverse edge in the residual network signifies decreasing the flow in the original network. Pushing flow on the reverse edge in the residual network is also known as cancellation. For example, if we send 5 crates of hockey pucks from u to 􏳪 and send 2 crates from 􏳪 to u, we could equivalently (from the perspective of the final result) just send 3 creates from u to 􏳪 and none from 􏳪 to u. Cancellation of this type is crucial for any maximum-flow algorithm.
Lemma 26.1
LetGD.V;E/beaflownetworkwithsourcesandsinkt,andletf beaflow inG. LetGf betheresidualnetworkofGinducedbyf,andletf0 beaflow in Gf . Then the function f ” f 0 defined in equation (26.4) is a flow in G with valuejf “f0jDjfjCjf0j.
Proof We first verify that f ” f 0 obeys the capacity constraint for each edge in E and flow conservation at each vertex in V 􏳣 fs; t g.
1/4 1/4
7/7 7/7
11 33
77
11/16
5 11
11/16
4/4
4
4/4
5 11
4
9
4/9
9
4 5
8/13
1 12
12/13
15/20
19/20
5 8
1 19
5 15

718 Chapter 26 Maximum Flow
For the capacity constraint, first observe that if .u; 􏳪/ 2 E, then cf .􏳪; u/ D f.u;􏳪/. Therefore, we have f 0.􏳪;u/ 􏳥 cf .􏳪;u/ D f.u;􏳪/, and hence
.f “f0/.u;􏳪/ D f.u;􏳪/Cf0.u;􏳪/􏳣f0.􏳪;u/ (byequation(26.4))
􏳦 f.u;􏳪/Cf0.u;􏳪/􏳣f.u;􏳪/ (becausef0.􏳪;u/􏳥f.u;􏳪/)
D f0.u;􏳪/
􏳦0: In addition,
.f “f0/.u;􏳪/
D f.u;􏳪/Cf0.u;􏳪/􏳣f0.􏳪;u/
􏳥 f.u;􏳪/Cf0.u;􏳪/
􏳥 f .u; 􏳪/ C cf .u; 􏳪/
D f.u;􏳪/Cc.u;􏳪/􏳣f.u;􏳪/ D c.u;􏳪/:
For flow conservation, because both f and f 0 thatforallu2V 􏳣fs;tg,
(byequation(26.4))
(because flows are nonnegative) (capacity constraint) (definitionofcf)
obey flow conservation, we have
X.f “f0/.u;􏳪/ D
􏳪2V
X .f .u; 􏳪/ C f 0.u; 􏳪/ 􏳣 f 0.􏳪; u// 􏳪2V
D Xf.u;􏳪/CXf0.u;􏳪/􏳣Xf0.􏳪;u/ 􏳪2V 􏳪2V 􏳪2V
D Xf.􏳪;u/CXf0.􏳪;u/􏳣Xf0.u;􏳪/ 􏳪2V 􏳪2V 􏳪2V
D X.f.􏳪;u/Cf0.􏳪;u/􏳣f0.u;􏳪//
D
􏳪2V X0
.f “f /.􏳪;u/;
􏳪2V
where the third line follows from the second by flow conservation.
Finally, we compute the value of f ” f 0 . Recall that we disallow antiparallel edges in G (but not in Gf ), and hence for each vertex 􏳪 2 V, we know that there can be an edge .s;􏳪/ or .􏳪;s/, but never both. We define V1 D f􏳪 W .s;􏳪/ 2 Eg tobethesetofverticeswithedgesfroms,andV2 Df􏳪W.􏳪;s/2Egtobethe set of vertices with edges to s. We have V1 [ V2 􏳧 V and, because we disallow antiparallel edges, V1 \ V2 D ;. We now compute
0X0X0
jf “f j D .f “f /.s;􏳪/􏳣 .f “f /.􏳪;s/
􏳪2V 􏳪2V X0 X0
D .f “f /.s;􏳪/􏳣 .f “f /.􏳪;s/; (26.5) 􏳪2V1 􏳪2V2

26.2 The Ford-Fulkerson method 719
where the second line follows because .f ” f 0/.w; x/ is 0 if .w; x/ 62 E. We now apply the definition of f ” f 0 to equation (26.5), and then reorder and group terms to obtain
jf “f0j
D D
X.f.s;􏳪/Cf0.s;􏳪/􏳣f0.􏳪;s//􏳣 X.f.􏳪;s/Cf0.􏳪;s/􏳣f0.s;􏳪// 􏳪2V1 􏳪2V2
X
D
􏳪2V1
􏳪2V1X f .s; 􏳪/ 􏳣
􏳪2V2
􏳪2V2 X f .􏳪; s/ C
􏳪2V1[V2
􏳪2V1
f 0.s; 􏳪/ 􏳣
X 􏳪2V2
f 0.􏳪; s/ : (26.6)
􏳪2V1[V2
XX0X0 f.s;􏳪/C f .s;􏳪/􏳣 f .􏳪;s/
􏳪2V1
X􏳪2V1 X 􏳪2V1 X
􏳣 f.􏳪;s/􏳣 f0.􏳪;s/C f0.s;􏳪/
􏳪2V2 X 􏳪2V2 􏳪2V2 D f.s;􏳪/􏳣 f.􏳪;s/
X
􏳪2V1 X􏳪2V2 X X X
C f 0.s; 􏳪/ C f 0.s; 􏳪/ 􏳣 f 0.􏳪; s/ 􏳣 f 0.􏳪; s/
In equation (26.6), we can extend all four summations to sum over V , since each additional term has value 0. (Exercise 26.2-1 asks you to prove this formally.) We thushave X X X X
jf “f0j D
f0.s;􏳪/􏳣 f0.􏳪;s/ (26.7) 􏳪2V
f.s;􏳪/􏳣 D jfjCjf0j:
Augmenting paths
f.􏳪;s/C
􏳪2V
􏳪2V
􏳪2V
Given a flow network G D .V;E/ and a flow f, an augmenting path p is a simple path from s to t in the residual network Gf . By the definition of the resid- ual network, we may increase the flow on an edge .u;􏳪/ of an augmenting path by up to cf .u; 􏳪/ without violating the capacity constraint on whichever of .u; 􏳪/ and .􏳪; u/ is in the original flow network G.
The shaded path in Figure 26.4(b) is an augmenting path. Treating the residual network Gf in the figure as a flow network, we can increase the flow through each edge of this path by up to 4 units without violating a capacity constraint, since the smallest residual capacity on this path is cf .􏳪2;􏳪3/ D 4. We call the maximum amount by which we can increase the flow on each edge in an augmenting path p the residual capacity of p, given by
cf .p/ D min fcf .u; 􏳪/ W .u; 􏳪/ is on pg :

720 Chapter 26 Maximum Flow
The following lemma, whose proof we leave as Exercise 26.2-7, makes the above argument more precise.
Lemma 26.2
LetG D.V;E/beaflownetwork,letf beaflowinG,andletpbeanaugmenting pathinGf.Defineafunctionfp WV 􏳨V !Rby
(
cf .p/ if .u;􏳪/ is on p ; (26.8) 0 otherwise :
fp.u;􏳪/ D
Then,fp isaflowinGf withvaluejfpjDcf.p/>0.
The following corollary shows that if we augment f by fp, we get another flow in G whose value is closer to the maximum. Figure 26.4(c) shows the result of augmenting the flow f from Figure 26.4(a) by the flow fp in Figure 26.4(b), and Figure 26.4(d) shows the ensuing residual network.
Corollary 26.3
Let G D .V;E/ be a flow network, let f be a flow in G, and let p be an augmenting path in Gf . Let fp be defined as in equation (26.8), and suppose that we augment f by fp. Then the function f “fp is a flow in G with value jf “fpjDjfjCjfpj>jfj.
Proof Immediate from Lemmas 26.1 and 26.2. Cuts of flow networks
The Ford-Fulkerson method repeatedly augments the flow along augmenting paths until it has found a maximum flow. How do we know that when the algorithm terminates, we have actually found a maximum flow? The max-flow min-cut theo- rem, which we shall prove shortly, tells us that a flow is maximum if and only if its residual network contains no augmenting path. To prove this theorem, though, we must first explore the notion of a cut of a flow network.
A cut .S;T/ of flow network G D .V;E/ is a partition of V into S and T DV 􏳣S such that s 2 S and t 2 T. (This definition is similar to the def- inition of “cut” that we used for minimum spanning trees in Chapter 23, except that here we are cutting a directed graph rather than an undirected graph, and we insist that s 2 S and t 2 T.) If f is a flow, then the net flow f.S;T/ across the
cut .S; T / is defined to be
XX XX
f .S; T / D f .u; 􏳪/ 􏳣 f .􏳪; u/ : (26.9) u2S 􏳪2T u2S 􏳪2T

26.2 The Ford-Fulkerson method 721
v1 12/12 v3 st
v2 11/14 v4 ST
Figure 26.5 A cut .S;T/ in the flow network of Figure 26.1(b), where S D fs;􏳪1;􏳪2g and T Df􏳪3;􏳪4;tg. The vertices in S are black, and the vertices in T are white. The net flow across .S;T/ is f.S;T/ D 19, and the capacity is c.S;T/ D 26.
The capacity of the cut .S; T / is XX
c.u; 􏳪/ : (26.10)
A minimum cut of a network is a cut whose capacity is minimum over all cuts of the network.
The asymmetry between the definitions of flow and capacity of a cut is inten- tional and important. For capacity, we count only the capacities of edges going from S to T , ignoring edges in the reverse direction. For flow, we consider the flow going from S to T minus the flow going in the reverse direction from T to S. The reason for this difference will become clear later in this section.
Figure 26.5 shows the cut .fs;􏳪1;􏳪2g;f􏳪3;􏳪4;tg/ in the flow network of Fig- ure 26.1(b). The net flow across this cut is
f.􏳪1;􏳪3/Cf.􏳪2;􏳪4/􏳣f.􏳪3;􏳪2/ D 12C11􏳣4 D 19;
and the capacity of this cut is
c.􏳪1;􏳪3/ C c.􏳪2;􏳪4/ D 12 C 14 D 26:
The following lemma shows that, for a given flow f , the net flow across any cut is the same, and it equals jf j, the value of the flow.
Lemma 26.4
Letf beaflowinaflownetworkGwithsourcesandsinkt,andlet.S;T/beany cutofG. Thenthenetflowacross.S;T/isf.S;T/Djfj.
c.S; T / D
u2S 􏳪2T
11/16
4/4
1/4
7/7
4/9
8/13
15/20

722 Chapter 26 Maximum Flow
Proof We can rewrite the flow-conservation condition for any node u 2 V 􏳣fs; tg
as
XX
􏳪2V
f .u; 􏳪/ 􏳣 f .􏳪; u/ D 0 : (26.11) 􏳪2V
Taking the definition of jf j from equation (26.1) and adding the left-hand side of equation (26.11), which equals 0, summed over all vertices in S 􏳣 fsg, gives
XXXXX
XXXXXX
jfjD f.s;􏳪/􏳣 f.􏳪;s/C f.u;􏳪/􏳣 􏳪2V 􏳪2V u2S􏳣fsg 􏳪2V
f .􏳪; s/ C
Expanding the right-hand summation and regrouping terms yields
jf j D f .s; 􏳪/ 􏳣 􏳪2V
􏳪2V
u2S􏳣fsg 􏳪2V
f .u; 􏳪/ 􏳣 f .􏳪; u/ : 􏳪2V
u2S􏳣fsg 􏳪2V XX!XX!
D f.s;􏳪/C f.u;􏳪/ 􏳣 f.􏳪;s/C 􏳪2V u2S􏳣fsg 􏳪2V
D f .u; 􏳪/ 􏳣 f .􏳪; u/ : 􏳪2V u2S 􏳪2V u2S
f.􏳪;u/
u2S􏳣fsg
XX XX
BecauseV DS[T andS\T D;,wecanspliteachsummationoverV into
summations over S and T to obtain XXXXXXXX
jfjD f.u;􏳪/C f.u;􏳪/􏳣 f.􏳪;u/􏳣 f.􏳪;u/
D
f.u;􏳪/􏳣 f.􏳪;u/ 􏳪2T u2S
􏳪2S u2S 􏳪2T u2S 􏳪2S u2S XX XX
􏳪2T u2S
􏳪2T u2S
!
C
f.u;􏳪/􏳣 f.􏳪;u/ : 􏳪2S u2S
XX XX
􏳪2S u2S
The two summations within the parentheses are actually the same, since for all vertices x; y 2 V , the term f .x; y/ appears once in each summation. Hence, these summations cancel, and we have
XX XX
jfjD f.u;􏳪/􏳣 f.􏳪;u/ u2S 􏳪2T u2S 􏳪2T
D f.S;T/:
A corollary to Lemma 26.4 shows how we can use cut capacities to bound the value of a flow.
!
f.􏳪;u/

26.2 The Ford-Fulkerson method 723
Corollary 26.5
The value of any flow f in a flow network G is bounded from above by the capacity of any cut of G.
Proof Let .S;T/ be any cut of G and let f be any flow. By Lemma 26.4 and the capacity constraint,
jfj D D
􏳥
􏳥 D
f.S;T/
XX XX
u2S 􏳪2T XX
u2S 􏳪2T XX
f.u;􏳪/􏳣 f.􏳪;u/ u2S 􏳪2T
f.u;􏳪/
c.u;􏳪/ c.S;T/:
u2S 􏳪2T
Corollary 26.5 yields the immediate consequence that the value of a maximum flow in a network is bounded from above by the capacity of a minimum cut of the network. The important max-flow min-cut theorem, which we now state and prove, says that the value of a maximum flow is in fact equal to the capacity of a minimum cut.
Theorem 26.6 (Max-flow min-cut theorem)
Iff isaflowinaflownetworkGD.V;E/withsourcesandsinkt,thenthe following conditions are equivalent:
1. f isamaximumflowinG.
2. The residual network Gf contains no augmenting paths. 3. jfjDc.S;T/forsomecut.S;T/ofG.
Proof .1/ ) .2/: Suppose for the sake of contradiction that f is a maximum flow in G but that Gf has an augmenting path p. Then, by Corollary 26.3, the flow found by augmenting f by fp , where fp is given by equation (26.8), is a flow in G with value strictly greater than jf j, contradicting the assumption that f is a maximum flow.
.2/ ) .3/: Suppose that Gf has no augmenting path, that is, that Gf contains no path from s to t. Define
SDf􏳪2V Wthereexistsapathfromsto􏳪inGfg
and T D V 􏳣 S. The partition .S; T / is a cut: we have s 2 S trivially and t 62 S because there is no path from s to t in Gf . Now consider a pair of vertices

724 Chapter 26 Maximum Flow
u2Sand􏳪2T. If.u;􏳪/2E,wemusthavef.u;􏳪/Dc.u;􏳪/,since otherwise .u;􏳪/ 2 Ef , which would place 􏳪 in set S. If .􏳪;u/ 2 E, we must have f .􏳪; u/ D 0, because otherwise cf .u; 􏳪/ D f .􏳪; u/ would be positive and we would have .u;􏳪/ 2 Ef , which would place 􏳪 in S. Of course, if neither .u;􏳪/
nor .􏳪;u/ is in E, then f.u;􏳪/ D f.􏳪;u/ D 0. We thus have XX XX
f.S;T/ D f.u;􏳪/􏳣 f.􏳪;u/ u2S 􏳪2T 􏳪2T u2S
XX XX
D c.u;􏳪/􏳣 0 u2S 􏳪2T 􏳪2T u2S
D c.S;T/:
By Lemma 26.4, therefore, jf j D f .S; T / D c.S; T /.
.3/ ) .1/: By Corollary 26.5, jf j 􏳥 c.S; T / for all cuts .S; T /. The condition
jf j D c.S; T / thus implies that f is a maximum flow. The basic Ford-Fulkerson algorithm
In each iteration of the Ford-Fulkerson method, we find some augmenting path p and use p to modify the flow f . As Lemma 26.2 and Corollary 26.3 suggest, we replace f by f ” fp , obtaining a new flow whose value is jf j C jfp j. The follow- ing implementation of the method computes the maximum flow in a flow network G D .V; E/ by updating the flow attribute .u; 􏳪/:f for each edge .u; 􏳪/ 2 E.1 If .u; 􏳪/ 62 E, we assume implicitly that .u; 􏳪/:f D 0. We also assume that we are given the capacities c.u;􏳪/ along with the flow network, and c.u;􏳪/ D 0 if .u;􏳪/ 62 E. We compute the residual capacity cf .u;􏳪/ in accordance with the formula (26.2). The expression cf .p/ in the code is just a temporary variable that stores the residual capacity of the path p.
FORD-FULKERSON.G; s; t/
1 2 3 4 5 6 7 8
for each edge .u; 􏳪/ 2 G:E .u;􏳪/:f D 0
while there exists a path p from s to t in the residual network Gf cf .p/ D minfcf .u;􏳪/ W .u;􏳪/ is in pg
for each edge .u; 􏳪/ in p
if .u;􏳪/ 2 E
.u;􏳪/:f D.u;􏳪/:fCcf.p/
else.􏳪;u/:f D.􏳪;u/:f􏳣cf.p/
1Recall from Section 22.1 that we represent an attribute f for edge .u;􏳪/ with the same style of notation—.u;􏳪/:f—that we use for an attribute of any other object.

26.2 The Ford-Fulkerson method 725
The FORD-FULKERSON algorithm simply expands on the FORD-FULKERSON- METHOD pseudocode given earlier. Figure 26.6 shows the result of each iteration in a sample run. Lines 1–2 initialize the flow f to 0. The while loop of lines 3–8 repeatedly finds an augmenting path p in Gf and augments flow f along p by the residual capacity cf .p/. Each residual edge in path p is either an edge in the original network or the reversal of an edge in the original network. Lines 6–8 update the flow in each case appropriately, adding flow when the residual edge is an original edge and subtracting it otherwise. When no augmenting paths exist, the flow f is a maximum flow.
Analysis of Ford-Fulkerson
The running time of FORD-FULKERSON depends on how we find the augmenting path p in line 3. If we choose it poorly, the algorithm might not even terminate: the value of the flow will increase with successive augmentations, but it need not even converge to the maximum flow value.2 If we find the augmenting path by using a breadth-first search (which we saw in Section 22.2), however, the algorithm runs in polynomial time. Before proving this result, we obtain a simple bound for the case in which we choose the augmenting path arbitrarily and all capacities are integers.
In practice, the maximum-flow problem often arises with integral capacities. If the capacities are rational numbers, we can apply an appropriate scaling transfor- mation to make them all integral. If f 􏳤 denotes a maximum flow in the transformed network, then a straightforward implementation of FORD-FULKERSON executes the while loop of lines 3–8 at most jf 􏳤j times, since the flow value increases by at least one unit in each iteration.
We can perform the work done within the while loop efficiently if we implement the flow network G D .V; E/ with the right data structure and find an augmenting path by a linear-time algorithm. Let us assume that we keep a data structure cor- responding to a directed graph G0 D .V; E0/, where E0 D f.u; 􏳪/ W .u; 􏳪/ 2 E or .􏳪;u/ 2 Eg. Edges in the network G are also edges in G0, and therefore we can easily maintain capacities and flows in this data structure. Given a flow f on G, the edges in the residual network Gf consist of all edges .u;􏳪/ of G0 such that cf .u;􏳪/ > 0, where cf conforms to equation (26.2). The time to find a path in a residual network is therefore O.V C E0/ D O.E/ if we use either depth-first search or breadth-first search. Each iteration of the while loop thus takes O.E/ time, as does the initialization in lines 1–2, making the total running time of the FORD-FULKERSON algorithm O.E jf 􏳤j/.
2The Ford-Fulkerson method might fail to terminate only if edge capacities are irrational numbers.

726 Chapter 26 Maximum Flow
v 12 v v 4/12 v 13 13
(a)s ts t
v2 v4 14
v 8 v 13
v2 4/14 v4 v 8/12 v
13
4
(b)s ts t
10
v2 v4 4
v 4 v 13
v2 4/14 v4 v 8/12 v
13
8
(c)s ts t
v10v vv 2 4 2 4/14 4
Figure 26.6 The execution of the basic Ford-Fulkerson algorithm. (a)–(e) Successive iterations of the while loop. The left side of each part shows the residual network Gf from line 3 with a shaded augmenting path p. The right side of each part shows the new flow f that results from augmenting f by fp. The residual network in (a) is the input network G.
When the capacities are integral and the optimal flow value jf 􏳤j is small, the running time of the Ford-Fulkerson algorithm is good. Figure 26.7(a) shows an ex- ample of what can happen on a simple flow network for which jf 􏳤j is large. A max- imum flow in this network has value 2,000,000: 1,000,000 units of flow traverse the path s ! u ! t, and another 1,000,000 units traverse the path s ! 􏳪 ! t. If the first augmenting path found by FORD-FULKERSON is s ! u ! 􏳪 ! t, shown in Figure 26.7(a), the flow has value 1 after the first iteration. The resulting resid- ual network appears in Figure 26.7(b). If the second iteration finds the augment- ing path s ! 􏳪 ! u ! t, as shown in Figure 26.7(b), the flow then has value 2. Figure 26.7(c) shows the resulting residual network. We can continue, choosing the augmenting path s ! u ! 􏳪 ! t in the odd-numbered iterations and the aug- menting path s ! 􏳪 ! u ! t in the even-numbered iterations. We would perform a total of 2,000,000 augmentations, increasing the flow value by only 1 unit in each.
4
44
4
7
77
4 4/4 4
777
12 4
4
12 4
4
16
4
8/16
4/4
4/16
4/4
4/16
4/4
4 5
4 5
9
9
4/9
4/9
13
20
13
16 4
20
9 4
13
4/20
4/13
8/20
20
4/13

(d) s
(e) s
(f) s
v4v 13
8
10
v2 v4 4
v4v 13
8
t
8/12 v v13
st v2 11/14 v4
12/12 v v13
26.2
The Ford-Fulkerson method
727
t
v3v v
2
4
st 2 11/14 v4
11
v1 12 v3
v3v 24
11
t
(f) The residual network at the last while loop test. It has no augmenting paths, and the flow f shown in (e) is therefore a maximum flow. The value of the maximum flow
found is 23.
The Edmonds-Karp algorithm
We can improve the bound on FORD-FULKERSON by finding the augmenting path p in line 3 with a breadth-first search. That is, we choose the augmenting path as a shortest path from s to t in the residual network, where each edge has unit distance (weight). We call the Ford-Fulkerson method so implemented the Edmonds-Karp algorithm. We now prove that the Edmonds-Karp algorithm runs in O.VE2/ time.
The analysis depends on the distances to vertices in the residual network Gf . The following lemma uses the notation ıf .u; 􏳪/ for the shortest-path distance from u to 􏳪 in Gf , where each edge has unit distance.
Lemma 26.7
If the Edmonds-Karp algorithm is run on a flow network G D .V; E/ with source s and sink t, then for all vertices 􏳪 2 V 􏳣 fs; tg, the shortest-path distance ıf .s; 􏳪/ in the residual network Gf increases monotonically with each flow augmentation.
Figure 26.6, continued
444
77
7
44
7/7 7/7
4 12
4
8 8
4
8 8
4
12/16
4/4
8/16
4/4
9
9
9
9
9
9 4
11/13
11 2
1 19
12 8
11 2
5 15
11/13
19/20
15/20

728 Chapter 26 Maximum Flow
uuu ststst vvv
(a) (b) (c)
Figure 26.7 (a) A flow network for which FORD-FULKERSON can take ‚.E jf 􏳤j/ time, where f 􏳤 is a maximum flow, shown here with jf 􏳤j D 2,000,000. The shaded path is an aug- menting path with residual capacity 1. (b) The resulting residual network, with another augmenting path whose residual capacity is 1. (c) The resulting residual network.
Proof We will suppose that for some vertex 􏳪 2 V 􏳣 fs; t g, there is a flow aug- mentation that causes the shortest-path distance from s to 􏳪 to decrease, and then we will derive a contradiction. Let f be the flow just before the first augmentation that decreases some shortest-path distance, and let f 0 be the flow just afterward. Let 􏳪 be the vertex with the minimum ıf 0 .s; 􏳪/ whose distance was decreased by the augmentation, so that ıf 0.s;􏳪/ < ıf .s;􏳪/. Let p D s Y u ! 􏳪 be a shortest pathfromsto􏳪inGf0,sothat.u;􏳪/2Ef0 and ıf 0 . s ; u / D ıf 0 . s ; 􏳪 / 􏳣 1 : ( 2 6 . 1 2 ) Because of how we chose 􏳪, we know that the distance of vertex u from the source s did not decrease, i.e., ıf 0.s;u/ 􏳦 ıf .s;u/ : (26.13) We claim that .u;􏳪/ 62 Ef . Why? If we had .u;􏳪/ 2 Ef , then we would also have ıf.s;􏳪/􏳥 ıf .s; u/ C 1 􏳥 ıf 0 .s; u/ C 1 D ıf 0 .s; 􏳪/ (by Lemma 24.10, the triangle inequality) (by inequality (26.13)) (by equation (26.12)) , which contradicts our assumption that ıf 0 .s; 􏳪/ < ıf .s; 􏳪/. How can we have .u; 􏳪/ 62 Ef and .u; 􏳪/ 2 Ef 0 ? The augmentation must have increased the flow from 􏳪 to u. The Edmonds-Karp algorithm always aug- ments flow along shortest paths, and therefore the shortest path from s to u in Gf has .􏳪; u/ as its last edge. Therefore, ıf.s;􏳪/ D 􏳥 D ıf.s;u/􏳣1 ıf 0 .s; u/ 􏳣 1 (by inequality (26.13)) ıf 0 .s; 􏳪/ 􏳣 2 (by equation (26.12)) , 1,000,000 1,000,000 999,999 1 999,999 1 999,999 1 999,999 1 1 1 1 1,000,000 1,000,000 1,000,000 1,000,000 999,999 1 999,999 1 26.2 The Ford-Fulkerson method 729 which contradicts our assumption that ıf 0 .s; 􏳪/ < ıf .s; 􏳪/. We conclude that our assumption that such a vertex 􏳪 exists is incorrect. The next theorem bounds the number of iterations of the Edmonds-Karp algo- rithm. Theorem 26.8 If the Edmonds-Karp algorithm is run on a flow network G D .V; E/ with source s and sink t , then the total number of flow augmentations performed by the algorithm is O.VE/. Proof We say that an edge .u; 􏳪/ in a residual network Gf is critical on an aug- menting path p if the residual capacity of p is the residual capacity of .u; 􏳪/, that is, if cf .p/ D cf .u; 􏳪/. After we have augmented flow along an augmenting path, any critical edge on the path disappears from the residual network. Moreover, at least one edge on any augmenting path must be critical. We will show that each of the jEj edges can become critical at most jV j =2 times. Let u and 􏳪 be vertices in V that are connected by an edge in E. Since augment- ing paths are shortest paths, when .u; 􏳪/ is critical for the first time, we have ıf . s ; 􏳪 / D ıf . s ; u / C 1 : Once the flow is augmented, the edge .u; 􏳪/ disappears from the residual network. It cannot reappear later on another augmenting path until after the flow from u to 􏳪 is decreased, which occurs only if .􏳪; u/ appears on an augmenting path. If f 0 is the flow in G when this event occurs, then we have ıf 0 . s ; u / D ıf 0 . s ; 􏳪 / C 1 : Since ıf .s; 􏳪/ 􏳥 ıf 0 .s; 􏳪/ by Lemma 26.7, we have ıf0.s;u/ D ıf0.s;􏳪/C1 􏳦 ıf.s;􏳪/C1 D ıf.s;u/C2: Consequently, from the time .u;􏳪/ becomes critical to the time when it next becomes critical, the distance of u from the source increases by at least 2. The distance of u from the source is initially at least 0. The intermediate vertices on a shortest path from s to u cannot contain s, u, or t (since .u; 􏳪/ on an augmenting path implies that u ¤ t). Therefore, until u becomes unreachable from the source, if ever, its distance is at most jV j 􏳣 2. Thus, after the first time that .u; 􏳪/ becomes critical, it can become critical at most .jV j 􏳣 2/=2 D jV j =2 􏳣 1 times more, for a total of at most jV j =2 times. Since there are O.E/ pairs of vertices that can have an edge between them in a residual network, the total number of critical edges during 730 Chapter 26 Maximum Flow the entire execution of the Edmonds-Karp algorithm is O.VE/. Each augmenting path has at least one critical edge, and hence the theorem follows. Because we can implement each iteration of FORD-FULKERSON in O.E/ time when we find the augmenting path by breadth-first search, the total running time of the Edmonds-Karp algorithm is O.VE2/. We shall see that push-relabel algorithms can yield even better bounds. The algorithm of Section 26.4 gives a method for achieving an O.V 2E/ running time, which forms the basis for the O.V 3/-time algorithm of Section 26.5. Exercises 26.2-1 Prove that the summations in equation (26.6) equal the summations in equa- tion (26.7). 26.2-2 In Figure 26.1(b), what is the flow across the cut .fs;􏳪2;􏳪4g;f􏳪1;􏳪3;tg/? What is the capacity of this cut? 26.2-3 Show the execution of the Edmonds-Karp algorithm on the flow network of Fig- ure 26.1(a). 26.2-4 In the example of Figure 26.6, what is the minimum cut corresponding to the max- imum flow shown? Of the augmenting paths appearing in the example, which one cancels flow? 26.2-5 Recall that the construction in Section 26.1 that converts a flow network with mul- tiple sources and sinks into a single-source, single-sink network adds edges with infinite capacity. Prove that any flow in the resulting network has a finite value if the edges of the original network with multiple sources and sinks have finite capacity. 26.2-6 Suppose that each source si in a flow network with multiple sources and sinks produces exactly p units of flow, so that P f .s ; 􏳪/ D p . Suppose also i 􏳪2Vii that each sink t consumes exactly q units, so that P PP f.􏳪;t / D q , where j j 􏳪2Vjj i pi D j qj . Show how to convert the problem of finding a flow f that obeys 26.2 The Ford-Fulkerson method 731 these additional constraints into the problem of finding a maximum flow in a single- source, single-sink flow network. 26.2-7 Prove Lemma 26.2. 26.2-8 Suppose that we redefine the residual network to disallow edges into s. Argue that the procedure FORD-FULKERSON still correctly computes a maximum flow. 26.2-9 Supposethatbothf andf0 areflowsinanetworkGandwecomputeflowf "f0. Does the augmented flow satisfy the flow conservation property? Does it satisfy the capacity constraint? 26.2-10 Show how to find a maximum flow in a network G D .V;E/ by a sequence of at most jEj augmenting paths. (Hint: Determine the paths after finding the maximum flow.) 26.2-11 The edge connectivity of an undirected graph is the minimum number k of edges that must be removed to disconnect the graph. For example, the edge connectivity of a tree is 1, and the edge connectivity of a cyclic chain of vertices is 2. Show how to determine the edge connectivity of an undirected graph G D .V;E/ by running a maximum-flow algorithm on at most jV j flow networks, each having O.V / vertices and O.E/ edges. 26.2-12 Suppose that you are given a flow network G, and G has edges entering the source s. Let f be a flow in G in which one of the edges .􏳪; s/ entering the source has f.􏳪;s/ D 1. Prove that there must exist another flow f 0 with f 0.􏳪;s/ D 0 such that jf j D jf 0j. Give an O.E/-time algorithm to compute f 0, given f , and assuming that all edge capacities are integers. 26.2-13 Suppose that you wish to find, among all minimum cuts in a flow network G with integral capacities, one that contains the smallest number of edges. Show how to modify the capacities of G to create a new flow network G0 in which any minimum cut in G0 is a minimum cut with the smallest number of edges in G. 732 Chapter 26 Maximum Flow 26.3 Maximum bipartite matching Some combinatorial problems can easily be cast as maximum-flow problems. The multiple-source, multiple-sink maximum-flow problem from Section 26.1 gave us one example. Some other combinatorial problems seem on the surface to have little to do with flow networks, but can in fact be reduced to maximum-flow problems. This section presents one such problem: finding a maximum matching in a bipartite graph. In order to solve this problem, we shall take advantage of an integrality property provided by the Ford-Fulkerson method. We shall also see how to use the Ford-Fulkerson method to solve the maximum-bipartite-matching problem on a graph G D .V; E/ in O.VE/ time. The maximum-bipartite-matching problem Given an undirected graph G D .V;E/, a matching is a subset of edges M 􏳧 E such that for all vertices 􏳪 2 V , at most one edge of M is incident on 􏳪. We say that a vertex 􏳪 2 V is matched by the matching M if some edge in M is incident on 􏳪; otherwise, 􏳪 is unmatched. A maximum matching is a matching of maximum cardinality, that is, a matching M such that for any matching M0, we have jM j 􏳦 jM 0 j. In this section, we shall restrict our attention to finding maximum matchings in bipartite graphs: graphs in which the vertex set can be partitioned into V D L [ R, where L and R are disjoint and all edges in E go between L and R. We further assume that every vertex in V has at least one incident edge. Figure 26.8 illustrates the notion of a matching in a bipartite graph. The problem of finding a maximum matching in a bipartite graph has many practical applications. As an example, we might consider matching a set L of ma- chines with a set R of tasks to be performed simultaneously. We take the presence of edge .u;􏳪/ in E to mean that a particular machine u 2 L is capable of per- forming a particular task 􏳪 2 R. A maximum matching provides work for as many machines as possible. Finding a maximum bipartite matching We can use the Ford-Fulkerson method to find a maximum matching in an undi- rected bipartite graph G D .V; E/ in time polynomial in jV j and jEj. The trick is to construct a flow network in which flows correspond to matchings, as shown in Figure 26.8(c). We define the corresponding flow network G0 D .V 0; E0/ for the bipartite graph G as follows. We let the source s and sink t be new vertices not inV,andweletV0 DV [fs;tg. IfthevertexpartitionofGisV DL[R,the 26.3 Maximum bipartite matching 733 st LRLR LR (a) (b) (c) Figure 26.8 A bipartite graph G D .V; E/ with vertex partition V D L [ R. (a) A matching with cardinality 2, indicated by shaded edges. (b) A maximum matching with cardinality 3. (c) The corresponding flow network G0 with a maximum flow shown. Each edge has unit capacity. Shaded edges have a flow of 1, and all other edges carry no flow. The shaded edges from L to R correspond to those in the maximum matching from (b). directed edges of G0 are the edges of E, directed from L to R, along with jV j new directed edges: E0 Df.s;u/Wu2Lg[f.u;􏳪/W.u;􏳪/2Eg[f.􏳪;t/W􏳪2Rg : To complete the construction, we assign unit capacity to each edge in E0. Since each vertex in V has at least one incident edge, jEj 􏳦 jV j =2. Thus, jEj 􏳥 jE0j D jEj C jV j 􏳥 3 jEj, and so jE0j D ‚.E/. The following lemma shows that a matching in G corresponds directly to a flow in G’s corresponding flow network G0. We say that a flow f on a flow network GD.V;E/isinteger-valuediff.u;􏳪/isanintegerforall.u;􏳪/2V 􏳨V. Lemma 26.9 Let G D .V; E/ be a bipartite graph with vertex partition V D L [ R, and let G0 D .V 0; E0/ be its corresponding flow network. If M is a matching in G, then there is an integer-valued flow f in G0 with value jf j D jM j. Conversely, if f is an integer-valued flow in G0, then there is a matching M in G with cardinality jM j D jf j. Proof We first show that a matching M in G corresponds to an integer-valued flow f in G0. Define f as follows. If .u;􏳪/ 2 M, then f.s;u/ D f.u;􏳪/ D f.􏳪;t/ D 1. For all other edges .u;􏳪/ 2 E0, we define f.u;􏳪/ D 0. It is simple to verify that f satisfies the capacity constraint and flow conservation. 734 Chapter 26 Maximum Flow Intuitively, each edge .u;􏳪/ 2 M corresponds to one unit of flow in G0 that traverses the path s ! u ! 􏳪 ! t. Moreover, the paths induced by edges in M arevertex-disjoint,exceptforsandt. Thenetflowacrosscut.L[fsg;R[ftg/ is equal to jMj; thus, by Lemma 26.4, the value of the flow is jf j D jMj. To prove the converse, let f be an integer-valued flow in G0, and let M Df.u;􏳪/Wu2L;􏳪2R; andf.u;􏳪/>0g :
Each vertex u 2 L has only one entering edge, namely .s;u/, and its capacity is 1. Thus, each u 2 L has at most one unit of flow entering it, and if one unit of flow does enter, by flow conservation, one unit of flow must leave. Furthermore, since f is integer-valued, for each u 2 L, the one unit of flow can enter on at most one edge and can leave on at most one edge. Thus, one unit of flow enters u if and only if there is exactly one vertex 􏳪 2 R such that f.u;􏳪/ D 1, and at most one edge leaving each u 2 L carries positive flow. A symmetric argument applies to each 􏳪 2 R. The set M is therefore a matching.
To see that jM j D jf j, observe that for every matched vertex u 2 L, we have f.s;u/ D 1, and for every edge .u;􏳪/ 2 E 􏳣 M, we have f.u;􏳪/ D 0. Conse- quently, f .L [ fsg ; R [ ftg/, the net flow across cut .L [ fsg ; R [ ftg/, is equal to jMj. Applying Lemma 26.4, we have that jf j D f.L[fsg;R[ftg/ D jMj.
Based on Lemma 26.9, we would like to conclude that a maximum matching in a bipartite graph G corresponds to a maximum flow in its corresponding flow network G0, and we can therefore compute a maximum matching in G by running a maximum-flow algorithm on G0. The only hitch in this reasoning is that the maximum-flow algorithm might return a flow in G0 for which some f.u;􏳪/ is not an integer, even though the flow value jf j must be an integer. The following theorem shows that if we use the Ford-Fulkerson method, this difficulty cannot arise.
Theorem 26.10 (Integrality theorem)
If the capacity function c takes on only integral values, then the maximum flow f produced by the Ford-Fulkerson method has the property that jf j is an integer. Moreover, for all vertices u and 􏳪, the value of f .u; 􏳪/ is an integer.
Proof The proof is by induction on the number of iterations. We leave it as Exercise 26.3-2.
We can now prove the following corollary to Lemma 26.9.

26.3 Maximum bipartite matching 735
Corollary 26.11
The cardinality of a maximum matching M in a bipartite graph G equals the value of a maximum flow f in its corresponding flow network G0.
Proof We use the nomenclature from Lemma 26.9. Suppose that M is a max- imum matching in G and that the corresponding flow f in G0 is not maximum. Then there is a maximum flow f0 in G0 such that jf0j > jfj. Since the ca- pacities in G0 are integer-valued, by Theorem 26.10, we can assume that f 0 is integer-valued. Thus, f0 corresponds to a matching M0 in G with cardinality jM 0j D jf 0j > jf j D jM j, contradicting our assumption that M is a maximum matching. In a similar manner, we can show that if f is a maximum flow in G0, its corresponding matching is a maximum matching on G.
Thus, given a bipartite undirected graph G, we can find a maximum matching by creating the flow network G0, running the Ford-Fulkerson method, and directly ob- taining a maximum matching M from the integer-valued maximum flow f found. Since any matching in a bipartite graph has cardinality at most min.L; R/ D O.V /, the value of the maximum flow in G0 is O.V /. We can therefore find a maximum matching in a bipartite graph in time O.VE0/ D O.VE/, since jE0j D ‚.E/.
Exercises
26.3-1
Run the Ford-Fulkerson algorithm on the flow network in Figure 26.8(c) and show the residual network after each flow augmentation. Number the vertices in L top to bottom from 1 to 5 and in R top to bottom from 6 to 9. For each iteration, pick the augmenting path that is lexicographically smallest.
26.3-2
Prove Theorem 26.10.
26.3-3
Let G D .V; E/ be a bipartite graph with vertex partition V D L [ R, and let G0 be its corresponding flow network. Give a good upper bound on the length of any augmenting path found in G0 during the execution of FORD-FULKERSON.
26.3-4 ?
A perfect matching is a matching in which every vertex is matched. Let G D .V; E/ be an undirected bipartite graph with vertex partition V D L [ R, where jLj D jRj. For any X 􏳧 V , define the neighborhood of X as
N.X/ D fy 2 V W .x;y/ 2 E for some x 2 Xg ;

736
Chapter 26 Maximum Flow
? 26.4
that is, the set of vertices adjacent to some member of X. Prove Hall’s theorem: there exists a perfect matching in G if and only if jAj 􏳥 jN.A/j for every subset A 􏳧 L.
26.3-5 ?
We say that a bipartite graph G D .V;E/, where V D L[R, is d-regular if every vertex 􏳪 2 V has degree exactly d . Every d -regular bipartite graph has jLj D jRj. Prove that every d-regular bipartite graph has a matching of cardinality jLj by arguing that a minimum cut of the corresponding flow network has capacity jLj.
Push-relabel algorithms
In this section, we present the “push-relabel” approach to computing maximum flows. To date, many of the asymptotically fastest maximum-flow algorithms are push-relabel algorithms, and the fastest actual implementations of maximum-flow algorithms are based on the push-relabel method. Push-relabel methods also effi- ciently solve other flow problems, such as the minimum-cost flow problem. This section introduces Goldberg’s “generic” maximum-flow algorithm, which has a simple implementation that runs in O.V 2E/ time, thereby improving upon the O.VE2/ bound of the Edmonds-Karp algorithm. Section 26.5 refines the generic algorithm to obtain another push-relabel algorithm that runs in O.V 3/ time.
Push-relabel algorithms work in a more localized manner than the Ford- Fulkerson method. Rather than examine the entire residual network to find an aug- menting path, push-relabel algorithms work on one vertex at a time, looking only at the vertex’s neighbors in the residual network. Furthermore, unlike the Ford- Fulkerson method, push-relabel algorithms do not maintain the flow-conservation property throughout their execution. They do, however, maintain a preflow, which is a function f W V 􏳨V ! R that satisfies the capacity constraint and the following relaxation of flow conservation:
XX
f .􏳪; u/ 􏳣 f .u; 􏳪/ 􏳦 0 􏳪2V
􏳪2V
for all vertices u 2 V 􏳣 fsg. That is, the flow into a vertex may exceed the flow
out. We call the quantity
XX
e.u/ D f .􏳪; u/ 􏳣 f .u; 􏳪/ (26.14) 􏳪2V 􏳪2V
the excess flow into vertex u. The excess at a vertex is the amount by which the flow in exceeds the flow out. We say that a vertex u 2 V 􏳣 fs; tg is overflowing if e.u/ > 0.

26.4 Push-relabel algorithms 737
We shall begin this section by describing the intuition behind the push-relabel method. We shall then investigate the two operations employed by the method: “pushing” preflow and “relabeling” a vertex. Finally, we shall present a generic push-relabel algorithm and analyze its correctness and running time.
Intuition
You can understand the intuition behind the push-relabel method in terms of fluid flows: we consider a flow network G D .V;E/ to be a system of interconnected pipes of given capacities. Applying this analogy to the Ford-Fulkerson method, we might say that each augmenting path in the network gives rise to an additional stream of fluid, with no branch points, flowing from the source to the sink. The Ford-Fulkerson method iteratively adds more streams of flow until no more can be added.
The generic push-relabel algorithm has a rather different intuition. As before, directed edges correspond to pipes. Vertices, which are pipe junctions, have two interesting properties. First, to accommodate excess flow, each vertex has an out- flow pipe leading to an arbitrarily large reservoir that can accumulate fluid. Second, each vertex, its reservoir, and all its pipe connections sit on a platform whose height increases as the algorithm progresses.
Vertex heights determine how flow is pushed: we push flow only downhill, that is, from a higher vertex to a lower vertex. The flow from a lower vertex to a higher vertex may be positive, but operations that push flow push it only downhill. We fix the height of the source at jV j and the height of the sink at 0. All other vertex heights start at 0 and increase with time. The algorithm first sends as much flow as possible downhill from the source toward the sink. The amount it sends is exactly enough to fill each outgoing pipe from the source to capacity; that is, it sends the capacity of the cut .s; V 􏳣 fsg/. When flow first enters an intermediate vertex, it collects in the vertex’s reservoir. From there, we eventually push it downhill.
We may eventually find that the only pipes that leave a vertex u and are not already saturated with flow connect to vertices that are on the same level as u or are uphill from u. In this case, to rid an overflowing vertex u of its excess flow, we must increase its height—an operation called “relabeling” vertex u. We increase its height to one unit more than the height of the lowest of its neighbors to which it has an unsaturated pipe. After a vertex is relabeled, therefore, it has at least one outgoing pipe through which we can push more flow.
Eventually, all the flow that can possibly get through to the sink has arrived there. No more can arrive, because the pipes obey the capacity constraints; the amount of flow across any cut is still limited by the capacity of the cut. To make the preflow a “legal” flow, the algorithm then sends the excess collected in the reservoirs of overflowing vertices back to the source by continuing to relabel vertices to above

738 Chapter 26 Maximum Flow
the fixed height jV j of the source. As we shall see, once we have emptied all the reservoirs, the preflow is not only a “legal” flow, it is also a maximum flow.
The basic operations
From the preceding discussion, we see that a push-relabel algorithm performs two basic operations: pushing flow excess from a vertex to one of its neighbors and relabeling a vertex. The situations in which these operations apply depend on the heights of vertices, which we now define precisely.
Let G D .V;E/ be a flow network with source s and sink t, and let f be a preflow in G. A function h W V ! N is a height function3 if h.s/ D jVj, h.t/ D 0, and
h.u/ 􏳥 h.􏳪/ C 1
for every residual edge .u; 􏳪/ 2 Ef . We immediately obtain the following lemma.
Lemma 26.12
LetGD.V;E/beaflownetwork,letf beapreflowinG,andlethbeaheight function on V . For any two vertices u; 􏳪 2 V , if h.u/ > h.􏳪/ C 1, then .u; 􏳪/ is not an edge in the residual network.
The push operation
The basic operation PUSH.u; 􏳪/ applies if u is an overflowing vertex, cf .u; 􏳪/ > 0, and h.u/ D h.􏳪/C1. The pseudocode below updates the preflow f and the excess flows for u and 􏳪. It assumes that we can compute residual capacity cf .u;􏳪/ in constant time given c and f . We maintain the excess flow stored at a vertex u as the attribute u:e and the height of u as the attribute u:h. The expression 􏳱f .u;􏳪/ is a temporary variable that stores the amount of flow that we can push from u to 􏳪.
3In the literature, a height function is typically called a “distance function,” and the height of a vertex is called a “distance label.” We use the term “height” because it is more suggestive of the intuition behind the algorithm. We retain the use of the term “relabel” to refer to the operation that increases the height of a vertex. The height of a vertex is related to its distance from the sink t, as would be found in a breadth-first search of the transpose GT.

26.4 Push-relabel algorithms 739
PUSH.u; 􏳪/
1 //Applieswhen:uisoverflowing,cf.u;􏳪/>0,andu:hD􏳪:hC1.
2 //Action:Push􏳱f.u;􏳪/Dmin.u:e;cf.u;􏳪//unitsofflowfromuto􏳪.
3 􏳱f .u;􏳪/ D min.u:e;cf .u;􏳪//
4 if.u;􏳪/2E
5 .u;􏳪/:f D.u;􏳪/:fC􏳱f.u;􏳪/
6 else.􏳪;u/:fD.􏳪;u/:f􏳣􏳱f.u;􏳪/
7 u:eDu:e􏳣􏳱f.u;􏳪/
8 􏳪:eD􏳪:eC􏳱f.u;􏳪/
The code for PUSH operates as follows. Because vertex u has a positive excess u:e and the residual capacity of .u; 􏳪/ is positive, we can increase the flow from u to 􏳪 by 􏳱f .u;􏳪/ D min.u:e;cf .u;􏳪// without causing u:e to become negative or the capacity c.u; 􏳪/ to be exceeded. Line 3 computes the value 􏳱f .u; 􏳪/, and lines 4–6 update f . Line 5 increases the flow on edge .u; 􏳪/, because we are pushing flow over a residual edge that is also an original edge. Line 6 decreases the flow on edge .􏳪;u/, because the residual edge is actually the reverse of an edge in the original network. Finally, lines 7–8 update the excess flows into vertices u and 􏳪. Thus, if f is a preflow before PUSH is called, it remains a preflow afterward.
Observe that nothing in the code for PUSH depends on the heights of u and 􏳪, yet we prohibit it from being invoked unless u: h D 􏳪: h C 1. Thus, we push excess flow downhill only by a height differential of 1. By Lemma 26.12, no residual edges exist between two vertices whose heights differ by more than 1, and thus, as long as the attribute h is indeed a height function, we would gain nothing by allowing flow to be pushed downhill by a height differential of more than 1.
We call the operation PUSH.u;􏳪/ a push from u to 􏳪. If a push operation ap- plies to some edge .u;􏳪/ leaving a vertex u, we also say that the push operation applies to u. It is a saturating push if edge .u; 􏳪/ in the residual network becomes saturated (cf .u;􏳪/ D 0 afterward); otherwise, it is a nonsaturating push. If an edge becomes saturated, it disappears from the residual network. A simple lemma characterizes one result of a nonsaturating push.
Lemma 26.13
After a nonsaturating push from u to 􏳪, the vertex u is no longer overflowing.
Proof Since the push was nonsaturating, the amount of flow 􏳱f .u;􏳪/ actually pushed must equal u:e prior to the push. Since u:e is reduced by this amount, it becomes 0 after the push.

740 Chapter 26 Maximum Flow
The relabel operation
The basic operation RELABEL.u/ applies if u is overflowing and if u:h 􏳥 􏳪:h for all edges .u;􏳪/ 2 Ef . In other words, we can relabel an overflowing vertex u if for every vertex 􏳪 for which there is residual capacity from u to 􏳪, flow cannot be pushed from u to 􏳪 because 􏳪 is not downhill from u. (Recall that by definition, neither the source s nor the sink t can be overflowing, and so s and t are ineligible for relabeling.)
RELABEL.u/
1 //Applies when: u is overflowing and for all 􏳪 2 V such that .u;􏳪/ 2 Ef , we have u:h 􏳥 􏳪:h.
2 //Action:Increasetheheightofu. 3 u:hD1Cminf􏳪:hW.u;􏳪/2Efg
When we call the operation RELABEL.u/, we say that vertex u is relabeled. Note that when u is relabeled, Ef must contain at least one edge that leaves u, so that the minimization in the code is over a nonempty set. This property follows from
the assumption that u is overflowing, which in turn tells us that XX
u:e D f .􏳪; u/ 􏳣 f .u; 􏳪/ > 0 : 􏳪2V 􏳪2V
Since all flows are nonnegative, we must therefore have at least one vertex 􏳪 such that .􏳪;u/:f > 0. But then, cf .u;􏳪/ > 0, which implies that .u;􏳪/ 2 Ef . The operation RELABEL.u/ thus gives u the greatest height allowed by the constraints on height functions.
The generic algorithm
The generic push-relabel algorithm uses the following subroutine to create an ini- tial preflow in the flow network.
INITIALIZE-PREFLOW.G;s/
1 2 3 4 5 6 7 8 9
10
for each vertex 􏳪 2 G:V 􏳪:h D 0
􏳪:e D 0
for each edge .u; 􏳪/ 2 G:E
.u;􏳪/:f D 0 s:h D jG:Vj
for each vertex 􏳪 2 s:Adj .s;􏳪/:f D c.s;􏳪/
􏳪:e D c.s;􏳪/
s:e D s:e􏳣c.s;􏳪/

26.4 Push-relabel algorithms 741
INITIALIZE-PREFLOW creates an initial preflow f defined by (
.u;􏳪/:f D
c.u;􏳪/ if u D s ; (26.15) 0 otherwise :
That is, we fill to capacity each edge leaving the source s, and all other edges carry no flow. For each vertex 􏳪 adjacent to the source, we initially have 􏳪:e D c.s;􏳪/, and we initialize s:e to the negative of the sum of these capacities. The generic algorithm also begins with an initial height function h, given by
(
u:hD jVj ifuDs; (26.16) 0 otherwise :
Equation (26.16) defines a height function because the only edges .u; 􏳪/ for which u:h > 􏳪:h C 1 are those for which u D s, and those edges are saturated, which means that they are not in the residual network.
Initialization, followed by a sequence of push and relabel operations, executed in no particular order, yields the GENERIC-PUSH-RELABEL algorithm:
GENERIC-PUSH-RELABEL.G/
1 INITIALIZE-PREFLOW.G;s/
2 while there exists an applicable push or relabel operation
3 select an applicable push or relabel operation and perform it
The following lemma tells us that as long as an overflowing vertex exists, at least one of the two basic operations applies.
Lemma 26.14 (An overflowing vertex can be either pushed or relabeled)
Let G D .V;E/ be a flow network with source s and sink t, let f be a preflow, and let h be any height function for f . If u is any overflowing vertex, then either a push or relabel operation applies to it.
Proof For any residual edge .u; 􏳪/, we have h.u/ 􏳥 h.􏳪/ C 1 because h is a height function. If a push operation does not apply to an overflowing vertex u, then for all residual edges .u; 􏳪/, we must have h.u/ < h.􏳪/ C 1, which implies h.u/ 􏳥 h.􏳪/. Thus, a relabel operation applies to u. Correctness of the push-relabel method To show that the generic push-relabel algorithm solves the maximum-flow prob- lem, we shall first prove that if it terminates, the preflow f is a maximum flow. We shall later prove that it terminates. We start with some observations about the height function h. 742 Chapter 26 Maximum Flow Lemma 26.15 (Vertex heights never decrease) During the execution of the GENERIC-PUSH-RELABEL procedure on a flow net- workGD.V;E/,foreachvertexu2V,theheightu:hneverdecreases. More- over, whenever a relabel operation is applied to a vertex u, its height u:h increases by at least 1. Proof Because vertex heights change only during relabel operations, it suffices to prove the second statement of the lemma. If vertex u is about to be rela- beled, then for all vertices 􏳪 such that .u;􏳪/ 2 Ef , we have u:h 􏳥 􏳪:h. Thus, u:h < 1 C min f􏳪:h W .u; 􏳪/ 2 Ef g, and so the operation must increase u:h. Lemma 26.16 Let G D .V;E/ be a flow network with source s and sink t. Then the execution of GENERIC-PUSH-RELABEL on G maintains the attribute h as a height function. Proof The proof is by induction on the number of basic operations performed. Initially, h is a height function, as we have already observed. We claim that if h is a height function, then an operation RELABEL.u/ leaves h a height function. If we look at a residual edge .u;􏳪/ 2 Ef that leaves u, then the operation RELABEL.u/ ensures that u:h 􏳥 􏳪:h C 1 afterward. Now consider a residual edge .w; u/ that enters u. By Lemma 26.15, w: h 􏳥 u: h C 1 before the operation RELABEL.u/ implies w:h < u:h C 1 afterward. Thus, the operation RELABEL.u/ leaves h a height function. Now, consider an operation PUSH.u; 􏳪/. This operation may add the edge .􏳪; u/ to Ef , and it may remove .u; 􏳪/ from Ef . In the former case, we have 􏳪:h D u:h 􏳣 1 < u:h C 1, and so h remains a height function. In the latter case, removing .u;􏳪/ from the residual network removes the corresponding constraint, and h again remains a height function. The following lemma gives an important property of height functions. Lemma 26.17 Let G D .V;E/ be a flow network with source s and sink t, let f be a preflow in G, and let h be a height function on V . Then there is no path from the source s to the sink t in the residual network Gf . Proof Assume for the sake of contradiction that Gf contains a path p from s to t, where p D h􏳪0; 􏳪1; :::; 􏳪ki, 􏳪0 D s, and 􏳪k D t. Without loss of generality, p i s a s i m p l e p a t h , a n d s o k < j V j . F o r i D 0 ; 1 ; : : : ; k 􏳣 1 , e d g e . 􏳪 i ; 􏳪 i C 1 / 2 Ef . Because h is a height function, h.􏳪i / 􏳥 h.􏳪i C1 / C 1 for i D 0; 1; : : : ; k 􏳣 1. Com- bining these inequalities over path p yields h.s/ 􏳥 h.t/Ck. But because h.t/ D 0, 26.4 Push-relabel algorithms 743 we have h.s/ 􏳥 k < jV j, which contradicts the requirement that h.s/ D jV j in a height function. We are now ready to show that if the generic push-relabel algorithm terminates, the preflow it computes is a maximum flow. Theorem 26.18 (Correctness of the generic push-relabel algorithm) If the algorithm GENERIC-PUSH-RELABEL terminates when run on a flow net- work G D .V;E/ with source s and sink t, then the preflow f it computes is a maximum flow for G. Proof We use the following loop invariant: Each time the while loop test in line 2 in GENERIC-PUSH-RELABEL is executed, f is a preflow. Initialization: INITIALIZE-PREFLOW makes f a preflow. Maintenance: Theonlyoperationswithinthewhileloopoflines2–3arepushand relabel. Relabel operations affect only height attributes and not the flow values; hence they do not affect whether f is a preflow. As argued on page 739, if f is a preflow prior to a push operation, it remains a preflow afterward. Termination: At termination, each vertex in V 􏳣 fs; t g must have an excess of 0, because by Lemma 26.14 and the invariant that f is always a preflow, there are no overflowing vertices. Therefore, f is a flow. Lemma 26.16 shows that h is a height function at termination, and thus Lemma 26.17 tells us that there is no path from s to t in the residual network Gf . By the max-flow min-cut theorem (Theorem 26.6), therefore, f is a maximum flow. Analysis of the push-relabel method To show that the generic push-relabel algorithm indeed terminates, we shall bound the number of operations it performs. We bound separately each of the three types of operations: relabels, saturating pushes, and nonsaturating pushes. With knowl- edge of these bounds, it is a straightforward problem to construct an algorithm that runs in O.V 2E/ time. Before beginning the analysis, however, we prove an im- portant lemma. Recall that we allow edges into the source in the residual network. Lemma 26.19 Let G D .V;E/ be a flow network with source s and sink t, and let f be a preflow in G. Then, for any overflowing vertex x, there is a simple path from x to s in the residual network Gf . 744 Chapter 26 Maximum Flow Proof For an overflowing vertex x, let U D f􏳪 W there exists a simple path from x to 􏳪 in Gf g, and suppose for the sake of contradiction that s 62 U. Let U D V 􏳣U. We take the definition of excess from equation (26.14), sum over all vertices inU,andnotethatV DU [U,toobtain X e.u/ D D u2U XX X ! f.􏳪;u/􏳣 f.u;􏳪/ u2U 􏳪2V 􏳪2V !! ! XXXXX f.􏳪;u/C f.􏳪;u/ 􏳣 f.u;􏳪/C f.u;􏳪/ u2U 􏳪2U 􏳪2U 􏳪2U 􏳪2U XXXXXXXX D f.􏳪;u/C f.􏳪;u/􏳣 f.u;􏳪/􏳣 f.u;􏳪/ u2U 􏳪2U u2U 􏳪2U u2U 􏳪2U u2U 􏳪2U XX XX D f .􏳪; u/ 􏳣 f .u; 􏳪/ : u2U 􏳪2U u2U 􏳪2U We know that the quantity P we have e.u/ must be positive because e.x/ > 0, x 2 U , all vertices other than s have nonnegative excess, and, by assumption, s 62 U . Thus,
XX XX
u2U
u2U 􏳪2U
f .􏳪; u/ 􏳣 f .u; 􏳪/ > 0 : (26.17) u2U 􏳪2U
All edge flows are nonnegative, and so for equation (26.17) to hold, we must have
P P f.􏳪;u/ > 0. Hence, there must exist at least one pair of vertices u2U 􏳪2U
u0 2Uand􏳪0 2Uwithf.􏳪0;u0/>0. But,iff.􏳪0;u0/>0,theremustbea residual edge .u0;􏳪0/, which means that there is a simple path from x to 􏳪0 (the path x Y u0 ! 􏳪0), thus contradicting the definition of U .
The next lemma bounds the heights of vertices, and its corollary bounds the number of relabel operations that are performed in total.
Lemma 26.20
Let G D .V;E/ be a flow network with source s and sink t. At any time during the execution of GENERIC-PUSH-RELABEL on G, we have u:h 􏳥 2jV j􏳣1 for all vertices u 2 V .
Proof The heights of the source s and the sink t never change because these vertices are by definition not overflowing. Thus, we always have s:h D jV j and t:h D 0, both of which are no greater than 2 jV j 􏳣 1.
Now consider any vertex u 2 V 􏳣 fs; t g. Initially, u: h D 0 􏳥 2 jV j 􏳣 1. We shall show that after each relabeling operation, we still have u: h 􏳥 2 jV j 􏳣 1. When u is

26.4 Push-relabel algorithms 745
relabeled, it is overflowing, and Lemma 26.19 tells us that there is a simple path p fromutosinGf.LetpDh􏳪0;􏳪1;:::;􏳪ki,where􏳪0 Du,􏳪k Ds,andk􏳥jVj􏳣1 because p is simple. For i D 0;1;:::;k 􏳣 1, we have .􏳪i;􏳪iC1/ 2 Ef , and therefore, by Lemma 26.16, 􏳪i :h 􏳥 􏳪iC1:h C 1. Expanding these inequalities over path p yields u:h D 􏳪0:h 􏳥 􏳪k:h C k 􏳥 s:h C .jV j 􏳣 1/ D 2jV j 􏳣 1.
Corollary 26.21 (Bound on relabel operations)
Let G D .V;E/ be a flow network with source s and sink t. Then, during the execution of GENERIC-PUSH-RELABEL on G, the number of relabel operations is atmost2jVj􏳣1pervertexandatmost.2jVj􏳣1/.jVj􏳣2/<2jVj2 overall. Proof Only the jV j􏳣2 vertices in V 􏳣fs; tg may be relabeled. Let u 2 V 􏳣fs; tg. The operation RELABEL.u/ increases u:h. The value of u:h is initially 0 and by Lemma 26.20, it grows to at most 2jV j 􏳣 1. Thus, each vertex u 2 V 􏳣 fs;tg is relabeled at most 2 jV j 􏳣 1 times, and the total number of relabel operations performed is at most .2 jV j 􏳣 1/.jV j 􏳣 2/ < 2 jV j2. Lemma 26.20 also helps us to bound the number of saturating pushes. Lemma 26.22 (Bound on saturating pushes) During the execution of GENERIC-PUSH-RELABEL on any flow network G D .V; E/, the number of saturating pushes is less than 2 jV j jEj. Proof For any pair of vertices u; 􏳪 2 V , we will count the saturating pushes from u to 􏳪 and from 􏳪 to u together, calling them the saturating pushes between u and 􏳪. If there are any such pushes, at least one of .u;􏳪/ and .􏳪;u/ is actually an edge in E. Now, suppose that a saturating push from u to 􏳪 has occurred. At that time, 􏳪:h D u:h 􏳣 1. In order for another push from u to 􏳪 to occur later, the algorithm must first push flow from 􏳪 to u, which cannot happen until 􏳪:h D u:h C 1. Since u:h never decreases, in order for 􏳪:h D u:h C 1, the value of 􏳪:h must increase by at least 2. Likewise, u:h must increase by at least 2 between saturating pushes from 􏳪 to u. Heights start at 0 and, by Lemma 26.20, never exceed 2 jV j 􏳣 1, which implies that the number of times any vertex can have its height increase by 2 is less than jV j. Since at least one of u:h and 􏳪:h must increase by 2 between any two saturating pushes between u and 􏳪, there are fewer than 2 jV j saturating pushes between u and 􏳪. Multiplying by the number of edges gives a bound of less than 2 jV j jE j on the total number of saturating pushes. The following lemma bounds the number of nonsaturating pushes in the generic push-relabel algorithm. 746 Chapter 26 Maximum Flow Lemma 26.23 (Bound on nonsaturating pushes) During the execution of GENERIC-PUSH-RELABEL on any flow network G D .V; E/, the number of nonsaturating pushes is less than 4 jV j2 .jV j C jEj/. Proof Define a potential function ˆ D P 􏳪:h. Initially, ˆ D 0, and the 􏳪We.􏳪/>0
value of ˆ may change after each relabeling, saturating push, and nonsaturating push. We will bound the amount that saturating pushes and relabelings can con- tribute to the increase of ˆ. Then we will show that each nonsaturating push must decrease ˆ by at least 1, and will use these bounds to derive an upper bound on the number of nonsaturating pushes.
Let us examine the two ways in which ˆ might increase. First, relabeling a vertex u increases ˆ by less than 2 jV j, since the set over which the sum is taken is the same and the relabeling cannot increase u’s height by more than its maximum possible height, which, by Lemma 26.20, is at most 2 jV j 􏳣 1. Second, a saturating push from a vertex u to a vertex 􏳪 increases ˆ by less than 2 jV j, since no heights change and only vertex 􏳪, whose height is at most 2 jV j 􏳣 1, can possibly become overflowing.
Now we show that a nonsaturating push from u to 􏳪 decreases ˆ by at least 1. Why? Before the nonsaturating push, u was overflowing, and 􏳪 may or may not have been overflowing. By Lemma 26.13, u is no longer overflowing after the push. In addition, unless 􏳪 is the source, it may or may not be overflowing after the push. Therefore, the potential function ˆ has decreased by exactly u:h, and it has increased by either 0 or 􏳪:h. Since u:h 􏳣 􏳪:h D 1, the net effect is that the potential function has decreased by at least 1.
Thus, during the course of the algorithm, the total amount of increase in ˆ is due to relabelings and saturated pushes, and Corollary 26.21 and Lemma 26.22 constrain the increase to be less than .2 jV j/.2 jV j2/ C .2 jV j/.2 jV j jEj/ D 4 jV j2 .jV j C jEj/. Since ˆ 􏳦 0, the total amount of decrease, and therefore the total number of nonsaturating pushes, is less than 4 jV j2 .jV j C jE j/.
Having bounded the number of relabelings, saturating pushes, and nonsatu- rating push, we have set the stage for the following analysis of the GENERIC- PUSH-RELABEL procedure, and hence of any algorithm based on the push-relabel method.
Theorem 26.24
During the execution of GENERIC-PUSH-RELABEL on any flow network G D .V; E/, the number of basic operations is O.V 2E/.
Proof Immediate from Corollary 26.21 and Lemmas 26.22 and 26.23.

26.4 Push-relabel algorithms 747
Thus, the algorithm terminates after O.V 2E/ operations. All that remains is to give an efficient method for implementing each operation and for choosing an appropriate operation to execute.
Corollary 26.25
There is an implementation of the generic push-relabel algorithm that runs in O.V 2E/ time on any flow network G D .V; E/.
Proof Exercise 26.4-2 asks you to show how to implement the generic algorithm with an overhead of O.V / per relabel operation and O.1/ per push. It also asks you to design a data structure that allows you to pick an applicable operation in O.1/ time. The corollary then follows.
Exercises
26.4-1
Prove that, after the procedure INITIALIZE-PREFLOW.G;s/ terminates, we have s:e􏳥􏳣jf􏳤j,wheref􏳤 isamaximumflowforG.
26.4-2
Show how to implement the generic push-relabel algorithm using O.V / time per relabel operation, O.1/ time per push, and O.1/ time to select an applicable oper- ation, for a total time of O.V 2E/.
26.4-3
Prove that the generic push-relabel algorithm spends a total of only O.VE/ time in performing all the O.V 2/ relabel operations.
26.4-4
Suppose that we have found a maximum flow in a flow network G D .V; E/ using a push-relabel algorithm. Give a fast algorithm to find a minimum cut in G.
26.4-5
Give an efficient push-relabel algorithm to find a maximum matching in a bipartite graph. Analyze your algorithm.
26.4-6
Suppose that all edge capacities in a flow network G D .V;E/ are in the set f1; 2; : : : ; kg. Analyze the running time of the generic push-relabel algorithm in terms of jV j, jEj, and k. (Hint: How many times can each edge support a nonsat- urating push before it becomes saturated?)

748
Chapter 26 Maximum Flow
? 26.5
26.4-7
Show that we could change line 6 of INITIALIZE-PREFLOW to 6 s:hDjG:Vj􏳣2
without affecting the correctness or asymptotic performance of the generic push- relabel algorithm.
26.4-8
Let ıf .u; 􏳪/ be the distance (number of edges) from u to 􏳪 in the residual net- work Gf . Show that the GENERIC-PUSH-RELABEL procedure maintains the properties that u:h < jVj implies u:h 􏳥 ıf .u;t/ and that u:h 􏳦 jVj implies u:h 􏳣 jV j 􏳥 ıf .u; s/. 26.4-9 ? As in the previous exercise, let ıf .u; 􏳪/ be the distance from u to 􏳪 in the residual network Gf . Show how to modify the generic push-relabel algorithm to maintain the property that u:h < jVj implies u:h D ıf .u;t/ and that u:h 􏳦 jVj implies u: h 􏳣 jV j D ıf .u; s/. The total time that your implementation dedicates to main- taining this property should be O.VE/. 26.4-10 Show that the number of nonsaturating pushes executed by the GENERIC-PUSH- RELABEL procedure on a flow network G D .V; E/ is at most 4 jV j2 jEj for jV j 􏳦 4. The relabel-to-front algorithm The push-relabel method allows us to apply the basic operations in any order at all. By choosing the order carefully and managing the network data structure effi- ciently, however, we can solve the maximum-flow problem faster than the O.V 2E/ bound given by Corollary 26.25. We shall now examine the relabel-to-front algo- rithm, a push-relabel algorithm whose running time is O.V 3/, which is asymptot- ically at least as good as O.V 2E/, and even better for dense networks. The relabel-to-front algorithm maintains a list of the vertices in the network. Beginning at the front, the algorithm scans the list, repeatedly selecting an over- flowing vertex u and then “discharging” it, that is, performing push and relabel operations until u no longer has a positive excess. Whenever we relabel a ver- tex, we move it to the front of the list (hence the name “relabel-to-front”) and the algorithm begins its scan anew. 26.5 The relabel-to-front algorithm 749 The correctness and analysis of the relabel-to-front algorithm depend on the notion of “admissible” edges: those edges in the residual network through which flow can be pushed. After proving some properties about the network of admissible edges, we shall investigate the discharge operation and then present and analyze the relabel-to-front algorithm itself. Admissible edges and networks IfGD.V;E/isaflownetworkwithsourcesandsinkt,f isapreflowinG,andh is a height function, then we say that .u;􏳪/ is an admissible edge if cf .u;􏳪/ > 0 and h.u/ D h.􏳪/ C 1. Otherwise, .u; 􏳪/ is inadmissible. The admissible network is Gf;h D .V;Ef;h/, where Ef;h is the set of admissible edges.
The admissible network consists of those edges through which we can push flow. The following lemma shows that this network is a directed acyclic graph (dag).
Lemma 26.26 (The admissible network is acyclic)
If G D .V;E/ is a flow network, f is a preflow in G, and h is a height function on G, then the admissible network Gf;h D .V;Ef;h/ is acyclic.
Proof The proof is by contradiction. Suppose that Gf;h contains a cycle p D h􏳪0;􏳪1;:::;􏳪ki, where 􏳪0 D 􏳪k and k > 0. Since each edge in p is admissible, we have h.􏳪i􏳣1/ D h.􏳪i / C 1 for i D 1; 2; : : : ; k. Summing around the cycle gives
Xk Xk h.􏳪i􏳣1/ D
iD1 iD1 Xk
D
.h.􏳪i/C1/ h.􏳪i / C k :
iD1
Because each vertex in cycle p appears once in each of the summations, we derive
the contradiction that 0 D k.
The next two lemmas show how push and relabel operations change the admis-
sible network.
Lemma 26.27
Let G D .V; E/ be a flow network, let f be a preflow in G, and suppose that the attribute h is a height function. If a vertex u is overflowing and .u;􏳪/ is an ad- missible edge, then PUSH.u;􏳪/ applies. The operation does not create any new admissible edges, but it may cause .u; 􏳪/ to become inadmissible.

750 Chapter 26 Maximum Flow
Proof By the definition of an admissible edge, we can push flow from u to 􏳪. Since u is overflowing, the operation PUSH.u;􏳪/ applies. The only new residual edge that pushing flow from u to 􏳪 can create is .􏳪;u/. Since 􏳪:h D u:h 􏳣 1, edge .􏳪; u/ cannot become admissible. If the operation is a saturating push, then cf .u; 􏳪/ D 0 afterward and .u; 􏳪/ becomes inadmissible.
Lemma 26.28
Let G D .V;E/ be a flow network, let f be a preflow in G, and suppose that the attribute h is a height function. If a vertex u is overflowing and there are no admissible edges leaving u, then RELABEL.u/ applies. After the relabel operation, there is at least one admissible edge leaving u, but there are no admissible edges entering u.
Proof If u is overflowing, then by Lemma 26.14, either a push or a relabel op- eration applies to it. If there are no admissible edges leaving u, then no flow can be pushed from u and so RELABEL.u/ applies. After the relabel operation, u:h D 1 C minf􏳪:h W .u;􏳪/ 2 Ef g. Thus, if 􏳪 is a vertex that realizes the mini- mum in this set, the edge .u; 􏳪/ becomes admissible. Hence, after the relabel, there is at least one admissible edge leaving u.
To show that no admissible edges enter u after a relabel operation, suppose that there is a vertex 􏳪 such that .􏳪;u/ is admissible. Then, 􏳪:h D u:h C 1 after the relabel, and so 􏳪:h > u:h C 1 just before the relabel. But by Lemma 26.12, no residual edges exist between vertices whose heights differ by more than 1. More- over, relabeling a vertex does not change the residual network. Thus, .􏳪; u/ is not in the residual network, and hence it cannot be in the admissible network.
Neighbor lists
Edges in the relabel-to-front algorithm are organized into “neighbor lists.” Given a flow network G D .V;E/, the neighbor list u:N for a vertex u 2 V is a singly linked list of the neighbors of u in G. Thus, vertex 􏳪 appears in the list u:N if .u;􏳪/ 2 E or .􏳪;u/ 2 E. The neighbor list u:N contains exactly those vertices 􏳪 for which there may be a residual edge .u;􏳪/. The attribute u:N:head points to the first vertex in u:N, and 􏳪:next-neighbor points to the vertex following 􏳪 in a neighbor list; this pointer is NIL if 􏳪 is the last vertex in the neighbor list.
The relabel-to-front algorithm cycles through each neighbor list in an arbitrary order that is fixed throughout the execution of the algorithm. For each vertex u, the attribute u:current points to the vertex currently under consideration in u:N. Initially, u:current is set to u:N:head.

26.5 The relabel-to-front algorithm 751
Discharging an overflowing vertex
An overflowing vertex u is discharged by pushing all of its excess flow through admissible edges to neighboring vertices, relabeling u as necessary to cause edges leaving u to become admissible. The pseudocode goes as follows.
DISCHARGE.u/
1 2 3 4 5 6 7 8
while u:e > 0
􏳪 D u:current
if 􏳪 == NIL RELABEL.u/
u:current D u:N:head
elseif cf .u; 􏳪/ > 0 and u:h == 􏳪:h C 1
PUSH.u;􏳪/
else u:current D 􏳪:next-neighbor
Figure 26.9 steps through several iterations of the while loop of lines 1–8, which executes as long as vertex u has positive excess. Each iteration performs exactly one of three actions, depending on the current vertex 􏳪 in the neighbor list u:N.
1. If 􏳪 is NIL, then we have run off the end of u:N. Line 4 relabels vertex u, and then line 5 resets the current neighbor of u to be the first one in u:N. (Lemma 26.29 below states that the relabel operation applies in this situation.)
2. If 􏳪 is non-NIL and .u;􏳪/ is an admissible edge (determined by the test in line 6), then line 7 pushes some (or possibly all) of u’s excess to vertex 􏳪.
3. If 􏳪 is non-NIL but .u;􏳪/ is inadmissible, then line 8 advances u:current one position further in the neighbor list u:N.
Observe that if DISCHARGE is called on an overflowing vertex u, then the last
action performed by DISCHARGE must be a push from u. Why? The procedure terminates only when u:e becomes zero, and neither the relabel operation nor ad- vancing the pointer u:current affects the value of u:e.
We must be sure that when PUSH or RELABEL is called by DISCHARGE, the operation applies. The next lemma proves this fact.
Lemma 26.29
If DISCHARGE calls PUSH.u;􏳪/ in line 7, then a push operation applies to .u;􏳪/. If DISCHARGE calls RELABEL.u/ in line 4, then a relabel operation applies to u.
Proof The tests in lines 1 and 6 ensure that a push operation occurs only if the operation applies, which proves the first statement in the lemma.

752 Chapter 26 Maximum Flow
6
5s –26
4
(a) 3 2 1 0
6
5s –26
4
(b) 3 2 1 0
6
5s –26
x
0
y8z 19 0
1234
ssss xxxx zzzz
567
sss xxx zzz
89
x 5/5 y 0 19
z
0
4ss
(c) 3 x x
2zz
1 0
x 5/5 y 0 11
z
8
Discharging a vertex y. It takes 15 iterations of the while loop of DISCHARGE to push all the excess flow from y. Only the neighbors of y and edges of the flow network that enter or leave y are shown. In each part of the figure, the number inside each vertex is its excess at the beginning of the first iteration shown in the part, and each vertex is shown at its height throughout the part. The neighbor list y:N at the beginning of each iteration appears on the right, with the iteration number on top. The shaded neighbor is y:current. (a) Initially, there are 19 units of excess to push from y, and y:current D s. Iterations 1, 2, and 3 just advance y:current, since there are no admissible edges leaving y. In iteration 4, y:current D NIL (shown by the shading being below the neighbor list), and so y is relabeled and y:current is reset to the head of the neighbor list. (b) After relabeling, vertex y has height 1. In iterations 5 and 6, edges .y; s/ and .y; x/ are found to be inadmissible, but iteration 7 pushes 8 units of excess flow from y to ́. Because of the push, y:current does not advance in this iteration. (c) Because the push in iteration 7 saturated edge .y; ́/, it is found inadmissible in iteration 8. In iteration 9, y:current D NIL, and so vertex y is again relabeled and y:current is reset.
Figure 26.9
14/14
5/5
14/14
14/14
8
8/8

26.5 The relabel-to-front algorithm 753
6
5 s 10 11 –26
4ss
(d) 3 x x
2yzz
1 0
6 5 4
(e) 3 2 1 0
0x 11
8z
s
–26
12 13 14
sss
xxx y6 zzz
5x
8z
6 y6
5s 15
–26 4s
(f) 3 x
2z
1 0
6 5 4
(g) 3 2 1 0
s
–20
x
5
x
5
y
0
z
8
z
8
(d) In iteration 10, .y; s/ is inadmissible, but iteration 11 pushes 5 units
Figure 26.9, continued
of excess flow from y to x. (e) Because y:current did not advance in iteration 11, iteration 12 finds .y;x/ to be inadmissible. Iteration 13 finds .y; ́/ inadmissible, and iteration 14 relabels ver- tex y and resets y:current. (f) Iteration 15 pushes 6 units of excess flow from y to s. (g) Vertex y now has no excess flow, and DISCHARGE terminates. In this example, DISCHARGE both starts and finishes with the current pointer at the head of the neighbor list, but in general this need not be the case.
5
5/5
14/14
14/14
8/8
8/8
8/14
14/14
8/8
8/8
5
5

754 Chapter 26 Maximum Flow
To prove the second statement, according to the test in line 1 and Lemma 26.28, we need only show that all edges leaving u are inadmissible. If a call to DISCHARGE.u/ starts with the pointer u:current at the head of u’s neighbor list and finishes with it off the end of the list, then all of u’s outgoing edges are in- admissible and a relabel operation applies. It is possible, however, that during a call to DISCHARGE.u/, the pointer u:current traverses only part of the list be- fore the procedure returns. Calls to DISCHARGE on other vertices may then oc- cur, but u:current will continue moving through the list during the next call to DISCHARGE.u/. We now consider what happens during a complete pass through the list, which begins at the head of u:N and finishes with u:current D NIL. Once u:current reaches the end of the list, the procedure relabels u and begins a new pass. For the u:current pointer to advance past a vertex 􏳪 2 u:N during a pass, the edge .u;􏳪/ must be deemed inadmissible by the test in line 6. Thus, by the time the pass completes, every edge leaving u has been determined to be inadmissible at some time during the pass. The key observation is that at the end of the pass, every edge leaving u is still inadmissible. Why? By Lemma 26.27, pushes cannot create any admissible edges, regardless of which vertex the flow is pushed from. Thus, any admissible edge must be created by a relabel operation. But the vertex u is not relabeled during the pass, and by Lemma 26.28, any other vertex 􏳪 that is relabeled during the pass (resulting from a call of DISCHARGE.􏳪/) has no entering admissible edges after relabeling. Thus, at the end of the pass, all edges leaving u remain inadmissible, which completes the proof.
The relabel-to-front algorithm
In the relabel-to-front algorithm, we maintain a linked list L consisting of all ver- tices in V 􏳣 fs; t g. A key property is that the vertices in L are topologically sorted according to the admissible network, as we shall see in the loop invariant that fol- lows. (Recall from Lemma 26.26 that the admissible network is a dag.)
The pseudocode for the relabel-to-front algorithm assumes that the neighbor lists u:N have already been created for each vertex u. It also assumes that u:next points to the vertex that follows u in list L and that, as usual, u:next D NIL if u is the last vertex in the list.

26.5 The relabel-to-front algorithm 755
RELABEL-TO-FRONT.G; s; t/
1 2 3 4 5 6 7 8 9
10 11
INITIALIZE-PREFLOW.G;s/ LDG:V􏳣fs;tg,inanyorder foreachvertexu2G:V􏳣fs;tg
u:current D u:N:head u D L:head
while u ¤ NIL old-height D u:h
DISCHARGE.u/
if u:h > old-height
move u to the front of list L u D u:next
The relabel-to-front algorithm works as follows. Line 1 initializes the preflow and heights to the same values as in the generic push-relabel algorithm. Line 2 initializes the list L to contain all potentially overflowing vertices, in any order. Lines 3–4 initialize the current pointer of each vertex u to the first vertex in u’s neighbor list.
As Figure 26.10 illustrates, the while loop of lines 6–11 runs through the list L, discharging vertices. Line 5 makes it start with the first vertex in the list. Each time through the loop, line 8 discharges a vertex u. If u was relabeled by the DISCHARGE procedure, line 10 moves it to the front of list L. We can determine whether u was relabeled by comparing its height before the discharge operation, saved into the variable old-height in line 7, with its height afterward, in line 9. Line 11 makes the next iteration of the while loop use the vertex following u in list L. If line 10 moved u to the front of the list, the vertex used in the next iteration is the one following u in its new position in the list.
To show that RELABEL-TO-FRONT computes a maximum flow, we shall show that it is an implementation of the generic push-relabel algorithm. First, ob- serve that it performs push and relabel operations only when they apply, since Lemma 26.29 guarantees that DISCHARGE performs them only when they apply. It remains to show that when RELABEL-TO-FRONT terminates, no basic opera- tions apply. The remainder of the correctness argument relies on the following loop invariant:
At each test in line 6 of RELABEL-TO-FRONT, list L is a topological sort of the vertices in the admissible network Gf;h D .V;Ef;h/, and no vertex before u in the list has excess flow.
Initialization: Immediately after INITIALIZE-PREFLOW has been run, s:h D jV j and􏳪:hD0forall􏳪2V􏳣fsg. SincejVj􏳦2(becauseVcontainsat

756 Chapter 26
Maximum Flow
6 5 4
(a) 3 2
s
–26
x y z N: ssx yxy zzt
L:
1t
0
6 5 4
(b) 3 2
0
x 5 y 8 z 10 t 12 14 0 0
7
16
s
–26
L: N:
x y z s sx y xy zzt
7/16 10×7 t
y 8 z 10 t 19 0 7
y0
15x t
0 8z 10 7t
Figure 26.10 The action of RELABEL-TO-FRONT. (a) A flow network just before the first iteration of the while loop. Initially, 26 units of flow leave source s. On the right is shown the initial list L D hx; y; ́i, where initially u D x. Under each vertex in list L is its neighbor list, with the current neighbor shaded. Vertex x is discharged. It is relabeled to height 1, 5 units of excess flow are pushed to y, and the 7 remaining units of excess are pushed to the sink t. Because x is relabeled, it moves to the head of L, which in this case does not change the structure of L. (b) After x, the next vertex in L that is discharged is y. Figure 26.9 shows the detailed action of discharging y in this situation. Because y is relabeled, it is moved to the head of L. (c) Vertex x now follows y in L, and so it is again discharged, pushing all 5 units of excess flow to t. Because vertex x is not relabeled in this discharge operation, it remains in place in list L.
6 5 4
(c) 3 2
s
–20
L: N:
y x z s sx x yy zzt
12/12
14/14
14/14
12/12
12/12
5/5
8/14
8/8
5
7/16
7

26.5 The relabel-to-front algorithm
757
6 5 4
(d) 3 2
0
s
–20
L: N:
y x z ssx xyy zzt
y0
10x t
z 10 t 8 12
y0
10x70z t
0t 20
Figure 26.10, continued (d) Since vertex ́ follows vertex x in L, it is discharged. It is relabeled to height 1 and all 8 units of excess flow are pushed to t. Because ́ is relabeled, it moves to the front of L. (e) Vertex y now follows vertex ́ in L and is therefore discharged. But because y has no excess, DISCHARGE immediately returns, and y remains in place in L. Vertex x is then discharged. Because it, too, has no excess, DISCHARGE again returns, and x remains in place in L. RELABEL- TO-FRONT has reached the end of list L and terminates. There are no overflowing vertices, and the preflow is a maximum flow.
least s and t), no edge can be admissible. Thus, Ef;h D ;, and any ordering of V 􏳣fs;tgisatopologicalsortofGf;h.
Because u is initially the head of the list L, there are no vertices before it and so there are none before it with excess flow.
Maintenance: To see that each iteration of the while loop maintains the topolog- ical sort, we start by observing that the admissible network is changed only by push and relabel operations. By Lemma 26.27, push operations do not cause edges to become admissible. Thus, only relabel operations can create admissi- ble edges. After a vertex u is relabeled, however, Lemma 26.28 states that there are no admissible edges entering u but there may be admissible edges leaving u. Thus, by moving u to the front of L, the algorithm ensures that any admissible edges leaving u satisfy the topological sort ordering.
6
4 (e) 3 2
5 s –20
L: N:
z y x xs s yx y tzz
8/14
8/14
8/8
12/16
7
12/12
12/12
5
5
8/8
8/10
12/16

758 Chapter 26 Maximum Flow
To see that no vertex preceding u in L has excess flow, we denote the vertex that will be u in the next iteration by u0. The vertices that will precede u0 in the next iteration include the current u (due to line 11) and either no other vertices (if u is relabeled) or the same vertices as before (if u is not relabeled). When u is discharged, it has no excess flow afterward. Thus, if u is relabeled during the discharge, no vertices preceding u0 have excess flow. If u is not relabeled during the discharge, no vertices before it on the list acquired excess flow during this discharge, because L remained topologically sorted at all times during the discharge (as just pointed out, admissible edges are created only by relabeling, not pushing), and so each push operation causes excess flow to move only to vertices further down the list (or to s or t). Again, no vertices preceding u0 have excess flow.
Termination: When the loop terminates, u is just past the end of L, and so the loop invariant ensures that the excess of every vertex is 0. Thus, no basic oper- ations apply.
Analysis
We shall now show that RELABEL-TO-FRONT runs in O.V 3/ time on any flow network G D .V;E/. Since the algorithm is an implementation of the generic push-relabel algorithm, we shall take advantage of Corollary 26.21, which pro- vides an O.V / bound on the number of relabel operations executed per vertex and an O.V 2/ bound on the total number of relabel operations overall. In addition, Ex- ercise 26.4-3 provides an O.VE/ bound on the total time spent performing relabel operations, and Lemma 26.22 provides an O.VE/ bound on the total number of saturating push operations.
Theorem 26.30
The running time of RELABEL-TO-FRONT on any flow network G D .V;E/ is O.V 3/.
Proof Let us consider a “phase” of the relabel-to-front algorithm to be the time between two consecutive relabel operations. There are O.V 2/ phases, since there are O.V 2/ relabel operations. Each phase consists of at most jV j calls to DIS- CHARGE, which we can see as follows. If DISCHARGE does not perform a re- label operation, then the next call to DISCHARGE is further down the list L, and the length of L is less than jV j. If DISCHARGE does perform a relabel, the next call to D I S C H A R G E belongs to a different phase. Since each phase contains at most jV j calls to DISCHARGE and there are O.V 2/ phases, the number of times DISCHARGE is called in line 8 of RELABEL-TO-FRONT is O.V 3/. Thus, the total

26.5 The relabel-to-front algorithm 759
work performed by the while loop in RELABEL-TO-FRONT, excluding the work performed within DISCHARGE, is at most O.V 3/.
We must now bound the work performed within DISCHARGE during the ex- ecution of the algorithm. Each iteration of the while loop within D I S C H A R G E performs one of three actions. We shall analyze the total amount of work involved in performing each of these actions.
We start with relabel operations (lines 4–5). Exercise 26.4-3 provides an O.VE/ time bound on all the O.V 2/ relabels that are performed.
Now, suppose that the action updates the u:current pointer in line 8. This action occurs O.degree.u// times each time a vertex u is relabeled, and O.V 􏳵 degree.u// times overall for the vertex. For all vertices, therefore, the total amount of work done in advancing pointers in neighbor lists is O.VE/ by the handshaking lemma (Exercise B.4-1).
The third type of action performed by DISCHARGE is a push operation (line 7). We already know that the total number of saturating push operations is O.VE/. Observe that if a nonsaturating push is executed, DISCHARGE immediately returns, since the push reduces the excess to 0. Thus, there can be at most one nonsaturating push per call to DISCHARGE. As we have observed, DISCHARGE is called O.V 3/ times, and thus the total time spent performing nonsaturating pushes is O.V 3/.
The running time of RELABEL-TO-FRONT is therefore O.V 3 C VE/, which is O.V 3/.
Exercises
26.5-1
Illustrate the execution of RELABEL-TO-FRONT in the manner of Figure 26.10 for the flow network in Figure 26.1(a). Assume that the initial ordering of vertices in L is h􏳪1; 􏳪2; 􏳪3; 􏳪4i and that the neighbor lists are
􏳪1:N D 􏳪2:N D 􏳪3:N D 􏳪4:N D
hs;􏳪2;􏳪3i; hs; 􏳪1; 􏳪3; 􏳪4i ; h􏳪1;􏳪2;􏳪4;ti; h􏳪2;􏳪3;ti:
26.5-2 ?
We would like to implement a push-relabel algorithm in which we maintain a first- in, first-out queue of overflowing vertices. The algorithm repeatedly discharges the vertex at the head of the queue, and any vertices that were not overflowing before the discharge but are overflowing afterward are placed at the end of the queue. After the vertex at the head of the queue is discharged, it is removed. When the

760 Chapter 26 Maximum Flow
Problems
queue is empty, the algorithm terminates. Show how to implement this algorithm to compute a maximum flow in O.V 3/ time.
26.5-3
Show that the generic algorithm still works if R E L A B E L updates u: h by sim- ply computing u:h D u:h C 1. How would this change affect the analysis of RELABEL-TO-FRONT?
26.5-4 ?
Show that if we always discharge a highest overflowing vertex, we can make the push-relabel method run in O.V 3/ time.
26.5-5
Suppose that at some point in the execution of a push-relabel algorithm, there exists an integer 0 < k 􏳥 jVj􏳣1 for which no vertex has 􏳪:h D k. Show that all vertices with 􏳪:h > k are on the source side of a minimum cut. If such a k exists, the gap heuristic updates every vertex 􏳪 2 V 􏳣 fsg for which 􏳪:h > k, to set 􏳪:h D max.􏳪:h; jV j C 1/. Show that the resulting attribute h is a height function. (The gap heuristic is crucial in making implementations of the push-relabel method perform well in practice.)
26-1 Escape problem
An n􏳨n grid is an undirected graph consisting of n rows and n columns of vertices, as shown in Figure 26.11. We denote the vertex in the i th row and the j th column by .i; j /. All vertices in a grid have exactly four neighbors, except for the boundary vertices,whicharethepoints.i;j/forwhichi D1,i Dn,j D1,orj Dn.
Given m 􏳥 n2 starting points .x1;y1/;.x2;y2/;:::;.xm;ym/ in the grid, the escape problem is to determine whether or not there are m vertex-disjoint paths from the starting points to any m different points on the boundary. For example, the grid in Figure 26.11(a) has an escape, but the grid in Figure 26.11(b) does not.
a. Consider a flow network in which vertices, as well as edges, have capacities. That is, the total positive flow entering any given vertex is subject to a capacity constraint. Show that determining the maximum flow in a network with edge and vertex capacities can be reduced to an ordinary maximum-flow problem on a flow network of comparable size.

Problems for Chapter 26 761
(a) (b)
Figure 26.11 Grids for the escape problem. Starting points are black, and other grid vertices are white. (a) A grid with an escape, shown by shaded paths. (b) A grid with no escape.
b. Describe an efficient algorithm to solve the escape problem, and analyze its running time.
26-2 Minimum path cover
A path cover of a directed graph G D .V;E/ is a set P of vertex-disjoint paths such that every vertex in V is included in exactly one path in P . Paths may start and end anywhere, and they may be of any length, including 0. A minimum path cover of G is a path cover containing the fewest possible paths.
a. Give an efficient algorithm to find a minimum path cover of a directed acyclic graph G D .V; E/. (Hint: Assuming that V D f1; 2; : : : ; ng, construct the graphG0 D.V0;E0/,where
V0 D fx0;x1;:::;xng[fy0;y1;:::;yng ;
E0 D f.x0;xi/Wi 2Vg[f.yi;y0/Wi 2Vg[f.xi;yj/W.i;j/2Eg ;
and run a maximum-flow algorithm.)
b. Does your algorithm work for directed graphs that contain cycles? Explain.
26-3 Algorithmic consulting
Professor Gore wants to open up an algorithmic consulting company. He has iden- tified n important subareas of algorithms (roughly corresponding to different por- tions of this textbook), which he represents by the set A D fA1; A2; : : : ; Ang. In each subarea Ak, he can hire an expert in that area for ck dollars. The consulting company has lined up a set J D fJ1; J2; : : : ; Jmg of potential jobs. In order to perform job Ji , the company needs to have hired experts in a subset Ri 􏳧 A of

762 Chapter 26 Maximum Flow
subareas. Each expert can work on multiple jobs simultaneously. If the company chooses to accept job Ji , it must have hired experts in all subareas in Ri , and it will take in revenue of pi dollars.
Professor Gore’s job is to determine which subareas to hire experts in and which jobs to accept in order to maximize the net revenue, which is the total income from jobs accepted minus the total cost of employing the experts.
Consider the following flow network G. It contains a source vertex s, vertices A1;A2;:::;An, vertices J1;J2;:::;Jm, and a sink vertex t. For k D 1;2:::;n, the flow network contains an edge .s;Ak/ with capacity c.s;Ak/ D ck, and for i D 1;2;:::;m, the flow network contains an edge .Ji;t/ with capacity c.Ji;t/ D pi. For k D 1;2;:::;n and i D 1;2;:::;m, if Ak 2 Ri, then G contains an edge .Ak;Ji/ with capacity c.Ak;Ji/ D 1.
a. ShowthatifJi 2T forafinite-capacitycut.S;T/ofG,thenAk 2T foreach Ak 2Ri.
b. Show how to determine the maximum net revenue from the capacity of a mini- mum cut of G and the given pi values.
c. Give an efficient algorithm to determine which jobs to accept and which experts to hire. Analyze the running time of your algorithm in terms of m, n, and r D P mi D 1 j R i j .
26-4 Updating maximum flow
Let G D .V;E/ be a flow network with source s, sink t, and integer capacities. Suppose that we are given a maximum flow in G.
a. Suppose that we increase the capacity of a single edge .u;􏳪/ 2 E by 1. Give an O.V C E/-time algorithm to update the maximum flow.
b. Suppose that we decrease the capacity of a single edge .u; 􏳪/ 2 E by 1. Give an O.V C E/-time algorithm to update the maximum flow.
26-5 Maximum flow by scaling
Let G D .V;E/ be a flow network with source s, sink t, and an integer capac- ity c.u; 􏳪/ on each edge .u; 􏳪/ 2 E. Let C D max.u;􏳪/2E c.u; 􏳪/.
a. Argue that a minimum cut of G has capacity at most C jEj.
b. For a given number K, show how to find an augmenting path of capacity at least K in O.E/ time, if such a path exists.

Problems for Chapter 26 763
We can use the following modification of FORD-FULKERSON-METHOD to com- pute a maximum flow in G:
MAX-FLOW-BY-SCALING.G;s;t/
1 2 3 4 5 6 7 8
c. d.
e. f.
C D max.u;􏳪/2E c.u;􏳪/ initialize flow f to 0
KD2blgCc
whileK􏳦1
while there exists an augmenting path p of capacity at least K
augment flow f along p K D K=2
return f
Argue that MAX-FLOW-BY-SCALING returns a maximum flow.
Show that the capacity of a minimum cut of the residual network Gf is at most 2K jEj each time line 4 is executed.
Argue that the inner while loop of lines 5–6 executes O.E/ times for each value of K.
Conclude that MAX-FLOW-BY-SCALING can be implemented so that it runs in O.E2 lgC/ time.
26-6 The Hopcroft-Karp bipartite matching algorithm
In this problem, we describe a faster algorithm, due to Hopcroft and Karp, for
V E/ time. Given an undirected, bipartite graph G D .V; E/, where V D L [ R and all edges have exactly one endpoint in L, let M be a matching in G. We say that a simple path P in G is an augmenting path with respect to M if it starts at an unmatched vertex in L, ends at an unmatched vertex in R, and its edges belong alternately to M and E 􏳣 M . (This definition of an augmenting path is related to, but different from, an augmenting path in a flow network.) In this problem, we treat a path as a sequence of edges, rather than as a sequence of vertices. A shortest augmenting path with respect to a matching M is an augmenting path
with a minimum number of edges.
Given two sets A and B, the symmetric difference A ̊B is defined as .A􏳣B/[
.B 􏳣 A/, that is, the elements that are in exactly one of the two sets.
finding a maximum matching in a bipartite graph. The algorithm runs in O.
p

764 Chapter 26 Maximum Flow
a. Show that if M is a matching and P is an augmenting path with respect to M , then the symmetric difference M ̊ P is a matching and jM ̊ P j D jM j C 1. ShowthatifP1;P2;:::;Pk arevertex-disjointaugmentingpathswithrespect to M, then the symmetric difference M ̊ .P1 [ P2 [ 􏳵􏳵􏳵 [ Pk/ is a matching with cardinality jM j C k.
The general structure of our algorithm is the following:
HOPCROFT-KARP.G/ 1MD;
2 3
4 5 6
repeat
let P D fP1; P2; : : : ; Pk g be a maximal set of vertex-disjoint shortest augmenting paths with respect to M
M D M ̊.P1 [P2 [􏳵􏳵􏳵[Pk/ untilP==;
return M
The remainder of this problem asks you to analyze the number of iterations in the algorithm (that is, the number of iterations in the repeat loop) and to describe an implementation of line 3.
b. Given two matchings M and M􏳤 in G, show that every vertex in the graph G0 D .V; M ̊ M 􏳤/ has degree at most 2. Conclude that G0 is a disjoint union of simple paths or cycles. Argue that edges in each such simple path or cycle belong alternately to M or M 􏳤. Prove that if jM j 􏳥 jM 􏳤j, then M ̊ M 􏳤 contains at least jM 􏳤j 􏳣 jM j vertex-disjoint augmenting paths with respect to M .
Let l be the length of a shortest augmenting path with respect to a matching M , and letP1;P2;:::;Pk beamaximalsetofvertex-disjointaugmentingpathsoflengthl with respect to M. Let M0 D M ̊.P1 [􏳵􏳵􏳵[Pk/, and suppose that P is a shortest augmenting path with respect to M0.
c. Show that if P is vertex-disjoint from P1;P2;:::;Pk, then P has more than l edges.
d. Now suppose that P is not vertex-disjoint from P1; P2; : : : ; Pk . Let A be the set of edges .M ̊ M0/ ̊ P. Show that A D .P1 [ P2 [ 􏳵􏳵􏳵 [ Pk/ ̊ P and that jAj 􏳦 .k C 1/l. Conclude that P has more than l edges.
e. Prove that if a shortest augmenting path with respect to M has l edges, the size of the maximum matching is at most jM j C jV j =.l C 1/.

Notes for Chapter 26 765
f. Show that the number of repeat loop iterations in the algorithm is at pp
most 2 jV j. (Hint: By how much can M grow after iteration number jV j?)
g. Give an algorithm that runs in O.E/ time to find a maximal set of vertex-
disjoint shortest augmenting paths P ; P ; : : : ; P for a given matching M .
Conclude that the total running time of HOPCROFT-KARP is O. V E/.
12k
p
Chapter notes
Ahuja, Magnanti, and Orlin [7], Even [103], Lawler [224], Papadimitriou and Stei- glitz [271], and Tarjan [330] are good references for network flow and related algo- rithms. Goldberg, Tardos, and Tarjan [139] also provide a nice survey of algorithms for network-flow problems, and Schrijver [304] has written an interesting review of historical developments in the field of network flows.
The Ford-Fulkerson method is due to Ford and Fulkerson [109], who originated the formal study of many of the problems in the area of network flow, including the maximum-flow and bipartite-matching problems. Many early implementations of the Ford-Fulkerson method found augmenting paths using breadth-first search; Edmonds and Karp [102], and independently Dinic [89], proved that this strategy yields a polynomial-time algorithm. A related idea, that of using “blocking flows,” was also first developed by Dinic [89]. Karzanov [202] first developed the idea of preflows. The push-relabel method is due to Goldberg [136] and Goldberg and Tar- jan [140]. Goldberg and Tarjan gave an O.V 3/-time algorithm that uses a queue to maintain the set of overflowing vertices, as well as an algorithm that uses dynamic trees to achieve a running time of O.VE lg.V 2=E C 2//. Several other researchers have developed push-relabel maximum-flow algorithms. Ahuja and Orlin [9] and Ahuja, Orlin, and Tarjan [10] gave algorithms that used scaling. Cheriyan and Maheshwari [62] proposed pushing flow from the overflowing vertex of maximum height. Cheriyan and Hagerup [61] suggested randomly permuting the neighbor lists, and several researchers [14, 204, 276] developed clever derandomizations of this idea, leading to a sequence of faster algorithms. The algorithm of King, Rao, and Tarjan [204] is the fastest such algorithm and runs in O.VE logE=.V lg V / V / time.
The asymptotically fastest algorithm to date for the maximum-flow problem, by Goldberg and Rao [138], runs in time O.min.V 2=3; E1=2/E lg.V 2=E C 2/ lg C /, where C D max.u;􏳪/2E c.u;􏳪/. This algorithm does not use the push-relabel method but instead is based on finding blocking flows. All previous maximum- flow algorithms, including the ones in this chapter, use some notion of distance (the push-relabel algorithms use the analogous notion of height), with a length of 1

766 Chapter 26 Maximum Flow
assigned implicitly to each edge. This new algorithm takes a different approach and assigns a length of 0 to high-capacity edges and a length of 1 to low-capacity edges. Informally, with respect to these lengths, shortest paths from the source to the sink tend have high capacity, which means that fewer iterations need be performed.
In practice, push-relabel algorithms currently dominate augmenting-path or linear-programming based algorithms for the maximum-flow problem. A study by Cherkassky and Goldberg [63] underscores the importance of using two heuris- tics when implementing a push-relabel algorithm. The first heuristic is to peri- odically perform a breadth-first search of the residual network in order to obtain more accurate height values. The second heuristic is the gap heuristic, described in Exercise 26.5-5. Cherkassky and Goldberg conclude that the best choice of push- relabel variants is the one that chooses to discharge the overflowing vertex with the maximum height.
The best algorithm to date for maximum bipartite matching, discovered by
p
V E/ time and is described in Problem 26-6. The book by Lova ́sz and Plummer [239] is an excellent reference on matching
Hopcroft and Karp [176], runs in O. problems.

VII Selected Topics

Introduction
This part contains a selection of algorithmic topics that extend and complement earlier material in this book. Some chapters introduce new models of computation such as circuits or parallel computers. Others cover specialized domains such as computational geometry or number theory. The last two chapters discuss some of the known limitations to the design of efficient algorithms and introduce techniques for coping with those limitations.
Chapter 27 presents an algorithmic model for parallel computing based on dy- namic multithreading. The chapter introduces the basics of the model, showing how to quantify parallelism in terms of the measures of work and span. It then investigates several interesting multithreaded algorithms, including algorithms for matrix multiplication and merge sorting.
Chapter 28 studies efficient algorithms for operating on matrices. It presents two general methods—LU decomposition and LUP decomposition—for solving linear equations by Gaussian elimination in O.n3/ time. It also shows that matrix inversion and matrix multiplication can be performed equally fast. The chapter concludes by showing how to compute a least-squares approximate solution when a set of linear equations has no exact solution.
Chapter 29 studies linear programming, in which we wish to maximize or mini- mize an objective, given limited resources and competing constraints. Linear pro- gramming arises in a variety of practical application areas. This chapter covers how to formulate and solve linear programs. The solution method covered is the sim- plex algorithm, which is the oldest algorithm for linear programming. In contrast to many algorithms in this book, the simplex algorithm does not run in polynomial time in the worst case, but it is fairly efficient and widely used in practice.

770 Part VII Selected Topics
Chapter 30 studies operations on polynomials and shows how to use a well- known signal-processing technique—the fast Fourier transform (FFT)—to multi- ply two degree-n polynomials in O.n lg n/ time. It also investigates efficient im- plementations of the FFT, including a parallel circuit.
Chapter 31 presents number-theoretic algorithms. After reviewing elementary number theory, it presents Euclid’s algorithm for computing greatest common di- visors. Next, it studies algorithms for solving modular linear equations and for raising one number to a power modulo another number. Then, it explores an impor- tant application of number-theoretic algorithms: the RSA public-key cryptosystem. This cryptosystem can be used not only to encrypt messages so that an adversary cannot read them, but also to provide digital signatures. The chapter then presents the Miller-Rabin randomized primality test, with which we can find large primes efficiently—an essential requirement for the RSA system. Finally, the chapter cov- ers Pollard’s “rho” heuristic for factoring integers and discusses the state of the art of integer factorization.
Chapter 32 studies the problem of finding all occurrences of a given pattern string in a given text string, a problem that arises frequently in text-editing pro- grams. After examining the naive approach, the chapter presents an elegant ap- proach due to Rabin and Karp. Then, after showing an efficient solution based on finite automata, the chapter presents the Knuth-Morris-Pratt algorithm, which modifies the automaton-based algorithm to save space by cleverly preprocessing the pattern.
Chapter 33 considers a few problems in computational geometry. After dis- cussing basic primitives of computational geometry, the chapter shows how to use a “sweeping” method to efficiently determine whether a set of line segments con- tains any intersections. Two clever algorithms for finding the convex hull of a set of points—Graham’s scan and Jarvis’s march—also illustrate the power of sweeping methods. The chapter closes with an efficient algorithm for finding the closest pair from among a given set of points in the plane.
Chapter 34 concerns NP-complete problems. Many interesting computational problems are NP-complete, but no polynomial-time algorithm is known for solving any of them. This chapter presents techniques for determining when a problem is NP-complete. Several classic problems are proved to be NP-complete: determining whether a graph has a hamiltonian cycle, determining whether a boolean formula is satisfiable, and determining whether a given set of numbers has a subset that adds up to a given target value. The chapter also proves that the famous traveling- salesman problem is NP-complete.
Chapter 35 shows how to find approximate solutions to NP-complete problems efficiently by using approximation algorithms. For some NP-complete problems, approximate solutions that are near optimal are quite easy to produce, but for others even the best approximation algorithms known work progressively more poorly as

Part VII Selected Topics 771
the problem size increases. Then, there are some problems for which we can invest increasing amounts of computation time in return for increasingly better approx- imate solutions. This chapter illustrates these possibilities with the vertex-cover problem (unweighted and weighted versions), an optimization version of 3-CNF satisfiability, the traveling-salesman problem, the set-covering problem, and the subset-sum problem.

27 Multithreaded Algorithms
The vast majority of algorithms in this book are serial algorithms suitable for running on a uniprocessor computer in which only one instruction executes at a time. In this chapter, we shall extend our algorithmic model to encompass parallel algorithms, which can run on a multiprocessor computer that permits multiple instructions to execute concurrently. In particular, we shall explore the elegant model of dynamic multithreaded algorithms, which are amenable to algorithmic design and analysis, as well as to efficient implementation in practice.
Parallel computers—computers with multiple processing units—have become increasingly common, and they span a wide range of prices and performance. Rela- tively inexpensive desktop and laptop chip multiprocessors contain a single multi- core integrated-circuit chip that houses multiple processing “cores,” each of which is a full-fledged processor that can access a common memory. At an intermedi- ate price/performance point are clusters built from individual computers—often simple PC-class machines—with a dedicated network interconnecting them. The highest-priced machines are supercomputers, which often use a combination of custom architectures and custom networks to deliver the highest performance in terms of instructions executed per second.
Multiprocessor computers have been around, in one form or another, for decades. Although the computing community settled on the random-access ma- chine model for serial computing early on in the history of computer science, no single model for parallel computing has gained as wide acceptance. A major rea- son is that vendors have not agreed on a single architectural model for parallel computers. For example, some parallel computers feature shared memory, where each processor can directly access any location of memory. Other parallel com- puters employ distributed memory, where each processor’s memory is private, and an explicit message must be sent between processors in order for one processor to access the memory of another. With the advent of multicore technology, however, every new laptop and desktop machine is now a shared-memory parallel computer,

Chapter 27 Multithreaded Algorithms 773
and the trend appears to be toward shared-memory multiprocessing. Although time will tell, that is the approach we shall take in this chapter.
One common means of programming chip multiprocessors and other shared- memory parallel computers is by using static threading, which provides a software abstraction of “virtual processors,” or threads, sharing a common memory. Each thread maintains an associated program counter and can execute code indepen- dently of the other threads. The operating system loads a thread onto a processor for execution and switches it out when another thread needs to run. Although the operating system allows programmers to create and destroy threads, these opera- tions are comparatively slow. Thus, for most applications, threads persist for the duration of a computation, which is why we call them “static.”
Unfortunately, programming a shared-memory parallel computer directly using static threads is difficult and error-prone. One reason is that dynamically parti- tioning the work among the threads so that each thread receives approximately the same load turns out to be a complicated undertaking. For any but the sim- plest of applications, the programmer must use complex communication protocols to implement a scheduler to load-balance the work. This state of affairs has led toward the creation of concurrency platforms, which provide a layer of software that coordinates, schedules, and manages the parallel-computing resources. Some concurrency platforms are built as runtime libraries, but others provide full-fledged parallel languages with compiler and runtime support.
Dynamic multithreaded programming
One important class of concurrency platform is dynamic multithreading, which is the model we shall adopt in this chapter. Dynamic multithreading allows program- mers to specify parallelism in applications without worrying about communication protocols, load balancing, and other vagaries of static-thread programming. The concurrency platform contains a scheduler, which load-balances the computation automatically, thereby greatly simplifying the programmer’s chore. Although the functionality of dynamic-multithreading environments is still evolving, almost all support two features: nested parallelism and parallel loops. Nested parallelism allows a subroutine to be “spawned,” allowing the caller to proceed while the spawned subroutine is computing its result. A parallel loop is like an ordinary for loop, except that the iterations of the loop can execute concurrently.
These two features form the basis of the model for dynamic multithreading that we shall study in this chapter. A key aspect of this model is that the programmer needs to specify only the logical parallelism within a computation, and the threads within the underlying concurrency platform schedule and load-balance the compu- tation among themselves. We shall investigate multithreaded algorithms written for

774 Chapter 27 Multithreaded Algorithms
this model, as well how the underlying concurrency platform can schedule compu- tations efficiently.
Our model for dynamic multithreading offers several important advantages:
It is a simple extension of our serial programming model. We can describe a multithreaded algorithm by adding to our pseudocode just three “concurrency” keywords: parallel, spawn, and sync. Moreover, if we delete these concur- rency keywords from the multithreaded pseudocode, the resulting text is serial pseudocode for the same problem, which we call the “serialization” of the mul- tithreaded algorithm.
It provides a theoretically clean way to quantify parallelism based on the no- tions of “work” and “span.”
Many multithreaded algorithms involving nested parallelism follow naturally from the divide-and-conquer paradigm. Moreover, just as serial divide-and- conquer algorithms lend themselves to analysis by solving recurrences, so do multithreaded algorithms.
The model is faithful to how parallel-computing practice is evolving. A grow- ing number of concurrency platforms support one variant or another of dynamic multithreading, including Cilk [51, 118], Cilk++ [71], OpenMP [59], Task Par- allel Library [230], and Threading Building Blocks [292].
Section 27.1 introduces the dynamic multithreading model and presents the met- rics of work, span, and parallelism, which we shall use to analyze multithreaded algorithms. Section 27.2 investigates how to multiply matrices with multithread- ing, and Section 27.3 tackles the tougher problem of multithreading merge sort.
27.1 The basics of dynamic multithreading
We shall begin our exploration of dynamic multithreading using the example of computing Fibonacci numbers recursively. Recall that the Fibonacci numbers are defined by recurrence (3.22):
F0 D 0; F1 D 1;
Fi D Fi􏳣1CFi􏳣2 fori􏳦2:
Here is a simple, recursive, serial algorithm to compute the nth Fibonacci number:
􏳮
􏳮
􏳮
􏳮

27.1 The basics of dynamic multithreading
775
FIB.5/
FIB.4/ FIB.3/
FIB.4/
FIB.3/ FIB.2/ FIB.2/ FIB.1/ FIB.1/ FIB.0/
FIB.1/ FIB.0/
FIB.6/
FIB.3/ FIB.2/ FIB.2/ FIB.1/ FIB.1/ FIB.0/
FIB.1/ FIB.0/
FIB.2/ FIB.1/ FIB.1/ FIB.0/
Figure 27.1 The tree of recursive procedure instances when computing FIB.6/. Each instance of FIB with the same argument does the same work to produce the same result, providing an inefficient but interesting way to compute Fibonacci numbers.
FIB.n/
1 2 3 4 5
ifn􏳥1 return n
else x D FIB.n 􏳣 1/ y D FIB.n􏳣2/
return x C y
You would not really want to compute large Fibonacci numbers this way, be- cause this computation does much repeated work. Figure 27.1 shows the tree of recursive procedure instances that are created when computing F6. For example, a call to FIB.6/ recursively calls FIB.5/ and then FIB.4/. But, the call to FIB.5/ also results in a call to FIB.4/. Both instances of FIB.4/ return the same result (F4 D 3). Since the FIB procedure does not memoize, the second call to FIB.4/ replicates the work that the first call performs.
Let T.n/ denote the running time of FIB.n/. Since FIB.n/ contains two recur- sive calls plus a constant amount of extra work, we obtain the recurrence
T .n/ D T .n 􏳣 1/ C T .n 􏳣 2/ C ‚.1/ :
This recurrence has solution T.n/ D ‚.Fn/, which we can show using the substi- tution method. For an inductive hypothesis, assume that T .n/ 􏳥 aFn 􏳣 b, where a > 1 and b > 0 are constants. Substituting, we obtain

776 Chapter 27
Multithreaded Algorithms
T.n/ 􏳥 D D 􏳥
.aFn􏳣1 􏳣b/C.aFn􏳣2 􏳣b/C‚.1/ a.Fn􏳣1 C Fn􏳣2/ 􏳣 2b C ‚.1/
aFn 􏳣b􏳣.b􏳣‚.1//
aFn􏳣b
if we choose b large enough to dominate the constant in the ‚.1/. We can then choose a large enough to satisfy the initial condition. The analytical bound
T.n/ D ‚.􏳭n/ ; (27.1) p
where 􏳭 D .1 C 5/=2 is the golden ratio, now follows from equation (3.25). Since Fn grows exponentially in n, this procedure is a particularly slow way to compute Fibonacci numbers. (See Problem 31-3 for much faster ways.)
Although the FIB procedure is a poor way to compute Fibonacci numbers, it makes a good example for illustrating key concepts in the analysis of multithreaded algorithms. Observe that within FIB.n/, the two recursive calls in lines 3 and 4 to FIB.n 􏳣 1/ and FIB.n 􏳣 2/, respectively, are independent of each other: they could be called in either order, and the computation performed by one in no way affects the other. Therefore, the two recursive calls can run in parallel.
We augment our pseudocode to indicate parallelism by adding the concurrency keywords spawn and sync. Here is how we can rewrite the FIB procedure to use dynamic multithreading:
P-FIB.n/
1 ifn􏳥1
2 return n
3 else x D spawn P-FIB.n 􏳣 1/
4 5 6
yDP-FIB.n􏳣2/ sync
returnxCy
Notice that if we delete the concurrency keywords spawn and sync from P-FIB, the resulting pseudocode text is identical to FIB (other than renaming the procedure in the header and in the two recursive calls). We define the serialization of a mul- tithreaded algorithm to be the serial algorithm that results from deleting the multi- threaded keywords: spawn, sync, and when we examine parallel loops, parallel. Indeed, our multithreaded pseudocode has the nice property that a serialization is always ordinary serial pseudocode to solve the same problem.
Nested parallelism occurs when the keyword spawn precedes a procedure call, as in line 3. The semantics of a spawn differs from an ordinary procedure call in that the procedure instance that executes the spawn—the parent—may continue to execute in parallel with the spawned subroutine—its child—instead of waiting

27.1 The basics of dynamic multithreading 777
for the child to complete, as would normally happen in a serial execution. In this case, while the spawned child is computing P-FIB.n 􏳣 1/, the parent may go on to compute P-FIB.n 􏳣 2/ in line 4 in parallel with the spawned child. Since the P-FIB procedure is recursive, these two subroutine calls themselves create nested parallelism, as do their children, thereby creating a potentially vast tree of subcom- putations, all executing in parallel.
The keyword spawn does not say, however, that a procedure must execute con- currently with its spawned children, only that it may. The concurrency keywords express the logical parallelism of the computation, indicating which parts of the computation may proceed in parallel. At runtime, it is up to a scheduler to deter- mine which subcomputations actually run concurrently by assigning them to avail- able processors as the computation unfolds. We shall discuss the theory behind schedulers shortly.
A procedure cannot safely use the values returned by its spawned children until after it executes a sync statement, as in line 5. The keyword sync indicates that the procedure must wait as necessary for all its spawned children to complete be- fore proceeding to the statement after the sync. In the P-FIB procedure, a sync is required before the return statement in line 6 to avoid the anomaly that would occur if x and y were summed before x was computed. In addition to explicit synchronization provided by the sync statement, every procedure executes a sync implicitly before it returns, thus ensuring that all its children terminate before it does.
A model for multithreaded execution
It helps to think of a multithreaded computation—the set of runtime instruc- tions executed by a processor on behalf of a multithreaded program—as a directed acyclic graph G D .V; E/, called a computation dag. As an example, Figure 27.2 shows the computation dag that results from computing P-FIB.4/. Conceptually, the vertices in V are instructions, and the edges in E represent dependencies be- tween instructions, where .u; 􏳪/ 2 E means that instruction u must execute before instruction 􏳪. For convenience, however, if a chain of instructions contains no parallel control (no spawn, sync, or return from a spawn—via either an explicit return statement or the return that happens implicitly upon reaching the end of a procedure), we may group them into a single strand, each of which represents one or more instructions. Instructions involving parallel control are not included in strands, but are represented in the structure of the dag. For example, if a strand has two successors, one of them must have been spawned, and a strand with mul- tiple predecessors indicates the predecessors joined because of a sync statement. Thus, in the general case, the set V forms the set of strands, and the set E of di- rected edges represents dependencies between strands induced by parallel control.

778 Chapter 27 Multithreaded Algorithms
P-FIB(4)
P-FIB(3) P-FIB(2)
P-FIB(1) P-FIB(1) P-FIB(0)
P-FIB(0)
A directed acyclic graph representing the computation of P-FIB.4/. Each circle rep- resents one strand, with black circles representing either base cases or the part of the procedure (instance) up to the spawn of P-FIB.n 􏳣 1/ in line 3, shaded circles representing the part of the pro- cedure that calls P-FIB.n 􏳣 2/ in line 4 up to the sync in line 5, where it suspends until the spawn of P-FIB.n 􏳣 1/ returns, and white circles representing the part of the procedure after the sync where it sums x and y up to the point where it returns the result. Each group of strands belonging to the same procedure is surrounded by a rounded rectangle, lightly shaded for spawned procedures and heavily shaded for called procedures. Spawn edges and call edges point downward, continuation edges point horizontally to the right, and return edges point upward. Assuming that each strand takes unit time, the work equals 17 time units, since there are 17 strands, and the span is 8 time units, since the critical path—shown with shaded edges—contains 8 strands.
If G has a directed path from strand u to strand 􏳪, we say that the two strands are (logically) in series. Otherwise, strands u and 􏳪 are (logically) in parallel.
We can picture a multithreaded computation as a dag of strands embedded in a tree of procedure instances. For example, Figure 27.1 shows the tree of procedure instances for P-FIB.6/ without the detailed structure showing strands. Figure 27.2 zooms in on a section of that tree, showing the strands that constitute each proce- dure. All directed edges connecting strands run either within a procedure or along undirected edges in the procedure tree.
We can classify the edges of a computation dag to indicate the kind of dependen- cies between the various strands. A continuation edge .u;u0/, drawn horizontally in Figure 27.2, connects a strand u to its successor u0 within the same procedure instance. When a strand u spawns a strand 􏳪, the dag contains a spawn edge .u; 􏳪/, which points downward in the figure. Call edges, representing normal procedure calls, also point downward. Strand u spawning strand 􏳪 differs from u calling 􏳪 in that a spawn induces a horizontal continuation edge from u to the strand u0 fol-
P-FIB(2)
P-FIB(1)
Figure 27.2

27.1 The basics of dynamic multithreading 779
lowing u in its procedure, indicating that u0 is free to execute at the same time as 􏳪, whereas a call induces no such edge. When a strand u returns to its calling procedure and x is the strand immediately following the next sync in the calling procedure, the computation dag contains return edge .u; x/, which points upward. A computation starts with a single initial strand—the black vertex in the procedure labeled P-FIB.4/ in Figure 27.2—and ends with a single final strand—the white vertex in the procedure labeled P-FIB.4/.
We shall study the execution of multithreaded algorithms on an ideal paral- lel computer, which consists of a set of processors and a sequentially consistent shared memory. Sequential consistency means that the shared memory, which may in reality be performing many loads and stores from the processors at the same time, produces the same results as if at each step, exactly one instruction from one of the processors is executed. That is, the memory behaves as if the instructions were executed sequentially according to some global linear order that preserves the individual orders in which each processor issues its own instructions. For dynamic multithreaded computations, which are scheduled onto processors automatically by the concurrency platform, the shared memory behaves as if the multithreaded computation’s instructions were interleaved to produce a linear order that preserves the partial order of the computation dag. Depending on scheduling, the ordering could differ from one run of the program to another, but the behavior of any exe- cution can be understood by assuming that the instructions are executed in some linear order consistent with the computation dag.
In addition to making assumptions about semantics, the ideal-parallel-computer model makes some performance assumptions. Specifically, it assumes that each processor in the machine has equal computing power, and it ignores the cost of scheduling. Although this last assumption may sound optimistic, it turns out that for algorithms with sufficient “parallelism” (a term we shall define precisely in a moment), the overhead of scheduling is generally minimal in practice.
Performance measures
We can gauge the theoretical efficiency of a multithreaded algorithm by using two metrics: “work” and “span.” The work of a multithreaded computation is the total time to execute the entire computation on one processor. In other words, the work is the sum of the times taken by each of the strands. For a computation dag in which each strand takes unit time, the work is just the number of vertices in the dag. The span is the longest time to execute the strands along any path in the dag. Again, for a dag in which each strand takes unit time, the span equals the number of vertices on a longest or critical path in the dag. (Recall from Section 24.2 that we can find a critical path in a dag G D .V; E/ in ‚.V C E/ time.) For example, the computation dag of Figure 27.2 has 17 vertices in all and 8 vertices on its critical

780 Chapter 27 Multithreaded Algorithms
path, so that if each strand takes unit time, its work is 17 time units and its span is 8 time units.
The actual running time of a multithreaded computation depends not only on its work and its span, but also on how many processors are available and how the scheduler allocates strands to processors. To denote the running time of a multithreaded computation on P processors, we shall subscript by P . For example, we might denote the running time of an algorithm on P processors by TP . The work is the running time on a single processor, or T1. The span is the running time if we could run each strand on its own processor—in other words, if we had an unlimited number of processors—and so we denote the span by T1.
The work and span provide lower bounds on the running time TP of a multi- threaded computation on P processors:
In one step, an ideal parallel computer with P processors can do at most P unitsofwork,andthusinTP time,itcanperformatmostPTP work.Sincethe totalworktodoisT1,wehavePTP 􏳦T1.DividingbyPyieldstheworklaw:
TP 􏳦T1=P: (27.2)
A P -processor ideal parallel computer cannot run any faster than a machine with an unlimited number of processors. Looked at another way, a machine with an unlimited number of processors can emulate a P -processor machine by using just P of its processors. Thus, the span law follows:
TP 􏳦 T1 : (27.3)
We define the speedup of a computation on P processors by the ratio T1=TP , which says how many times faster the computation is on P processors than on 1 processor. By the work law, we have TP 􏳦 T1=P , which implies that T1=TP 􏳥 P. Thus, the speedup on P processors can be at most P. When the speedup is linear in the number of processors, that is, when T1=TP D ‚.P/, the computation exhibits linear speedup, and when T1=TP D P, we have perfect linear speedup.
The ratio T1=T1 of the work to the span gives the parallelism of the multi- threaded computation. We can view the parallelism from three perspectives. As a ratio, the parallelism denotes the average amount of work that can be performed in parallel for each step along the critical path. As an upper bound, the parallelism gives the maximum possible speedup that can be achieved on any number of pro- cessors. Finally, and perhaps most important, the parallelism provides a limit on the possibility of attaining perfect linear speedup. Specifically, once the number of processors exceeds the parallelism, the computation cannot possibly achieve per- fect linear speedup. To see this last point, suppose that P > T1=T1, in which case
􏳮
􏳮

27.1 The basics of dynamic multithreading 781
the span law implies that the speedup satisfies T1=TP 􏳥 T1=T1 < P. Moreover, if the number P of processors in the ideal parallel computer greatly exceeds the parallelism—that is, if P 􏳷 T1=T1—then T1=TP 􏳸 P, so that the speedup is much less than the number of processors. In other words, the more processors we use beyond the parallelism, the less perfect the speedup. As an example, consider the computation P-FIB.4/ in Figure 27.2, and assume that each strand takes unit time. Since the work is T1 D 17 and the span is T1 D 8, the parallelism is T1=T1 D 17=8 D 2:125. Consequently, achieving much more than double the speedup is impossible, no matter how many processors we em- ploy to execute the computation. For larger input sizes, however, we shall see that P-FIB.n/ exhibits substantial parallelism. We define the (parallel) slackness of a multithreaded computation executed on an ideal parallel computer with P processors to be the ratio .T1=T1/=P D T1=.PT1/, which is the factor by which the parallelism of the computation ex- ceeds the number of processors in the machine. Thus, if the slackness is less than 1, we cannot hope to achieve perfect linear speedup, because T1 =.P T1 / < 1 and the span law imply that the speedup on P processors satisfies T1=TP 􏳥 T1=T1 < P . Indeed, as the slackness decreases from 1 toward 0, the speedup of the computation diverges further and further from perfect linear speedup. If the slackness is greater than 1, however, the work per processor is the limiting constraint. As we shall see, as the slackness increases from 1, a good scheduler can achieve closer and closer to perfect linear speedup. Scheduling Good performance depends on more than just minimizing the work and span. The strands must also be scheduled efficiently onto the processors of the parallel ma- chine. Our multithreaded programming model provides no way to specify which strands to execute on which processors. Instead, we rely on the concurrency plat- form’s scheduler to map the dynamically unfolding computation to individual pro- cessors. In practice, the scheduler maps the strands to static threads, and the op- erating system schedules the threads on the processors themselves, but this extra level of indirection is unnecessary for our understanding of scheduling. We can just imagine that the concurrency platform’s scheduler maps strands to processors directly. A multithreaded scheduler must schedule the computation with no advance knowledge of when strands will be spawned or when they will complete—it must operate on-line. Moreover, a good scheduler operates in a distributed fashion, where the threads implementing the scheduler cooperate to load-balance the com- putation. Provably good on-line, distributed schedulers exist, but analyzing them is complicated. 782 Chapter 27 Multithreaded Algorithms Instead, to keep our analysis simple, we shall investigate an on-line centralized scheduler, which knows the global state of the computation at any given time. In particular, we shall analyze greedy schedulers, which assign as many strands to processors as possible in each time step. If at least P strands are ready to execute during a time step, we say that the step is a complete step, and a greedy scheduler assigns any P of the ready strands to processors. Otherwise, fewer than P strands are ready to execute, in which case we say that the step is an incomplete step, and the scheduler assigns each ready strand to its own processor. From the work law, the best running time we can hope for on P processors isTP DT1=P,andfromthespanlawthebestwecanhopeforisTP DT1. The following theorem shows that greedy scheduling is provably good in that it achieves the sum of these two lower bounds as an upper bound. Theorem 27.1 On an ideal parallel computer with P processors, a greedy scheduler executes a multithreaded computation with work T1 and span T1 in time TP 􏳥T1=PCT1: (27.4) Proof We start by considering the complete steps. In each complete step, the P processors together perform a total of P work. Suppose for the purpose of contradiction that the number of complete steps is strictly greater than bT1=Pc. Then, the total work of the complete steps is at least P 􏳵.bT1=PcC1/ D P bT1=PcCP D T1 􏳣.T1 modP/CP (byequation(3.8)) > T1 (by inequality (3.9)) .
Thus, we obtain the contradiction that the P processors would perform more work than the computation requires, which allows us to conclude that the number of complete steps is at most bT1 =P c.
Now, consider an incomplete step. Let G be the dag representing the entire computation, and without loss of generality, assume that each strand takes unit time. (We can replace each longer strand by a chain of unit-time strands.) Let G0 be the subgraph of G that has yet to be executed at the start of the incomplete step, and let G00 be the subgraph remaining to be executed after the incomplete step. A longest path in a dag must necessarily start at a vertex with in-degree 0. Since an incomplete step of a greedy scheduler executes all strands with in-degree 0 in G0, the length of a longest path in G00 must be 1 less than the length of a longest path in G0. In other words, an incomplete step decreases the span of the unexecuted dag by 1. Hence, the number of incomplete steps is at most T1.
Since each step is either complete or incomplete, the theorem follows.

27.1 The basics of dynamic multithreading 783
The following corollary to Theorem 27.1 shows that a greedy scheduler always performs well.
Corollary 27.2
The running time TP of any multithreaded computation scheduled by a greedy scheduler on an ideal parallel computer with P processors is within a factor of 2 of optimal.
Proof Let TP􏳤 be the running time produced by an optimal scheduler on a machine with P processors, and let T1 and T1 be the work and span of the computation, respectively. Since the work and span laws—inequalities (27.2) and (27.3)—give us TP􏳤 􏳦 max.T1=P;T1/, Theorem 27.1 implies that
TP 􏳥T1=PCT1
􏳥 2􏳵max.T1=P;T1/ 􏳥 2TP􏳤 :
The next corollary shows that, in fact, a greedy scheduler achieves near-perfect linear speedup on any multithreaded computation as the slackness grows.
Corollary 27.3
Let TP be the running time of a multithreaded computation produced by a greedy scheduler on an ideal parallel computer with P processors, and let T1 and T1 be the work and span of the computation, respectively. Then, if P 􏳸 T1=T1, we haveTP 􏳬T1=P,orequivalently,aspeedupofapproximatelyP.
Proof If we suppose that P 􏳸 T1=T1, then we also have T1 􏳸 T1=P, and hence Theorem 27.1 gives us TP 􏳥 T1=P C T1 􏳬 T1=P . Since the work law (27.2) dictates that TP 􏳦 T1=P, we conclude that TP 􏳬 T1=P, or equiva- lently, that the speedup is T1=TP 􏳬 P .
The 􏳸 symbol denotes “much less,” but how much is “much less”? As a rule of thumb, a slackness of at least 10—that is, 10 times more parallelism than pro- cessors—generally suffices to achieve good speedup. Then, the span term in the greedy bound, inequality (27.4), is less than 10% of the work-per-processor term, which is good enough for most engineering situations. For example, if a computa- tion runs on only 10 or 100 processors, it doesn’t make sense to value parallelism of, say 1,000,000 over parallelism of 10,000, even with the factor of 100 differ- ence. As Problem 27-2 shows, sometimes by reducing extreme parallelism, we can obtain algorithms that are better with respect to other concerns and which still scale up well on reasonable numbers of processors.

784 Chapter 27 Multithreaded Algorithms
AB
Work: T1.A [ B/ D T1.A/ C T1.B/ Span: T1.A [ B/ D T1.A/ C T1.B/
(a)
A
B
Work: T1.A [ B/ D T1.A/ C T1.B/ Span: T1.A [ B/ D max.T1.A/; T1.B/)
(b)
Figure 27.3 The work and span of composed subcomputations. (a) When two subcomputations are joined in series, the work of the composition is the sum of their work, and the span of the composition is the sum of their spans. (b) When two subcomputations are joined in parallel, the work of the composition remains the sum of their work, but the span of the composition is only the maximum of their spans.
Analyzing multithreaded algorithms
We now have all the tools we need to analyze multithreaded algorithms and provide good bounds on their running times on various numbers of processors. Analyzing the work is relatively straightforward, since it amounts to nothing more than ana- lyzing the running time of an ordinary serial algorithm—namely, the serialization of the multithreaded algorithm—which you should already be familiar with, since that is what most of this textbook is about! Analyzing the span is more interesting, but generally no harder once you get the hang of it. We shall investigate the basic ideas using the P-FIB program.
Analyzing the work T1.n/ of P-FIB.n/ poses no hurdles, because we’ve already done it. The original FIB procedure is essentially the serialization of P-FIB, and hence T1.n/ D T.n/ D ‚.􏳭n/ from equation (27.1).
Figure 27.3 illustrates how to analyze the span. If two subcomputations are joined in series, their spans add to form the span of their composition, whereas if they are joined in parallel, the span of their composition is the maximum of the spans of the two subcomputations. For P-FIB.n/, the spawned call to P-FIB.n􏳣1/ in line 3 runs in parallel with the call to P-FIB.n 􏳣 2/ in line 4. Hence, we can express the span of P-FIB.n/ as the recurrence
T1.n/ D max.T1.n 􏳣 1/; T1.n 􏳣 2// C ‚.1/ D T1.n􏳣1/C‚.1/;
which has solution T1.n/ D ‚.n/.
The parallelism of P-FIB.n/ is T1.n/=T1.n/ D ‚.􏳭n=n/, which grows dra-
matically as n gets large. Thus, on even the largest parallel computers, a modest

27.1 The basics of dynamic multithreading 785
value for n suffices to achieve near perfect linear speedup for P-FIB.n/, because this procedure exhibits considerable parallel slackness.
Parallel loops
Many algorithms contain loops all of whose iterations can operate in parallel. As we shall see, we can parallelize such loops using the spawn and sync keywords, but it is much more convenient to specify directly that the iterations of such loops can run concurrently. Our pseudocode provides this functionality via the parallel concurrency keyword, which precedes the for keyword in a for loop statement.
As an example, consider the problem of multiplying an n 􏳨 n matrix A D .aij / by an n-vector x D .xj /. The resulting n-vector y D .yi / is given by the equation
the entries of y in parallel as follows: MAT-VEC.A;x/
Xn jD1
yi D
for i D 1; 2; : : : ; n. We can perform matrix-vector multiplication by computing all
1 2 3 4 5 6 7 8
n D A:rows letybeanewvectoroflengthn parallelforiD1ton
yiD0 parallelforiD1ton
for j D 1 to n
yi DyiCaijxj
return y
aijxj ;
In this code, the parallel for keywords in lines 3 and 5 indicate that the itera- tions of the respective loops may be run concurrently. A compiler can implement each parallel for loop as a divide-and-conquer subroutine using nested parallelism. For example, the parallel for loop in lines 5–7 can be implemented with the call MAT-VEC-MAIN-LOOP.A;x;y;n;1;n/, where the compiler produces the auxil- iary subroutine MAT-VEC-MAIN-LOOP as follows:

786
Chapter 27
Multithreaded Algorithms
1,8
1,4
5,8
1,2
3,4
5,6
7,8
1,1
2,2
3,3
4,4
5,5
6,6
7,7
8,8
A dag representing the computation of MAT-VEC-MAIN-LOOP.A; x; y; 8; 1; 8/. The two numbers within each rounded rectangle give the values of the last two parameters (i and i0 in the procedure header) in the invocation (spawn or call) of the procedure. The black circles repre- sent strands corresponding to either the base case or the part of the procedure up to the spawn of MAT-VEC-MAIN-LOOP in line 5; the shaded circles represent strands corresponding to the part of the procedure that calls MAT-VEC-MAIN-LOOP in line 6 up to the sync in line 7, where it suspends until the spawned subroutine in line 5 returns; and the white circles represent strands corresponding to the (negligible) part of the procedure after the sync up to the point where it returns.
MAT-VEC-MAIN-LOOP.A;x;y;n;i;i0/
Figure 27.4
1 2 3 4 5 6 7
ifi==i0
for j D 1 to n
yi DyiCaijxj elsemidDb.iCi0/=2c
spawn MAT-VEC-MAIN-LOOP.A;x;y;n;i;mid/ MAT-VEC-MAIN-LOOP.A;x;y;n;mid C 1;i0/ sync
This code recursively spawns the first half of the iterations of the loop to execute in parallel with the second half of the iterations and then executes a sync, thereby creating a binary tree of execution where the leaves are individual loop iterations, as shown in Figure 27.4.
To calculate the work T1.n/ of MAT-VEC on an n􏳨n matrix, we simply compute the running time of its serialization, which we obtain by replacing the parallel for loops with ordinary for loops. Thus, we have T1.n/ D ‚.n2/, because the qua- dratic running time of the doubly nested loops in lines 5–7 dominates. This analysis

27.1 The basics of dynamic multithreading 787
seems to ignore the overhead for recursive spawning in implementing the parallel loops, however. In fact, the overhead of recursive spawning does increase the work of a parallel loop compared with that of its serialization, but not asymptotically. To see why, observe that since the tree of recursive procedure instances is a full binary tree, the number of internal nodes is 1 fewer than the number of leaves (see Exercise B.5-3). Each internal node performs constant work to divide the iteration range, and each leaf corresponds to an iteration of the loop, which takes at least constant time (‚.n/ time in this case). Thus, we can amortize the overhead of re- cursive spawning against the work of the iterations, contributing at most a constant factor to the overall work.
As a practical matter, dynamic-multithreading concurrency platforms sometimes coarsen the leaves of the recursion by executing several iterations in a single leaf, either automatically or under programmer control, thereby reducing the overhead of recursive spawning. This reduced overhead comes at the expense of also reduc- ing the parallelism, however, but if the computation has sufficient parallel slack- ness, near-perfect linear speedup need not be sacrificed.
We must also account for the overhead of recursive spawning when analyzing the span of a parallel-loop construct. Since the depth of recursive calling is logarithmic in the number of iterations, for a parallel loop with n iterations in which the ith iteration has span iter1.i/, the span is
T1.n/D‚.lgn/C max iter1.i/: 1􏳥i 􏳥n
For example, for MAT-VEC on an n 􏳨 n matrix, the parallel initialization loop in lines 3–4 has span ‚.lg n/, because the recursive spawning dominates the constant- time work of each iteration. The span of the doubly nested loops in lines 5–7 is ‚.n/, because each iteration of the outer parallel for loop contains n iterations of the inner (serial) for loop. The span of the remaining code in the procedure is constant, and thus the span is dominated by the doubly nested loops, yielding an overall span of ‚.n/ for the whole procedure. Since the work is ‚.n2/, the parallelism is ‚.n2/=‚.n/ D ‚.n/. (Exercise 27.1-6 asks you to provide an implementation with even more parallelism.)
Race conditions
A multithreaded algorithm is deterministic if it always does the same thing on the same input, no matter how the instructions are scheduled on the multicore com- puter. It is nondeterministic if its behavior might vary from run to run. Often, a multithreaded algorithm that is intended to be deterministic fails to be, because it contains a “determinacy race.”
Race conditions are the bane of concurrency. Famous race bugs include the Therac-25 radiation therapy machine, which killed three people and injured sev-

788 Chapter 27 Multithreaded Algorithms
eral others, and the North American Blackout of 2003, which left over 50 million people without power. These pernicious bugs are notoriously hard to find. You can run tests in the lab for days without a failure only to discover that your software sporadically crashes in the field.
A determinacy race occurs when two logically parallel instructions access the same memory location and at least one of the instructions performs a write. The following procedure illustrates a race condition:
RACE-EXAMPLE. /
1 xD0
2 parallelfori D 1to2 3 xDxC1
4 print x
After initializing x to 0 in line 1, RACE-EXAMPLE creates two parallel strands, each of which increments x in line 3. Although it might seem that RACE- EXAMPLE should always print the value 2 (its serialization certainly does), it could instead print the value 1. Let’s see how this anomaly might occur.
When a processor increments x, the operation is not indivisible, but is composed of a sequence of instructions:
1. Read x from memory into one of the processor’s registers.
2. Increment the value in the register.
3. Write the value in the register back into x in memory.
Figure 27.5(a) illustrates a computation dag representing the execution of RACE- EXAMPLE, with the strands broken down to individual instructions. Recall that since an ideal parallel computer supports sequential consistency, we can view the parallel execution of a multithreaded algorithm as an interleaving of instructions that respects the dependencies in the dag. Part (b) of the figure shows the values in an execution of the computation that elicits the anomaly. The value x is stored in memory, and r1 and r2 are processor registers. In step 1, one of the processors sets x to 0. In steps 2 and 3, processor 1 reads x from memory into its register r1 and increments it, producing the value 1 in r1. At that point, processor 2 comes into the picture, executing instructions 4–6. Processor 2 reads x from memory into register r2; increments it, producing the value 1 in r2; and then stores this value into x, setting x to 1. Now, processor 1 resumes with step 7, storing the value 1 in r1 into x, which leaves the value of x unchanged. Therefore, step 8 prints the value 1, rather than 2, as the serialization would print.
We can see what has happened. If the effect of the parallel execution were that processor 1 executed all its instructions before processor 2, the value 2 would be

27.1 The basics of dynamic multithreading 789
1
2 r1=x
x =0
step x r1 r2
4 r2=x 10–– 200–
3 7
incr r1
x = r1
8
5
6
print x (a)
incr r2 301– 4010 x = r2 5011 6111 7111
(b)
Illustration of the determinacy race in RACE-EXAMPLE. (a) A computation dag show- ing the dependencies among individual instructions. The processor registers are r1 and r2. Instruc- tions unrelated to the race, such as the implementation of loop control, are omitted. (b) An execution sequence that elicits the bug, showing the values of x in memory and registers r1 and r2 for each step in the execution sequence.
printed. Conversely, if the effect were that processor 2 executed all its instructions before processor 1, the value 2 would still be printed. When the instructions of the two processors execute at the same time, however, it is possible, as in this example execution, that one of the updates to x is lost.
Of course, many executions do not elicit the bug. For example, if the execution order were h1;2;3;7;4;5;6;8i or h1;4;5;6;2;3;7;8i, we would get the cor- rect result. That’s the problem with determinacy races. Generally, most orderings produce correct results—such as any in which the instructions on the left execute before the instructions on the right, or vice versa. But some orderings generate improper results when the instructions interleave. Consequently, races can be ex- tremely hard to test for. You can run tests for days and never see the bug, only to experience a catastrophic system crash in the field when the outcome is critical.
Although we can cope with races in a variety of ways, including using mutual- exclusion locks and other methods of synchronization, for our purposes, we shall simply ensure that strands that operate in parallel are independent: they have no determinacy races among them. Thus, in a parallel for construct, all the iterations should be independent. Between a spawn and the corresponding sync, the code of the spawned child should be independent of the code of the parent, including code executed by additional spawned or called children. Note that arguments to a spawned child are evaluated in the parent before the actual spawn occurs, and thus the evaluation of arguments to a spawned subroutine is in series with any accesses to those arguments after the spawn.
Figure 27.5

790 Chapter 27 Multithreaded Algorithms
As an example of how easy it is to generate code with races, here is a faulty implementation of multithreaded matrix-vector multiplication that achieves a span of ‚.lg n/ by parallelizing the inner for loop:
MAT-VEC-WRONG.A;x/
1 2 3 4 5 6 7 8
n D A:rows letybeanewvectoroflengthn parallel for i D 1 to n
yiD0
parallel for i D 1 to n
parallel for j D 1 to n yi DyiCaijxj
return y
This procedure is, unfortunately, incorrect due to races on updating yi in line 7, which executes concurrently for all n values of j . Exercise 27.1-6 asks you to give a correct implementation with ‚.lg n/ span.
A multithreaded algorithm with races can sometimes be correct. As an exam- ple, two parallel threads might store the same value into a shared variable, and it wouldn’t matter which stored the value first. Generally, however, we shall consider code with races to be illegal.
A chess lesson
We close this section with a true story that occurred during the development of
the world-class multithreaded chess-playing program ?Socrates [80], although the
timings below have been simplified for exposition. The program was prototyped
on a 32-processor computer but was ultimately to run on a supercomputer with 512
processors. At one point, the developers incorporated an optimization into the pro-
gram that reduced its running time on an important benchmark on the 32-processor
machine from T32 D 65 seconds to T 0 D 40 seconds. Yet, the developers used 32
the work and span performance measures to conclude that the optimized version, which was faster on 32 processors, would actually be slower than the original ver- sion on 512 processsors. As a result, they abandoned the “optimization.”
Here is their analysis. The original version of the program had work T1 D 2048 seconds and span T1 D 1 second. If we treat inequality (27.4) as an equation, TP D T1=P C T1, and use it as an approximation to the running time on P pro- cessors, we see that indeed T32 D 2048=32 C 1 D 65. With the optimization, the work became T10 D 1024 seconds and the span became T10 D 8 seconds. Again using our approximation, we get T 0 D 1024=32 C 8 D 40.
The relative speeds of the two versions switch when we calculate the running times on 512 processors, however. In particular, we have T512 D 2048=512C1 D 5
32

27.1 The basics of dynamic multithreading 791
seconds, and T 0 D 1024=512 C 8 D 10 seconds. The optimization that sped up 512
the program on 32 processors would have made the program twice as slow on 512 processors! The optimized version’s span of 8, which was not the dominant term in the running time on 32 processors, became the dominant term on 512 processors, nullifying the advantage from using more processors.
The moral of the story is that work and span can provide a better means of extrapolating performance than can measured running times.
Exercises
27.1-1
Suppose that we spawn P-FIB.n 􏳣 2/ in line 4 of P-FIB, rather than calling it as is done in the code. What is the impact on the asymptotic work, span, and parallelism?
27.1-2
Draw the computation dag that results from executing P-FIB.5/. Assuming that each strand in the computation takes unit time, what are the work, span, and par- allelism of the computation? Show how to schedule the dag on 3 processors using greedy scheduling by labeling each strand with the time step in which it is executed.
27.1-3
Prove that a greedy scheduler achieves the following time bound, which is slightly stronger than the bound proven in Theorem 27.1:
TP 􏳥 T1 􏳣 T1 C T1 : (27.5) P
27.1-4
Construct a computation dag for which one execution of a greedy scheduler can take nearly twice the time of another execution of a greedy scheduler on the same number of processors. Describe how the two executions would proceed.
27.1-5
Professor Karan measures her deterministic multithreaded algorithm on 4, 10, and 64 processors of an ideal parallel computer using a greedy scheduler. She claims that the three runs yielded T4 D 80 seconds, T10 D 42 seconds, and T64 D 10 seconds. Argue that the professor is either lying or incompetent. (Hint: Use the work law (27.2), the span law (27.3), and inequality (27.5) from Exer- cise 27.1-3.)

792 Chapter 27 Multithreaded Algorithms
27.1-6
Give a multithreaded algorithm to multiply an n 􏳨 n matrix by an n-vector that achieves ‚.n2= lg n/ parallelism while maintaining ‚.n2/ work.
27.1-7
Consider the following multithreaded pseudocode for transposing an n􏳨n matrix A in place:
P-TRANSPOSE.A/
1 2 3 4
n D A:rows parallelforj D 2ton
parallelfori D 1toj 􏳣1 exchangeaij withaji
Analyze the work, span, and parallelism of this algorithm.
27.1-8
Suppose that we replace the parallel for loop in line 3 of P-TRANSPOSE (see Ex- ercise 27.1-7) with an ordinary for loop. Analyze the work, span, and parallelism of the resulting algorithm.
27.1-9
For how many processors do the two versions of the chess programs run equally fast, assuming that TP D T1=P C T1?
27.2 Multithreaded matrix multiplication
In this section, we examine how to multithread matrix multiplication, a problem whose serial running time we studied in Section 4.2. We’ll look at multithreaded algorithms based on the standard triply nested loop, as well as divide-and-conquer algorithms.
Multithreaded matrix multiplication
The first algorithm we study is the straighforward algorithm based on parallelizing the loops in the procedure SQUARE-MATRIX-MULTIPLY on page 75:

27.2 Multithreaded matrix multiplication 793
P-SQUARE-MATRIX-MULTIPLY.A;B/
1 2 3 4 5 6 7 8
n D A:rows
letC beanewn􏳨nmatrix parallelforiD1ton
parallel for j D 1 to n cij D0
for k D 1 to n
cij DcijCaik􏳵bkj
return C
To analyze this algorithm, observe that since the serialization of the algorithm is just SQUARE-MATRIX-MULTIPLY, the work is therefore simply T1.n/ D ‚.n3/, the same as the running time of SQUARE-MATRIX-MULTIPLY. The span is T1.n/ D ‚.n/, because it follows a path down the tree of recursion for the parallel for loop starting in line 3, then down the tree of recursion for the parallel for loop starting in line 4, and then executes all n iterations of the ordinary for loop starting in line 6, resulting in a total span of ‚.lg n/ C ‚.lg n/ C ‚.n/ D ‚.n/. Thus, the parallelism is ‚.n3/=‚.n/ D ‚.n2/. Exercise 27.2-3 asks you to par- allelize the inner loop to obtain a parallelism of ‚.n3= lg n/, which you cannot do straightforwardly using parallel for, because you would create races.
A divide-and-conquer multithreaded algorithm for matrix multiplication
As we learned in Section 4.2, we can multiply n 􏳨 n matrices serially in time ‚.nlg 7/ D O.n2:81/ using Strassen’s divide-and-conquer strategy, which motivates us to look at multithreading such an algorithm. We begin, as we did in Section 4.2, with multithreading a simpler divide-and-conquer algorithm.
Recall from page 77 that the SQUARE-MATRIX-MULTIPLY-RECURSIVE proce-
dure, which multiplies two n 􏳨 n matrices A and B to produce the n 􏳨 n matrix C ,
relies on partitioning each of the three matrices into four n=2 􏳨 n=2 submatrices: 􏳧􏳹􏳧􏳹􏳧􏳹
AD A11 A12 ; BD B11 B12 ; CD C11 C12 :
A21 A22 B21 B22
Then, we can write the matrix product as
􏳧 􏳹 􏳧 􏳹􏳧 􏳹
C11 C12 D A11 A12 B11 B12 C21 C22 A21 A22 B21 B22
C21 C22
􏳧􏳹􏳧􏳹
D A11 B11 A11 B12 C A12 B21 A12 B22 : A21 B11 A21 B12 A22 B21 A22 B22
(27.6)
Thus, to multiply two n􏳨n matrices, we perform eight multiplications of n=2􏳨n=2 matrices and one addition of n􏳨n matrices. The following pseudocode implements

794 Chapter 27 Multithreaded Algorithms
this divide-and-conquer strategy using nested parallelism. Unlike the S Q U A R E – MATRIX-MULTIPLY-RECURSIVE procedure on which it is based, P-MATRIX- MULTIPLY-RECURSIVE takes the output matrix as a parameter to avoid allocating matrices unnecessarily.
P-MATRIX-MULTIPLY-RECURSIVE.C;A;B/
1 n D A:rows
2 ifn==1
3 c11 D a11b11
4 elseletT beanewn􏳨nmatrix
5 partition A, B , C , and T into n=2 􏳨 n=2 submatrices
A11; A12; A21; A22; B11; B12; B21; B22; C11; C12; C21; C22;
and T11;T12;T21;T22; respectively
6 spawn P-MATRIX-MULTIPLY-RECURSIVE.C11;A11;B11/
7 spawn P-MATRIX-MULTIPLY-RECURSIVE.C12;A11;B12/
8 spawn P-MATRIX-MULTIPLY-RECURSIVE.C21;A21;B11/
9 spawn P-MATRIX-MULTIPLY-RECURSIVE.C22;A21;B12/
10 spawn P-MATRIX-MULTIPLY-RECURSIVE.T11;A12;B21/
11 spawn P-MATRIX-MULTIPLY-RECURSIVE.T12;A12;B22/
12 spawn P-MATRIX-MULTIPLY-RECURSIVE.T21;A22;B21/
13 P-MATRIX-MULTIPLY-RECURSIVE.T22;A22;B22/
14 sync
15 parallelforiD1ton
16 parallel for j D 1 to n
17 cij DcijCtij
Line 3 handles the base case, where we are multiplying 1 􏳨 1 matrices. We handle the recursive case in lines 4–17. We allocate a temporary matrix T in line 4, and line 5 partitions each of the matrices A, B , C , and T into n=2 􏳨 n=2 submatrices. (As with SQUARE-MATRIX-MULTIPLY-RECURSIVE on page 77, we gloss over the minor issue of how to use index calculations to represent submatrix sections of a matrix.) The recursive call in line 6 sets the submatrix C11 to the submatrix product A11B11, so that C11 equals the first of the two terms that form its sum in equation (27.6). Similarly, lines 7–9 set C12, C21, and C22 to the first of the two terms that equal their sums in equation (27.6). Line 10 sets the submatrix T11 to the submatrix product A12B21, so that T11 equals the second of the two terms that form C11’s sum. Lines 11–13 set T12, T21, and T22 to the second of the two terms that form the sums of C12 , C21 , and C22 , respectively. The first seven recursive calls are spawned, and the last one runs in the main strand. The sync statement in line 14 ensures that all the submatrix products in lines 6–13 have been computed,

27.2 Multithreaded matrix multiplication 795
after which we add the products from T into C in using the doubly nested parallel for loops in lines 15–17.
We first analyze the work M1.n/ of the P-MATRIX-MULTIPLY-RECURSIVE procedure, echoing the serial running-time analysis of its progenitor SQUARE- MATRIX-MULTIPLY-RECURSIVE. In the recursive case, we partition in ‚.1/ time, perform eight recursive multiplications of n=2 􏳨 n=2 matrices, and finish up with the ‚.n2/ work from adding two n 􏳨 n matrices. Thus, the recurrence for the work M1.n/ is
M1.n/ D 8M1.n=2/ C ‚.n2/ D ‚.n3/
by case 1 of the master theorem. In other words, the work of our multithreaded al- gorithm is asymptotically the same as the running time of the procedure SQUARE- MATRIX-MULTIPLY in Section 4.2, with its triply nested loops.
To determine the span M1.n/ of P-MATRIX-MULTIPLY-RECURSIVE, we first observe that the span for partitioning is ‚.1/, which is dominated by the ‚.lg n/ span of the doubly nested parallel for loops in lines 15–17. Because the eight parallel recursive calls all execute on matrices of the same size, the maximum span for any recursive call is just the span of any one. Hence, the recurrence for the span M1.n/ of P-MATRIX-MULTIPLY-RECURSIVE is
M1.n/ D M1.n=2/ C ‚.lg n/ : (27.7)
This recurrence does not fall under any of the cases of the master theorem, but it does meet the condition of Exercise 4.6-2. By Exercise 4.6-2, therefore, the solution to recurrence (27.7) is M1.n/ D ‚.lg2 n/.
Now that we know the work and span of P-MATRIX-MULTIPLY-RECURSIVE, we can compute its parallelism as M1.n/=M1.n/ D ‚.n3=lg2 n/, which is very high.
Multithreading Strassen’s method
To multithread Strassen’s algorithm, we follow the same general outline as on page 79, only using nested parallelism:
1. Divide the input matrices A and B and output matrix C into n=2 􏳨 n=2 sub- matrices, as in equation (27.6). This step takes ‚.1/ work and span by index calculation.
2. Create10matricesS1;S2;:::;S10,eachofwhichisn=2􏳨n=2andisthesum or difference of two matrices created in step 1. We can create all 10 matrices with ‚.n2/ work and ‚.lg n/ span by using doubly nested parallel for loops.

796 Chapter 27 Multithreaded Algorithms
3. Using the submatrices created in step 1 and the 10 matrices created in step 2, recursively spawn the computation of seven n=2 􏳨 n=2 matrix products P1;P2;:::;P7.
4. Compute the desired submatrices C11 ; C12 ; C21 ; C22 of the result matrix C by adding and subtracting various combinations of the Pi matrices, once again using doubly nested parallel for loops. We can compute all four submatrices with ‚.n2/ work and ‚.lg n/ span.
To analyze this algorithm, we first observe that since the serialization is the
same as the original serial algorithm, the work is just the running time of the serialization, namely, ‚.nlg7/. As for P-MATRIX-MULTIPLY-RECURSIVE, we can devise a recurrence for the span. In this case, seven recursive calls exe- cute in parallel, but since they all operate on matrices of the same size, we ob- tain the same recurrence (27.7) as we did for P-MATRIX-MULTIPLY-RECURSIVE, which has solution ‚.lg2 n/. Thus, the parallelism of multithreaded Strassen’s method is ‚.nlg7=lg2 n/, which is high, though slightly less than the parallelism of P-MATRIX-MULTIPLY-RECURSIVE.
Exercises
27.2-1
Draw the computation dag for computing P-SQUARE-MATRIX-MULTIPLY on 2􏳨2 matrices, labeling how the vertices in your diagram correspond to strands in the execution of the algorithm. Use the convention that spawn and call edges point downward, continuation edges point horizontally to the right, and return edges point upward. Assuming that each strand takes unit time, analyze the work, span, and parallelism of this computation.
27.2-2
Repeat Exercise 27.2-1 for P-MATRIX-MULTIPLY-RECURSIVE.
27.2-3
Give pseudocode for a multithreaded algorithm that multiplies two n 􏳨 n matrices with work ‚.n3/ but span only ‚.lg n/. Analyze your algorithm.
27.2-4
Give pseudocode for an efficient multithreaded algorithm that multiplies a p 􏳨 q matrix by a q 􏳨 r matrix. Your algorithm should be highly parallel even if any of p, q, and r are 1. Analyze your algorithm.

27.3 Multithreaded merge sort 797
27.2-5
Give pseudocode for an efficient multithreaded algorithm that transposes an n 􏳨 n matrix in place by using divide-and-conquer to divide the matrix recursively into four n=2 􏳨 n=2 submatrices. Analyze your algorithm.
27.2-6
Give pseudocode for an efficient multithreaded implementation of the Floyd- Warshall algorithm (see Section 25.2), which computes shortest paths between all pairs of vertices in an edge-weighted graph. Analyze your algorithm.
27.3 Multithreaded merge sort
We first saw serial merge sort in Section 2.3.1, and in Section 2.3.2 we analyzed its running time and showed it to be ‚.n lg n/. Because merge sort already uses the divide-and-conquer paradigm, it seems like a terrific candidate for multithreading using nested parallelism. We can easily modify the pseudocode so that the first recursive call is spawned:
MERGE-SORT0.A;p;r/
1 ifp T Œp􏳩, then it returns the largest index q in the range p < q 􏳥 r C 1 such 800 Chapter 27 Multithreaded Algorithms The call BINARY-SEARCH.x; T; p; r/ takes ‚.lg n/ serial time in the worst case, wherenDr􏳣pC1isthesizeofthesubarrayonwhichitruns. (SeeExer- cise 2.3-5.) Since BINARY-SEARCH is a serial procedure, its worst-case work and span are both ‚.lg n/. We are now prepared to write pseudocode for the multithreaded merging pro- cedure itself. Like the MERGE procedure on page 31, the P-MERGE procedure assumes that the two subarrays to be merged lie within the same array. Un- like MERGE, however, P-MERGE does not assume that the two subarrays to be merged are adjacent within the array. (That is, P-MERGE does not require that p2 D r1 C 1.) Another difference between MERGE and P-MERGE is that P-MERGE takes as an argument an output subarray A into which the merged val- ues should be stored. The call P-MERGE.T; p1; r1; p2; r2; A; p3/ merges the sorted subarrays TŒp1 ::r1􏳩 and TŒp2 ::r2􏳩 into the subarray AŒp3 ::r3􏳩, where r3 D p3 C.r1 􏳣p1 C1/C.r2 􏳣p2 C1/􏳣1 D p3 C.r1 􏳣p1/C.r2 􏳣p2/C1 and is not provided as an input. P-MERGE.T; p1; r1; p2; r2; A; p3/ 1 n1Dr1􏳣p1C1 2 n2Dr2􏳣p2C1 3 ifn1

810 Chapter 27 Multithreaded Algorithms
a stencil algorithm to compute a longest common subsequence, where the value in entry cŒi; j 􏳩 depends only on the values in cŒi 􏳣1; j 􏳩, cŒi; j 􏳣1􏳩, and cŒi 􏳣1; j 􏳣1􏳩, as well as the elements xi and yj within the two sequences given as inputs. The input sequences are fixed, but the algorithm fills in the two-dimensional array c so that it computes entry cŒi; j 􏳩 after computing all three entries cŒi 􏳣1; j 􏳩, cŒi; j 􏳣1􏳩, and cŒi 􏳣 1; j 􏳣 1􏳩.
In this problem, we examine how to use nested parallelism to multithread a simple stencil calculation on an n 􏳨 n array A in which, of the values in A, the value placed into entry AŒi;j􏳩 depends only on values in AŒi0;j0􏳩, where i0 􏳥 i andj0 􏳥j(andofcourse,i0 ¤iorj0 ¤j). Inotherwords,thevalueinan entry depends only on values in entries that are above it and/or to its left, along with static information outside of the array. Furthermore, we assume throughout this problem that once we have filled in the entries upon which AŒi; j 􏳩 depends, we can fill in AŒi; j 􏳩 in ‚.1/ time (as in the LCS-LENGTH procedure of Section 15.4).
We can partition the n 􏳨 n array A into four n=2 􏳨 n=2 subarrays as follows: 􏳧􏳹
AD A11 A12 : (27.11) A21 A22
Observe now that we can fill in subarray A11 recursively, since it does not depend on the entries of the other three subarrays. Once A11 is complete, we can continue to fill in A12 and A21 recursively in parallel, because although they both depend on A11, they do not depend on each other. Finally, we can fill in A22 recursively.
a. Give multithreaded pseudocode that performs this simple stencil calculation using a divide-and-conquer algorithm SIMPLE-STENCIL based on the decom- position (27.11) and the discussion above. (Don’t worry about the details of the base case, which depends on the specific stencil.) Give and solve recurrences for the work and span of this algorithm in terms of n. What is the parallelism?
b. Modify your solution to part (a) to divide an n 􏳨 n array into nine n=3 􏳨 n=3 subarrays, again recursing with as much parallelism as possible. Analyze this algorithm. How much more or less parallelism does this algorithm have com- pared with the algorithm from part (a)?
c. Generalize your solutions to parts (a) and (b) as follows. Choose an integer b 􏳦 2. Divide an n􏳨n array into b2 subarrays, each of size n=b􏳨n=b, recursing with as much parallelism as possible. In terms of n and b, what are the work, span, and parallelism of your algorithm? Argue that, using this approach, the parallelism must be o.n/ for any choice of b 􏳦 2. (Hint: For this last argument, show that the exponent of n in the parallelism is strictly less than 1 for any choice of b 􏳦 2.)

Notes for Chapter 27 811
d. Give pseudocode for a multithreaded algorithm for this simple stencil calcu- lation that achieves ‚.n= lg n/ parallelism. Argue using notions of work and span that the problem, in fact, has ‚.n/ inherent parallelism. As it turns out, the divide-and-conquer nature of our multithreaded pseudocode does not let us achieve this maximal parallelism.
27-6 Randomized multithreaded algorithms
Just as with ordinary serial algorithms, we sometimes want to implement random- ized multithreaded algorithms. This problem explores how to adapt the various performance measures in order to handle the expected behavior of such algorithms. It also asks you to design and analyze a multithreaded algorithm for randomized quicksort.
a. Explainhowtomodifytheworklaw(27.2),spanlaw(27.3),andgreedysched- uler bound (27.4) to work with expectations when TP , T1, and T1 are all ran- dom variables.
b. Consider a randomized multithreaded algorithm for which 1% of the time we haveT1 D104 andT10;000 D1,butfor99%ofthetimewehaveT1 D T10;000 D 109. Argue that the speedup of a randomized multithreaded algo- rithm should be defined as E ŒT1􏳩 =E ŒTP 􏳩, rather than E ŒT1=TP 􏳩.
c. Argue that the parallelism of a randomized multithreaded algorithm should be defined as the ratio E ŒT1􏳩 =E ŒT1􏳩.
d. Multithread the RANDOMIZED-QUICKSORT algorithm on page 179 by using nested parallelism. (Do not parallelize RANDOMIZED-PARTITION.) Give the pseudocode for your P-RANDOMIZED-QUICKSORT algorithm.
e. Analyze your multithreaded algorithm for randomized quicksort. (Hint: Re- view the analysis of RANDOMIZED-SELECT on page 216.)
Chapter notes
Parallel computers, models for parallel computers, and algorithmic models for par- allel programming have been around in various forms for years. Prior editions of this book included material on sorting networks and the PRAM (Parallel Random- Access Machine) model. The data-parallel model [48, 168] is another popular al- gorithmic programming model, which features operations on vectors and matrices as primitives.

812 Chapter 27 Multithreaded Algorithms
Graham [149] and Brent [55] showed that there exist schedulers achieving the bound of Theorem 27.1. Eager, Zahorjan, and Lazowska [98] showed that any greedy scheduler achieves this bound and proposed the methodology of using work and span (although not by those names) to analyze parallel algorithms. Blelloch [47] developed an algorithmic programming model based on work and span (which he called the “depth” of the computation) for data-parallel programming. Blumofe and Leiserson [52] gave a distributed scheduling algorithm for dynamic multi- threading based on randomized “work-stealing” and showed that it achieves the bound E ŒTP 􏳩 􏳥 T1=P C O.T1/. Arora, Blumofe, and Plaxton [19] and Blelloch, Gibbons, and Matias [49] also provided provably good algorithms for scheduling dynamic multithreaded computations.
The multithreaded pseudocode and programming model were heavily influenced by the Cilk [51, 118] project at MIT and the Cilk++ [71] extensions to C++ dis- tributed by Cilk Arts, Inc. Many of the multithreaded algorithms in this chapter appeared in unpublished lecture notes by C. E. Leiserson and H. Prokop and have been implemented in Cilk or Cilk++. The multithreaded merge-sorting algorithm was inspired by an algorithm of Akl [12].
The notion of sequential consistency is due to Lamport [223].

28 Matrix Operations
Because operations on matrices lie at the heart of scientific computing, efficient al- gorithms for working with matrices have many practical applications. This chapter focuses on how to multiply matrices and solve sets of simultaneous linear equa- tions. Appendix D reviews the basics of matrices.
Section 28.1 shows how to solve a set of linear equations using LUP decomposi- tions. Then, Section 28.2 explores the close relationship between multiplying and inverting matrices. Finally, Section 28.3 discusses the important class of symmetric positive-definite matrices and shows how we can use them to find a least-squares solution to an overdetermined set of linear equations.
One important issue that arises in practice is numerical stability. Due to the limited precision of floating-point representations in actual computers, round-off errors in numerical computations may become amplified over the course of a com- putation, leading to incorrect results; we call such computations numerically un- stable. Although we shall briefly consider numerical stability on occasion, we do not focus on it in this chapter. We refer you to the excellent book by Golub and Van Loan [144] for a thorough discussion of stability issues.
28.1 Solving systems of linear equations
Numerous applications need to solve sets of simultaneous linear equations. We can formulate a linear system as a matrix equation in which each matrix or vector element belongs to a field, typically the real numbers R. This section discusses how to solve a system of linear equations using a method called LUP decomposition.
We start with a set of linear equations in n unknowns x1; x2; : : : ; xn:

814 Chapter 28 Matrix Operations
a11x1 Ca12x2 C􏳵􏳵􏳵Ca1nxn D b1; a21x1 Ca22x2 C􏳵􏳵􏳵Ca2nxn D b2;
:
an1x1 Can2x2 C􏳵􏳵􏳵Cannxn D bn:
(28.1)
A solution to the equations (28.1) is a set of values for x1;x2;:::;xn that satisfy all of the equations simultaneously. In this section, we treat only the case in which there are exactly n equations in n unknowns.
We can conveniently rewrite equations (28.1) as the matrix-vector equation
̇a a 􏳵􏳵􏳵 a 􏳽 ̇x 􏳽 ̇b 􏳽 1112 1n 1 1
a21 a22 􏳵􏳵􏳵 a2n x2 : : ::: : :
Ax D b :
If A is nonsingular, it possesses an inverse A􏳣1, and
x D A􏳣1b
an1 an2 􏳵􏳵􏳵 ann xn
bn
or, equivalently, letting A D .aij /, x D .xi /, and b D .bi /, as
b2 D :
is the solution vector. We can prove that x is the unique solution to equation (28.2) as follows. If there are two solutions, x and x0, then Ax D Ax0 D b and, letting I denote an identity matrix,
x D
D .A􏳣1 A/x
D A􏳣1.Ax/ D A􏳣1.Ax0/ D .A􏳣1A/x0 D x0:
In this section, we shall be concerned predominantly with the case in which A is nonsingular or, equivalently (by Theorem D.1), the rank of A is equal to the number n of unknowns. There are other possibilities, however, which merit a brief discussion. If the number of equations is less than the number n of unknowns—or, more generally, if the rank of A is less than n—then the system is underdeter- mined. An underdetermined system typically has infinitely many solutions, al- though it may have no solutions at all if the equations are inconsistent. If the number of equations exceeds the number n of unknowns, the system is overdeter- mined, and there may not exist any solutions. Section 28.3 addresses the important
Ix
(28.2) (28.3)

28.1 Solving systems of linear equations 815
problem of finding good approximate solutions to overdetermined systems of linear equations.
Let us return to our problem of solving the system Ax D b of n equations in n unknowns. We could compute A􏳣1 and then, using equation (28.3), multiply b by A􏳣1, yielding x D A􏳣1b. This approach suffers in practice from numerical instability. Fortunately, another approach—LUP decomposition—is numerically stable and has the further advantage of being faster in practice.
Overview of LUP decomposition
The idea behind LUP decomposition is to find three n 􏳨 n matrices L, U , and P such that
PA D LU ;
where
L is a unit lower-triangular matrix, U is an upper-triangular matrix, and P is a permutation matrix.
(28.4)
􏳮 􏳮 􏳮
We call matrices L, U , and P satisfying equation (28.4) an LUP decomposition of the matrix A. We shall show that every nonsingular matrix A possesses such a decomposition.
Computing an LUP decomposition for the matrix A has the advantage that we can more easily solve linear systems when they are triangular, as is the case for both matrices L and U . Once we have found an LUP decomposition for A, we can solve equation (28.2), Ax D b, by solving only triangular linear systems, as follows. Multiplying both sides of Ax D b by P yields the equivalent equation PAx D P b, which, by Exercise D.1-4, amounts to permuting the equations (28.1). Using our decomposition (28.4), we obtain
LUx D Pb :
We can now solve this equation by solving two triangular linear systems. Let us define y D Ux, where x is the desired solution vector. First, we solve the lower- triangular system
Ly D P b (28.5) for the unknown vector y by a method called “forward substitution.” Having solved
for y, we then solve the upper-triangular system
Ux D y (28.6)

816 Chapter 28 Matrix Operations
for the unknown x by a method called “back substitution.” Because the permu- tation matrix P is invertible (Exercise D.2-3), multiplying both sides of equa- tion (28.4) by P􏳣1 gives P􏳣1PA D P􏳣1LU, so that
ADP􏳣1LU :
Hence, the vector x is our solution to Ax D b:
(28.7)
Ax D
(by equation (28.7)) (by equation (28.6)) (by equation (28.5))
P 􏳣1LUx D P 􏳣1Ly D P􏳣1Pb
Db:
Our next step is to show how forward and back substitution work and then attack
the problem of computing the LUP decomposition itself.
Forward and back substitution
Forward substitution can solve the lower-triangular system (28.5) in ‚.n2/ time, given L, P , and b. For convenience, we represent the permutation P compactly by an array 􏳬Œ1::n􏳩. For i D 1;2;:::;n, the entry 􏳬Œi􏳩 indicates that Pi;􏳬Œi􏳩 D 1 andPij D0forj ¤􏳬Œi􏳩. Thus,PAhasa􏳬Œi􏳩;j inrowiandcolumnj,andPb has b􏳬Œi􏳩 as its ith element. Since L is unit lower-triangular, we can rewrite equa- tion (28.5) as
y1
l21y1 C y2
l31y1 C l32y2 C y3
D b􏳬Œ1􏳩; D b􏳬Œ2􏳩 ; D b􏳬Œ3􏳩 ;
:
ln1y1 Cln2y2 Cln3y3 C􏳵􏳵􏳵Cyn D b􏳬Œn􏳩:
The first equation tells us that y1 D b􏳬Œ1􏳩. Knowing the value of y1, we can substitute it into the second equation, yielding
y2 D b􏳬Œ2􏳩 􏳣 l21y1 :
Now, we can substitute both y1 and y2 into the third equation, obtaining y3 D b􏳬Œ3􏳩 􏳣 .l31y1 C l32y2/ :
In general, we substitute y1;y2;:::;yi􏳣1 “forward” into the ith equation to solve for yi :

28.1 Solving systems of linear equations 817
i􏳣1 X
jD1
Having solved for y, we solve for x in equation (28.6) using back substitution, which is similar to forward substitution. Here, we solve the nth equation first and work backward to the first equation. Like forward substitution, this process runs in ‚.n2/ time. Since U is upper-triangular, we can rewrite the system (28.6) as
yi Db􏳬Œi􏳩􏳣
lijyj :
u11x1 C u12x2 C 􏳵 􏳵 􏳵 C u22x2 C 􏳵 􏳵 􏳵 C
u1;n􏳣2xn􏳣2 C u1;n􏳣1xn􏳣1 C u1nxn u2;n􏳣2xn􏳣2 C u2;n􏳣1xn􏳣1 C u2nxn
un􏳣2;n􏳣2xn􏳣2 C un􏳣2;n􏳣1xn􏳣1 C un􏳣2;nxn un􏳣1;n􏳣1 xn􏳣1 C un􏳣1;n xn un;nxn
D y1 ; D y2 ;
:
D yn􏳣2 ; D yn􏳣1 ; D yn :
Thus, we can solve for xn; xn􏳣1; : : : ; x1 successively as follows:
xn Dyn=un;n;
xn􏳣1 D .yn􏳣1 􏳣 un􏳣1;nxn/=un􏳣1;n􏳣1 ;
xn􏳣2 D .yn􏳣2 􏳣 .un􏳣2;n􏳣1xn􏳣1 C un􏳣2;nxn//=un􏳣2;n􏳣2 ;
:
or, in general,
Xn xiDyi􏳣 uijxj
jDiC1
!
yi Db􏳬Œi􏳩􏳣 jD1lijyj foriDndownto1
return x
x D 􏳣y 􏳣 Pn u x 􏳵 =u
i i jDiC1ijj ii
=uii :
Given P, L, U, and b, the procedure LUP-SOLVE solves for x by combining forward and back substitution. The pseudocode assumes that the dimension n ap- pears in the attribute L:rows and that the permutation matrix P is represented by the array 􏳬.
LUP-SOLVE.L; U; 􏳬; b/
1 2 3 4 5 6 7
n D L:rows letxbeanewvectoroflengthn foriD1ton Pi􏳣1

818 Chapter 28 Matrix Operations
Procedure LUP-SOLVE solves for y using forward substitution in lines 3–4, and then it solves for x using backward substitution in lines 5–6. Since the summation within each of the for loops includes an implicit loop, the running time is ‚.n2/.
As an example of these methods, consider the system of linear equations defined
by
􏳣􏳵
120 AD344;
􏳣1 2 0􏳵 􏳣3􏳵 344xD7; 563 8
where
3 bD7;
􏳣􏳵
563
8
and we wish to solve for the unknown x. The LUP decomposition is
􏳣100􏳵 L D 0:2 1 0 ;
U D
􏳣0:6 0:5 1 􏳵
563
0 0:8 􏳣0:6 ;
􏳣􏳵
0 0 2:5
001 PD100:
010
(You might want to verify that PA D LU .) Using forward substitution, we solve
Ly D Pb for y:
􏳣1 00􏳵􏳣y􏳵􏳣8􏳵
1
0:2 1 0 y2 D 3 ;
0:60:51 y3 7 obtaining
􏳣8􏳵 yD 1:4
1:5
by computing first y1, then y2, and finally y3. Using back substitution, we solve Ux D y for x:

28.1 Solving systems of linear equations
􏳣5 6 3􏳵􏳣x􏳵􏳣8􏳵 1
0 0:8 􏳣0:6 x2 D 1:4 ; 0 0 2:5 x3 1:5
819
thereby obtaining the desired answer
􏳣 􏳣1:4 􏳵 xD 2:2 0:6
by computing first x3, then x2, and finally x1. Computing an LU decomposition
We have now shown that if we can create an LUP decomposition for a nonsingular matrix A, then forward and back substitution can solve the system Ax D b of linear equations. Now we show how to efficiently compute an LUP decomposition for A. We start with the case in which A is an n 􏳨 n nonsingular matrix and P is absent (or, equivalently, P D In). In this case, we factor A D LU . We call the two matrices L and U an LU decomposition of A.
We use a process known as Gaussian elimination to create an LU decomposi- tion. We start by subtracting multiples of the first equation from the other equations in order to remove the first variable from those equations. Then, we subtract mul- tiples of the second equation from the third and subsequent equations so that now the first and second variables are removed from them. We continue this process until the system that remains has an upper-triangular form—in fact, it is the ma- trix U . The matrix L is made up of the row multipliers that cause variables to be eliminated.
Our algorithm to implement this strategy is recursive. We wish to construct an LU decomposition for an n 􏳨 n nonsingular matrix A. If n D 1, then we are done, sincewecanchooseLDI andU DA.Forn>1,webreakAintofourparts:
̇1􏳽 a11 a12 􏳵􏳵􏳵 a1n
a21 a22 􏳵􏳵􏳵 a2n : : ::: :
AD
􏳧an1 an2􏳹􏳵􏳵􏳵ann
a11 wT
D 􏳪 A0 ;
where 􏳪 is a column .n 􏳣 1/-vector, wT is a row .n 􏳣 1/-vector, and A0 is an .n 􏳣 1/ 􏳨 .n 􏳣 1/ matrix. Then, using matrix algebra (verify the equations by

820 Chapter 28 Matrix Operations
simply multiplying through), we can factor A as 􏳧a11 wT􏳹
A D 􏳪 A0
􏳧10􏳹􏳧a11 wT 􏳹
D 􏳪=a I 11
n􏳣1
0 A0 􏳣􏳪wT=a : (28.8) 11
The 0s in the first and second matrices of equation (28.8) are row and col- umn .n 􏳣 1/-vectors, respectively. The term 􏳪wT=a11, formed by taking the outer product of 􏳪 and w and dividing each element of the result by a11, is an .n 􏳣 1/ 􏳨 .n 􏳣 1/ matrix, which conforms in size to the matrix A0 from which it is subtracted. The resulting .n 􏳣 1/ 􏳨 .n 􏳣 1/ matrix
A0 􏳣 􏳪wT=a11 (28.9)
is called the Schur complement of A with respect to a11.
We claim that if A is nonsingular, then the Schur complement is nonsingular,
too. Why? Suppose that the Schur complement, which is .n 􏳣 1/ 􏳨 .n 􏳣 1/, is singular. Then by Theorem D.1, it has row rank strictly less than n 􏳣 1. Because the bottom n 􏳣 1 entries in the first column of the matrix
􏳧 a11 wT 􏳹 0 A0􏳣􏳪wT=a11
are all 0, the bottom n 􏳣 1 rows of this matrix must have row rank strictly less than n 􏳣 1. The row rank of the entire matrix, therefore, is strictly less than n. Applying Exercise D.2-8 to equation (28.8), A has rank strictly less than n, and from Theorem D.1 we derive the contradiction that A is singular.
Because the Schur complement is nonsingular, we can now recursively find an LU decomposition for it. Let us say that
A0 􏳣􏳪wT=a11 DL0U0 ;
where L0 is unit lower-triangular and U 0 is upper-triangular. Then, using matrix
algebra, we have
AD D D
D
􏳧10􏳹􏳧a11 wT 􏳹 􏳪=a11 In􏳣1 0 A0 􏳣􏳪wT=a11
􏳧1 0􏳹􏳧a11 wT􏳹 􏳪=a11 In􏳣1 0 L0U0
􏳧 1 0􏳹􏳧a11 wT􏳹 􏳪=a11 L0 0 U0
LU;
thereby providing our LU decomposition. (Note that because L0 is unit lower- triangular, so is L, and because U 0 is upper-triangular, so is U .)