How to Think About Algorithms (Instructor's Solution Manual) (Solutions)

29 Pages·2008·0.353 MB·English

by  Jeff Edmonds

Exercise Solutions
How to Think About Algorithms
Jeff Edmonds
May 2008
Chapter 1: Iterative Algorithms:
Measures of Progress and Loop Invariants
Exercise 1.2.1:
1. pre cond & code loop invariant
pre−loop
h − i ⇒ h − i
2. loop invariant′ & not exit cond & code loop invariant′′
loop
h − i h − i ⇒ h − i
3. loop invariant & exit cond & code post cond
post−loop
h − i h − i ⇒ h − i
Exercise 1.6.1: The loop invariant that you would like to maintain is that you are diametrically opposed
tothemonster,i.e.thelinebetweenhimandyougoesthroughthecenter. Initially,thisistruebecause
you are at the center. Now suppose your current location is at radius r 1 from the center. You
≤ 4
are able to swim around your circle of radius r at least as fast as he can run around the lake, because
your circle has at most 1 the circumference of his. Hence, you have no problem maintaining the loop
4
invariant. Your measure progress is your distance r from the center. If r is strictly less than 1, than
4
you have extra speed with which you can make progress by swimming outward. Using this strategy,
you will get closer can closer to the circle of radius 1 but never quite reach it. When you are quite
4
close,youswimasyoucandirectlyforshore. Thistakeyou1 r 3 time units. Duringthis time the
− ≈ 4
monster can run a distance of 3. However, because he is diametrically opposed to you when you start
your sprint, he needs to run a distance of Π>3, which is too far for him. You then run to safety.
Exercise 1.6.2: The only loop invariant that you need is that after colouring i nodes, you have not yet
colouredthe two nodes of an edge with the same colour. Grab any uncoloured node v. It has at most
d neighbors some of which might already be coloured. However, at most d different colours different
colours can be already used by these neighbors. Colour v with one of the other d+1 colours. The
measure of progress is the number of coloured nodes. Each of the n iterations will take at most O(d)
time for a total of at most O(dn) time.
Chapter 2: Using More-of-the-Input Loop Invariants
Exercise 2.2.3:
1. Finite Memory: L= 0n1n n 0 = α 0,1 ∗ α has zero or more 0s followed by the same
{ | ≥ } { ∈{ } |
number of 1s . Suppose that a large block of 0’s has been read in. Clearly, you remember know
}
how many 0’s have been read in. Otherwise, you will not know whether the number of 1’s that
follows is the same. Recall that you cannot go back and reexamine the block of 0’s. This count
cannot be remembered in finite memory, but requires Θ(logn) bits of memory.
2. Mod Counting: L = α 0,1 ∗ every 3rd character of α is a 1 . Eg. 1010011110110 L,
{ ∈ { } | } ∈
ǫ L, 0 L, and 100 L. The computation must remember modulo 3 how many characters
∈ ∈ 6∈
have been read in, so that it knows which characters are every third one. It also must remember
whether the string has already failed to meet the conditions.
i = number of characters read
i = 0 mod 3
0,1
1
i = 2 mod 3 i = 1 mod 3
0,1
0
dead
0,1
3. Union ≈ OR: L = {α ∈ {0,1}∗ | α has length at most three OR the number of 1’s is odd }
This problem is that same as that in Example ??.1 except the AND is replaced by an OR. The
same information needs to be kept, namely length with the state variable l ∈ {0,1,2,3,more}
and the parity of the number of 1’s with r ∈ {even,odd}. The only difference is which states
accept the final string and which reject it. Now, the programaccepts if l 6= moreOR r = odd.
***Need to make OR***
leng 0 leng 1 leng 2 leng 3 leng >3
0
0 0 0 0
Even
1 1 1 1
0 1 1
1 1 1 1
0 0 0 0
Odd
Or more simply
leng 0 leng 1 leng 2 leng 3 leng >3
0,1
0 0 0
dead Even
1 1 1
1 1 1
0,1
0 0 0
Odd
4. Partial Progress: L = {α ∈ {0,1}∗ | α contains the substring 0101 }. For example α =
1110101101∈ L, because it contains the substring, namely α = 111 0101 101.
If the prefix ofthe stringreadso far containsthe substring0101,this certainly shouldbe remem-
bered. However, if it does not, some progress may have been made towards this goal. A prefix
grows one character to the right at a time. Therefore, if the prefix ends in 010 a lot of progress
would have been made because reading a 1 would complete the 0101 task. The levels of progress
are
(a) q
hcontains 0101i
2
(b) q
hends in 010, but does not contain 0101i
(c) q
hends in 01, but does not contain 0101i
(d) q
hends in 0, but does not end in 010 and does not contain 0101i
(e) q
hdoes not ends in 0 or in 01 and does not contain 0101i
Note how we were careful to ensure that these classifications are disjoint and cover all strings so
that every possible prefix is contained in exactly one of these. The loop invariant asserts that
when we have read some prefix, we are in the correct corresponding state.
When defining the code for the loop or the transition function for the DFA, you must determine
when a character moves you forward to a higher level of progress and when you are moved
backwards. As said, if the prefix α so far ends in 010 and you read the character c = 1, then
progress is made because the prefix α1 ends in and hence contains 0101. On the other hand, if
α ends in 010 and you read a c = 0, then this destroys the chance that the ending 010 will lead
to a 0101. However, it is not a complete disaster. The prefix α0 now ends in 0100. This last 0
begins again the pattern 0101. Care needs to be taken to determine all of these transitions.
1
0
0
denodes i nn o0t or 01 0 end in 0 1 end in 01 0 end in 010 1 cont. 0101
Exercise 2.3.1:
1) Clearlythe firsttaskisimpossible becausesummingupn thingsofsizemorethan 1 givesyouata
n
total more than one. There can be none left over. However, the second is possible. Consider the
example given above in which for each i, Eval(p ,[i−1, i ]) returns 1. This subinterval [i−1, i ]
i 2n 2n 2 2n 2n
can be allocated to this player. These intervals are disjoint, valued much more than 1 by this
n
player, and the interval [1,1] is left over.
2
2, 3) See text.
4) pre csond & code loop invariant :
pre−loop
h − i ⇒ h − i
With a = 0 and Q = , the beginning zero [0,0] of the cake has been partitioned into disjoint
∅
piecesandallocatedto Q =0oftheplayers. All[0,1]ofthecakeremainsandbytheprecondition
| |
is worth at least least n−|Q| =1 to each of the players.
n
5) loop invariant′ & not exit cond & code loop invariant′′ : Let a′ and P′ be the
loop
h − i h − i ⇒ h − i
values at the top of the loop and let a′′ and Q′′ be the values after going around again. By the
code, a′′ =c and Q′′ =Q′+i .
imin min
1. By loop invariant′ the beginning [0,a′] of the cake has been partitioned into Q′ disjoint
h − i | |
pieces. By the code, we just partitioned off the piece [a′,a′′]. Hence, the beginning [0,a′′] of
the cake has been partitioned into Q′ +1= Q′′ disjoint pieces.
| | | |
2. By loop invariant′ ,eachplayerp Q′ hasbeenallocatedapieceworthatleast 1 tohim.
h − i i ∈ n
We just just allocated a piece of this value to another player and added him to Q′. Hence,
each player p Q′′ has been such a piece.
i
∈
3. Consider a remaining player p in P Q′′ =P Q′ i . Because he marked it, we know
i min
− − −
that this player values the piece [a′,c ] by 1. The piece [a′,c ]=[a′,a′′] cut off is smaller
i n imin
than this, because c is smaller than c . Hence, player p values the piece [a,a′′] by at
imin i i
most 1. By loop invariant′ , the remaining [a′,1] interval of the cake is worth at least
least nn−|Q′| toh p . −Hence, [a′′,1i]=[a′,1] [a′,a′′] has value of at least n−|Q′| 1 = n−|Q′′|.
n i − n − n n
If follows that loop invariant′′ is true and that the loop invariant has been maintained.
h − i
f) loop invariant & exit cond & code post cond :
post−loop
h − i h − i ⇒ h − i
By the exit condition Q = n. By the loop invariant, the beginning [0,a] of the cake has been
| |
partitioned into Q = n disjoint pieces and each player p Q = P has been allocated a piece
i
| | ∈
[a ,b ] worth at least 1 to him. Though there may be some cake left over, the post condition is
i i n
satisfied.
3
6) The running time is (n2).
O
7) This is a more of the output loop invariant if you think of the output being ordered by who gets
the first piece, who gets the second, and so on.
Chapter 3: Abstract Data Types
Exercise 3.1.1: When the stack is empty, top = 0 if the array indexes from 1 and top = 1 if it indexes
−
from 0.
algorithm Push(newElement)
hpre−condi: This algorithm implicitly acts on some stack ADT via top.
newElement is the information for a new element.
hpost−condi: The new element is pushed onto the top of the stack.
begin
if( top MAX ) then
≥
put “Stack is full”
else
top=top+1
A[top]=newElement
end if
end algorithm
algorithm Pop()
hpre−condi: This algorithm implicitly acts on some stack ADT via top.
hpost−condi: The top element is removed and its information returned.
begin
if( top 0 ) then
≤
put “Stack is empty”
else
element=A[top]
top=top 1
−
return(element)
end if
end algorithm
Exercise 3.1.2:
algorithm Insert(newElement)
hpre−condi: This algorithm implicitly acts on some queue ADT via front and rear.
newElement is the information for a new element.
hpost−condi: The new element is added to the rear of the queue.
begin
if( rear =front 2 mod MAX ) then
−
put “Queue is full”
else
rear = (rear mod MAX)+1
A[rear]=newElement
end if
end algorithm
4
algorithm Remove()
hpre−condi: This algorithm implicitly acts on some queue ADT via front and rear.
hpost−condi: The front element is removed and its information returned.
begin
if( rear =front 1 mod MAX ) then
−
put “Stack is empty”
else
element=A[front]
front=(front mod MAX)+1
return(element)
end if
end algorithm
Exercise 3.1.4: The first two are easy. For the third, one technique is to look for features. In the second
graphofthe pair,there is clearlyacycle oflength eight. Find a correspondingcycle in the firstgraph.
1 1
8 2
5 2 9 10
8
9 10 7 3
6 4
7 3 6 4
5
Exercise 3.2.1:
algorithm IsEmpty()
hpre−condi: This algorithm implicitly acts on some queue ADT.
hpost−condi: The output indicates whether it is empty.
begin
if( first=nil ) then
return( true )
else
return( false )
end if
end algorithm
Exercise 3.2.2:
new temp % Allocate space for the new node.
if( first=nil) then % The new node is also the only node.
first=temp % Point first at this node.
else
last.link=temp % Link the previous last node to the new node.
end if
temp.info=item % Store the information for the new element.
temp.link=nil % Being the last node in the list, it needs a nil pointer.
last=temp % Point last to the new last node.
Exercise 3.2.5:
algorithm Insert(newElement)
5
hpre−condi: This algorithm implicitly acts on some sorted list ADT via first and last.
newElement is the information for a new element.
hpost−condi: The new element is added where it belongs in the ordered list.
begin
% create node to insert
new temp % Allocate space for the new node.
temp.info=item % Store the information for the new element.
% Find the location to insert the new node.
prev =nil % Sandwich the location before the first node.
next=first
loop
exit when next=nil or next.info newElement
≥
prev =next % Point prev where next is pointing.
next=next.link % Point next to the next node.
end loop
% Insert the new node.
if prev =nil then
first=temp % The new node will be the first node.
else
prev.link=temp % Point the previous node to the new node.
end if
temp.link=next % Point the new node to the next node.
if prev =last then
last=temp % The new node will be the last node.
end if end algorithm
Chapter 4: Narrowing the Search Space: Binary Search
Exercise 4.2.2: Suppose S and T are sorted arrays, each containing n elements. (We can assume that all
the numbers are distinct). The goal is to find the nth smallest of the 2n numbers. The output will
be either the index i such that the searched value is in S[i] or the j such that T[j] is the value. For
example, if n=3, S =[2,5,14],and T =[1,6,7], then the 2n numbers are [1,2,5,6,7,14]and the nth
value is 5. The output would simply give that this value 5 is located in S[i] for i = 2. One option is
to merge S and T together and to then pluck out the nth number in this sorted order, but this would
take too much time.
1. Prove for each of the 2n possible indexes, that there is an input for which this answer would be
given. In particular, for each i [1..n], give an input to this problem such that the nth smallest
∈
of the 2n numbers is in S[i].
Answer: To have 2n distinct values, lets use the values 1,2,...,2n.
•
We want to put the value n into S[i].
S must be sorted. Hence, put the values 1,2,...,i 1 into S[1],S[2],...,S[i 1]
− −
and put the values n+i+1,n+i+2,...,2n into S[i+1],S[i+2],...,S[n]
The remaining values i,i+1,...,n 1 and n+1,n+2,...,n+i can go into T sorted.
−
2. Our goal is to design an algorithm with a logarithmic running time. The loop invariant will be
of the type “narrowingthe searchspace”. The firststep is to determine what the searchspace is.
(Hint: First assume that the nth value is in S as opposed to T.) Clearly state the loop invariant.
Answer: Using the hint we will first assume that the nth value is in S as opposed to T. The
•
searchspacewillbe asetS =[i ..i ]ofindexesofS thatthenth valuemightbe in. Theloop
1 2
invariant states “If the nthbvalue is in S then it is in one of the indexes in S.
b
6
Moreformally,the correctindex (assuminginS)islargerthani 1,becauseT[n i]<S[i]
1
− −
is not true for i=i 1.
1
−
andthe correctindex (assuminginS)issmallerorequaltoi ,because T[n i]<S[i]istrue
2
−
for i=i .”
2
3. How do you establish this loop invariant?
Answer: Initially, S =[1..n]. We can establish the loop invariant as follows.
•
For i=i 1=0,tbhe statementT[n i]<S[i]is T[n]<S[0]. Thisis nottrue ifwe pretend
1
− −
that S[0]= .
−∞
For i=i =n , the statement T[n i]<S[i] is T[0]<S[n]. This is true if we pretend that
2
−
T[0]= .
−∞
4. What stepdoes youralgorithmtakeeachiteration? Provethat this maintains the loopinvariant.
Prove that this makes progress.
Answer: Each iteration cuts the search space in half. i = i1+i2 . As hinted in (2), the
• mid ⌊ 2 ⌋
algorithm tests if T[n i ]<S[i ].
mid mid
−
If T[n i ]<S[i ]is nottrue,then i cannotbe the answer,however,largerindexesi
mid mid mid
−
mightbe. Seti′ toi +1andS′ =[i +1..i ]. Thismaintainstheloopinvariantbecause
1 mid mid 2
we know that T[n i]<S[i] is nbot true for i=i′ 1=i .
− 1− mid
On the other hand, if T[n i ] < S[i ] is true, then i might be the answer. Set
mid mid mid
−
i′ to i and S′ = [i ..i ]. This maintains the loop invariant because we know that
2 mid 1 mid
T[n i]<S[i] isbtrue for i=i′ =i .
− 2 mid
Note that because we rounded down i = i1+i2 , we have that S = [1 ..i ] is half of S
mid ⌊ 2 ⌋ 1 mid
when of even size. For example, if S =[3,4,5,6], the i = 3+6 b=4 and S becomes [3,4b]
mid ⌊ 2 ⌋
which is half the size. Taking anothber step gives i = 3+4 =3 and S becbomes [3] which
mid ⌊ 2 ⌋
is again half the size. b
5. Whatis the exitconditionandwhatextraworkdoyouneedtodo toestablishthe postcondition
from the exit condition and the loop invariant?
Answer: The exit conditions states that S contains one index i, where i =i =i.
1 2
•
From the loop invariant, we know T[n bi′] < S[i′] is not true for i′ = i 1 = i 1 and
1
− − −
T[n i]<S[i] is true for i=i . Restating the first gives that T[n i+1]>S[i 1] is true.
2
− − −
(Here we used the fact that the elements are distinct).
The extra work must check whether the nth value is in location S[i]. By (d), we test this by
checkingthat T[n i]<S[i]andthatT[n i+1]>S[i]. The firstofthese we knowalready.
− −
Hence, we must only test whether T[n i+1]>S[i] is true.
−
If T[n i+1]>S[i]turns outto be true,then we knowthatthenth value is inlocationS[i].
−
On the other hand, if T[n i+1]<S[i]turns out to be true instead, then we know that the
−
nth value cannot be in S. Hence, it must be in T. Our goal is to the index j, such that it is
in T[j]. By the symmetric version of (2), we test a j by checking that S[n j] < T[j] and
−
that S[n j+1]>T[j].
−
Recall that from the loop invariant we already know that T[n i+1] > S[i 1] and from
− −
our last test we know that T[n i+1]< S[i]. Hence, if we set j to n i+1, then the two
− −
test for j are known to pass and we know that the nth value is in location T[j].
6. Supposeyouhaveagiveninputinstance,S andT,andafriendtellsgivesyouanindexiandtells
you that the nth value is in S[i]. Tell me two comparisons that verify that your friend is right.
Suppose we assuming that the correct index is in S and we denote this index with i . How
correct
do you determine whether i i or i<i .
correct correct
≤
Answer: ForS[i]tobethenthvaluethereneedstobeexactlyn 1valuesthataresmallerthan
• −
S[i]. S containsexactlyi 1suchvalues. Hence,T mustcontainexactly(n 1) (i 1)=n i
− − − − −
such values. To test this we check that T[n i]<S[i] and that T[n i+1]>S[i].
− −
If T[n i]< S[i] is not true, then i cannot be the answer. For larger i′, T[n i′] is smaller
− −
andS[i′]isbiggerandhencethestatementT[n i′]<S[i′]mightbetrue. Hence,thecorrect
−
index (assuming in S) is larger than i.
7
Conversely, if T[n i] < S[i] is true, then i might be the answer. But this statement gives
−
that T[n i] < S[i] < S[i+1]. Hence, the statement T[n i+1] > S[i] is not true for
− −
i=i+1. This being the second requirementfor being the answebrs,this probvesthat i=i+1
bcannot be the answer. For larger i′, T[n i′+1] is even smaller and S[i′] is even labrger and
−
hencethe statementT[n i′+1]>S[i′]willremainfalseandwehenceknowthatsuchlarger
−
i′ cannotbe the answereither. We canconclude thatthe correctindex (assuming inS)must
be smaller or equal to i.
7. What is the running time of your algorithm?
Answer: The measure of progress is initially n and goes down by a factor of two each
•
iterations. After logn iterations it is one. Then there is one last iteration to choose between
S[i] and T[j]. This is a total of T(n)=log(n)+1.
8. Extra exercise: Read Chapter 7, “The Loop Invariant for Lower Bounds”. What is the lower
bound on the number of comparisons needed to solve this S-T problem? This is proved by
designing an algorithm A that, given an algorithm A, finds an input instance on which A either
runs for at least T (nb) time steps or gives the wrong answer. What is the loop invariantused
lower
by A? How is this loop invariant established? What step does A do each iteration? What is the
meabsure of progress and what is this measure at time t? What ibs T (n)?
lower
Answer: TheloopinvariantisasetS ofinputinstanceswhichareindistinguishabletoAafter
•
t time steps. For time t=0, S is thbe set of 2n instances given in the last question for which
the outputs are all different. bEach iteration, A partitions the set S of instances into those
for which A’s comparisonsaid “yes greater thanb” and those for whicbh it said “no not greater
than”. The measure of progressis that the size of the set S is at least 2n. Note it goes down
2t
by a factor of two each iteration. The lower bound is thatbT (n) = log(2n)= log(n)+1
lower
comparisons are needed to solve the S-T problem.
This is exactly the same as the running time of our algorithm.
Chapter 6: Euclid’s GCD Algorithm
Exercise 6.0.1:
1. pre cond & code loop invariant
pre−loop
h − i ⇒ h − i
By pre cond , x [0,...,1]. By code , x = x . Hence, x [0,...,1]. This
original pre−loop original
h − i ∈ ∈
establishes the loop invariant.
2. loop invariant′ & not exit cond & code loop invariant′′
loop
h − i h − i ⇒ h − i
Let x′ be the values of x at the top of the loop and let x′′ be that after going around again. By
the loop invariant we know that x′ [0,...,1] and by the code that x′′ = f(x′). Eyeballing the
∈
function f, we see that on input x′ [0,...,1], the output f(x′) is also in the range [0,...,1]. It
∈
follows that x′′ [0,...,1] reestablishing the loop invariant.
∈
3. loop invariant & exit cond & code post cond
post−loop
h − i h − i ⇒ h − i
By the loopinvariant,x [0,...,1]. By the exitconditionx=f(x). Eyeballingthe functionf,we
∈
see the only value of x [0,...,1] for which x=f(x) is x=0.4. It follows that the value returned
∈
is x=0.4.
4. In the worst case, the size of the input in bits is n = log (x)+log (N) = Θ(log(N)) and the
2 2
number of iterations is T =N =2Θ(n). This is exponential time.
5. The number of iterations is T = billion =Θ(1). This may be big, but is a constant with respect
to the input size.
Exercise 6.0.2:
1)
algorithm EthiopianMultipling(x,y)
8
hpre−condi: x and y are positive integers.
hpost−condi: Outputs x y.
×
begin
ℓ=x, r =y, s=0
loop
hloop−invarianti: ℓ r+s=x y.
× ×
exit when ℓ=0
if(ℓ is odd) then
ℓ=ℓ 1
−
s=s+r
end if
hloop−invarianti: ℓ r+s=x y.
× ×
ℓ=ℓ/2
r =2 r
×
end loop
return(s)
end algorithm
2, 4) See text.
3) Draw an ℓ by r rectangle and an area of s on the side. The first step consists of removing one row
(with area 1 r) from the rectangle and moving that area to the side. The second step consists
×
of cutting the rectangle in half top to bottom and moving the top half to the right side of the
bottom half. Both of these steps keep the total area the same.
5) No value increases beyond x y = 2n 2n = 22n and hence is at most a 2n bit number, giving
× ×
that all additions take Θ(n) bit operations. The algorithmiterates log (ℓ)=n times. Hence, the
2
total algorithm uses at most Θ(n2) bit operations, which is quadratic in the size 2n of the input.
This time equivalent to that needed for the high school algorithm for multiplying.
Ifpebblesareusedtheneventuallytheanswerx y iscountedoutinpebbles. Thisalonerequires
×
Ω(x y) = Ω(22n) pebble operations. This is exponential in the input size 2n. But if the input
×
is given to us in pebbles, it might be more fair to call the “size” the number of pebbles, which is
x+y. In which, case the time x y is also quadratic in the input size. Note this is equivalent in
×
time to lay out a rectangle of x by y pebbles.
6) Though this algorithm seems strange, it is in fact exactly the same as the high school algorithm
for multiplying in binary. One candetermine x in binary (eg 13=1101 ) by continuing to divide
2
by two and putting a one when the value is odd. Then the value y = 15 needs to be shifted to
the right for each digit of x that it gets multiplied to. Shifting to the right in binary amounts to
repeatedly doubling y. The digits of x which are 0, clearly destroy the corresponding shifted y.
Then the remaining shifted ys are added up to give the product.
Chapter 7: The Loop Invariant for Lower Bounds
Exercise 7.0.5: Intheworstcase,AlicemustcommunicateT (M)=log M bits. Theproofisidentical
lower 2
to that for sorting.
Exercise 7.0.7: Many people are tempted to give an algorithm with a running time of Θ(log(nm)) that
does some type of binary search. We, however, will will prove that this is impossible.
WestartbyprovingalowerboundofT(n,n)=2n 1onthenumberofmatrixentriesthatneedtobe
−
accessed when n =m. Recall that the matrix increase from A[1,1] to A[n,m] and that the boundary
between values that are less than or equal to x and those that are greater might follow the diagonal
A[1,n] to A[n,1]. Let I be the instance defined as follows. We let the prize being searched for be
x = 5. The diagonal A[1,n] to A[n,1] will be all 4. The next diagonal A[2,n] to A[n,2] will be all 6.
Let every element on the A[1,1] side of the diagonal be 0 and every one on the A[n,n] will be 9.
9
0 0 0 0 0 4
 
0 0 0 0 4 6
 0 0 0 4 6 9 
 
 0 0 4 6 9 9 
 
 0 4 6 9 9 9 
 
 4 6 9 9 9 9 
Noteeachrowandeachcolumnissorted. LetJ bethe4and6diagonalelements. IfoninstanceI,the
algorithm does not read one of these 2n 1 diagonal elements, then we change this unread diagonal
−
element to being 5. This changes the answer from five to six without violating the precondition of the
problem and without the algorithm knowing it.
We now give a T(n,m)= nlog (m) lower bound when m n. The above instance I contains blocks
2 n ≥
[4,6] of length 2 along the diagonal from A[1,n] to A[n,1]. Because the matrix is much wider, we
extend these blocks to be of length b = m. Each of these blocks will contain some number of 3’s,
n
followed by one 4, followed by some number of 6’s. For each j ,...,j [1..b], let J be the
1 n ∈ hj1,...,jni
instancewheretheblockinrowiwillhavethe4inthej th entryofitsblock. Forexample,withn=5,
i
m=20, b=4, and
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 [3 4 6 6]
 
0 0 0 0 0 0 0 0 0 0 0 0 [4 6 6 6] 9 9 9 9
A = 0 0 0 0 0 0 0 0 [3 3 3 4] 9 9 9 9 9 9 9 9 
h2,1,4,2,3i  
 0 0 0 0 [3 4 6 6] 9 9 9 9 9 9 9 9 9 9 9 9 
 
 [3 3 4 6] 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 
The intuition for the lower bound is that any algorithm solving this problem must find and access the
4 in each of these n blocks. Otherwise, this unaccessed 4 can be changed to a 5 as done before. The
best way for the algorithmto find the 4 in a block is to do binarysearch,requiring log(b) accesses,for
a total of T(n,m)=nlog (b) accesses.
2
More formally, the loop invariant of the lower bound algorithm will keep the set of instances S =
J j [a ,b ],...,j [a ,b ] for some ranges [a ,b ]. These ranges get cut in half as the
{ hj1,...,jni | 1 ∈ 1 1 1 ∈ n n } i i
algorithm accesses elements.
Exercise 7.0.8: Let I be the instance consisting of a heap of n elements, each being the value one. (If you
wantthem distinct, youcould make the elements be the values 1 to n.) Let J consistof all the leaves.
The smallest element in I is clearly one. For each j J, if we change this leaf element to be zero, the
∈
instance is still a valid heap and the answer changes from one to zero. Hence, if the algorithm does
not read one of the leaves when given instance I, it either gives the wrong answer on instance I or on
the instance with this value changed. Thus the problemof finding the smallestelement in a max heap
requires at least n/2 time.
⌈ ⌉
Chapter 9: Some Simple Examples of Recursive Algorithms
Exercise 9.1.3: The base case of the recursive algorithm for finding value x within A[1..n,1..m] is when
m n = 1. Then the algorithm simply does a binary search within this one row requiring access to
≥
T(n,m)=nlog (m)+2n log(n) 2=log (m) elements.
2 n − − 2
Ingeneral,thealgorithmfirstuseslog nelementaccessestodoabinarysearchwithinthe(m)thcolumn
2 2
looking for the rowi [1..n] such that A(i,m) x and A(i+1,m)>x. Because elements get smaller
∈ 2 ≤ 2
towards A[1,1], within the sub-matrix A(1..i,1..m), we need only consider A(i,m). Because elements
2 2
get larger towards A[n,m], we can ignore the sub-matrix A(i+1..n,m..m). Hence, we recursively
2
get one friend to search within the sub-matrix A(1..i,m+1..m) and another friend to search within
2
the sub-matrix A(i+1..n,1..m 1). Our answer is the best of A(i,m), the first friend’s answer, and
2 − 2
the second friend’s answer. Note the number of accesses satisfies the recurrence relation T(n,m)
≤
max T(i,m)+T(n i,m)+log n.
i∈[1,n] 2 − 2 2
10