Algorithm Pancake PDF

Download as pdf or txt
Download as pdf or txt
You are on page 1of 22

Pancake Sorting

Algorithms
and Data Structures

Input: Stack of pancakes, each of different sizes


Output: Arrange in order of size (smallest on top)
Action: Slip a flipper under one of the pancakes and
flip over the whole stack above the flipper

Divide and Conquer


(Decrease & Conquer)

3
2

finish

Prof. Dr. Qin Xin

start

2
3
4

A Flip

Action: Slip a flipper under one of the pancakes and


flip over the whole stack above the flipper
3
2
4

flip here

1
4
2
3
1

How?

2
4

2
3

3
1
2

1
3
2

3
4

3
4

Done!

More Pancakes?
2
4
5
1
6
3

Divide/Decrease and Conquer

For n pancakes, at most 2(n-1) flips

Learning outcomes

Decrease and Conquer


Idea:
A problem instance is changed into one smaller
instance of the same problem
The smaller instance is solved, typically recursively
The solution for the smaller instance is converted to
get a solution for the larger instance

 Understand how divide and conquer works and


able to analyse complexity of divide and conquer
methods by solving recurrence
 See examples of divide and conquer methods

(Divide & Conquer)

(Divide & Conquer)

Binary Search

Binary Search (2)


we first work on n numbers, from a[1]..a[n]

Recall that we have learnt binary search:


Input: a sequence of n sorted numbers a1, a2, ,
an; and a number X
Idea of algorithm:

3 7 11 12

15 19 24 33
24

41 55

19 24 33
24
further reduce by half 19 24
24

41 55

then we work on n/2 numbers,


from a[n/2+1]..a[n]

compare X with number in the middle


then focus on only the first half or the second half
(depend on whether X is smaller or greater than
the middle number)
reduce the amount of numbers to be searched by
half
9

10

(Divide & Conquer)

(Divide & Conquer)

Recursive Binary Search (RBS)

Recursive Binary Search


RecurBinarySearch(A, first, last, X)
invoke by calling
begin
RecurBinarySearch(A, 1, n, X)
if (first > last) then
return true if X is found,
return false
false otherwise
mid = (first + last)/2
if (X == A[mid]) then
return true
if (X < A[mid]) then
return RecurBinarySearch(A, first, mid-1, X)
else
return RecurBinarySearch(A, mid+1, last, X)
end

A[1]

30 70

A[2]

A[3]

A[4]

A[5]

A[6]

A[7]

110

120 150 190 240

A[8]

To find 190

A[9]

330 410

A[10]

550

RBS(A, 1, 10, 190)


if 1 > 10? No; mid = 5; if 190 == A[5]? No; if 190 < A[5]? No
RBS(A, 6, 10, 190)

if 6 > 10? No; mid = 8; if 190 == A[8]? No; if 190 < A[8]? Yes
RBS(A, 6, 7, 190)

if 6 > 7? No; mid = 6; if 190 == A[6]? YES; return true

RBS(A, 6, 7, 190) is done, return true

RBS(A, 6, 10, 190) is done, return true

RBS(A, 1, 10, 190) is done, return true

11

12

(Divide & Conquer)

(Divide & Conquer)

Recursive Binary Search (RBS)

A[1]

A[2]

A[3]

A[4]

30 70

RBS(A, 1, 10, 230)

A[5]

A[6]

A[7]

110

120 150 190 240

A[8]

To find 230

A[9]

330 410

Time complexity

A[10]

550

Let T(n) denote the time complexity of binary


search algorithm on n numbers.

if 1 > 10? No; mid = 5; if 230 == A[5]? No; if 230 < A[5]? No
RBS(A, 6, 10, 230)

T(n) =

if 6 > 10? No; mid = 8; if 230 == A[8]? No; if 230 < A[8]? Yes
RBS(A, 6, 7, 230)

if 6 > 7? No; mid = 6; if 230 == A[6]? No; if 230 < A[6]? No


RBS(A, 7, 7, 230)

if 7 > 7? No; mid = 7; if 230 == A[7]? No; if 230 < A[7]? No


RBS(A, 8, 7, 230): if 8 > 7? Yes; return false
RBS(A, 8, 7, 230) is done, return false
RBS(A, 7, 7, 230) is done, return false

if n=1

T(n/2) + 1

otherwise

We call this formula a recurrence.

RBS(A, 6, 7, 230) is done, return false

RBS(A, 6, 10, 230) is done, return false

RBS(A, 1, 10, 230) is done, return false

13

14

(Divide & Conquer)

(Divide & Conquer)

Substitution method

Recurrence
A recurrence is an equation or inequality that
describes a function in terms of its value on smaller
inputs.
E.g.,
T(n) =

1
T(n/2) + 1

if n = 1
if n > 1

T(n) =

if n=1

T(n/2) + 1

otherwise

Make a guess, T(n) 2 log n


We prove statement by MI.
Base case? When n=1, statement is FALSE!

To solve a recurrence is to derive asymptotic


bounds on the solution

L.H.S = T(1) = 1
L.H.S

R.H.S = 2 log 1 = 0 <

Yet, when n=2,


L.H.S = T(2) = T(1) + 1 = 2
R.H.S = 2 log 2 = 2

15
(Divide & Conquer)

L.H.S R.H.S

16
(Divide & Conquer)

Triomino Puzzle

Substitution method
T(n) =

if n=1

T(n/2) + 1

otherwise

2n-by-2n chessboard with one missing


square &
many L-shaped tiles of 3 adjacent squares
Question: Cover the chessboard with L-shaped tiles
without overlapping
n
Input:

Make a guess, T(n) 2 log n

We prove statement by MI.


Assume true for all n' < n [assume T(n/2) 2 log (n/2)]
T(n) = T(n/2) + 1
by hypothesis
2 log (n/2) + 1
= 2(log n 1) + 1
log(n/2) = log n log 2
< 2log n

Is it do-able?

2n

i.e., T(n) 2 log n


17
(Divide & Conquer)

Triomino Puzzle
2n-by-2n chessboard with one missing
square &
many L-shaped tiles of 3 adjacent squares
Question: Cover the chessboard with L-shaped tiles
without overlapping 2n
Is it do-able?
Input:

Input:

Triomino Puzzle

2n-by-2n chessboard with one missing


square & many L-shaped tiles of 3
adjacent squares
2n-1

2n-1

2n-1

2n

2n-1

Divide and Conquer


One of the best-known algorithm design techniques
Idea:
A problem instance is divided into several smaller
instances of the same problem, ideally of about
same size
The smaller instances are solved, typically
recursively
The solutions for the smaller instances are combined
to get a solution to the large instance

Merge Sort

21
(Divide & Conquer)

51, 13, 10, 64, 34, 5, 32, 21

Merge sort
 using divide and conquer technique
 divide the sequence of n numbers into two halves
 recursively sort the two halves
 merge the two sorted halves into a single sorted
sequence

we want to sort these 8 numbers,


divide them into two halves

23

24

(Divide & Conquer)

(Divide & Conquer)

51, 13, 10, 64, 34, 5, 32, 21


51, 13, 10, 64

51, 13, 10, 64, 34, 5, 32, 21

34, 5, 32, 21

divide these 4
numbers into
halves

51, 13, 10, 64


51, 13

similarly for
these 4

10, 64

51, 13, 10, 64

51

13

32, 21

25

26

(Divide & Conquer)

(Divide & Conquer)

51, 13, 10, 64, 34, 5, 32, 21

34, 5, 32, 21

10, 64
10

34, 5

further divide each shorter sequence


until we get sequence with only 1 number

51, 13, 10, 64, 34, 5, 32, 21

51, 13

34, 5, 32, 21

64

merge pairs of
single number
into a sequence
of 2 sorted
numbers

34, 5
34

51, 13, 10, 64

32, 21
32

21

51, 13
51

10, 64

13

13, 51

34, 5, 32, 21

10

64

10, 64

34, 5
34

32, 21
32

5, 34

21

21, 32

then merge again into sequences


of 4 sorted numbers
27

28

(Divide & Conquer)

(Divide & Conquer)

51, 13, 10, 64, 34, 5, 32, 21


51, 13, 10, 64
51, 13
51

13

13, 51

34, 5, 32, 21

10, 64
10

51, 13, 10, 64, 34, 5, 32, 21

64

10, 64

34, 5
34

32, 21
32

5, 34

10, 13, 51, 64

51, 13, 10, 64

21

21, 32

5, 21, 32, 34

51, 13
51

13

13, 51

10, 64
10

34, 5
34

5, 34

32, 21
32

21

21, 32

5, 21, 32, 34

5, 10, 13, 21, 32, 34, 51, 64

29

(Divide & Conquer)

Summary

64

10, 64

10, 13, 51, 64

one more merge give the final sorted sequence

34, 5, 32, 21

30
(Divide & Conquer)

10, 13, 51, 64

5, 21, 32, 34

Divide
dividing a sequence of n numbers into two
smaller sequences is straightforward

Result:

Conquer

To merge two sorted sequences,


we keep two pointers, one to each sequence

merging two sorted sequences of total length n


can also be done easily, at most n-1 comparisons

Compare the two numbers pointed,


copy the smaller one to the result
and advance the corresponding pointer
31

32

(Divide & Conquer)

(Divide & Conquer)

10, 13, 51, 64

5, 21, 32, 34

10, 13, 51, 64

Result: 5,

5, 21, 32, 34

Result: 5, 10,

Then compare again the two numbers


pointed to by the pointer;
copy the smaller one to the result
and advance that pointer

10, 13, 51, 64

Repeat the same process

33

34

(Divide & Conquer)

(Divide & Conquer)

5, 21, 32, 34

10, 13, 51, 64

Result: 5, 10, 13

5, 21, 32, 34

Result: 5, 10, 13, 21


Again

and again

35

36

(Divide & Conquer)

(Divide & Conquer)

10, 13, 51, 64

5, 21, 32, 34

10, 13, 51, 64

Result: 5, 10, 13, 21, 32

Result: 5, 10, 13, 21, 32, 34


When we reach the end of one sequence,
simply copy the remaining numbers in the other
sequence to the result

10, 13, 51, 64

5, 21, 32, 34

37

38

(Divide & Conquer)

(Divide & Conquer)

Pseudo code

5, 21, 32, 34

Algorithm Mergesort(A[1..n])
if n > 1 then begin
copy A[1..n/2] to B[1..n/2]
copy A[n/2+1..n] to C[1..n/2]
Mergesort(B[1..n/2])
Mergesort(C[1..n/2])
Merge(B, C, A)
end

Result: 5, 10, 13, 21, 32, 34, 51, 64


Then we obtain the final sorted sequence

39

40

(Divide & Conquer)

(Divide & Conquer)

MS( 51, 13, 10, 64, 34, 5, 32, 21


MS( 51, 13, 10, 64

MS( 51, 13, 10, 64, 34, 5, 32, 21


1

MS( 34, 5, 32, 21

MS( 10) MS( 64)

MS(34)MS(

5)

MS( 32)MS(21)

MS( 51)MS( 13)

M(

10, 64 )

10, 13, 51, 64

M( 5, 34
,

21, 32 )

5, 21, 32, 34

MS( 10) MS( 64)

10, 64 )

M( 5, 34

10

M(

10, 13, 51, 64


21

5, 10, 13, 21, 32, 34, 51, 64

M( 13, 51

20
)
5, 21, 32, 34
42

order(Divide
of execution
& Conquer)

(Divide & Conquer)

p=4

q=4

B: 10, 13, 51, 64

Algorithm Merge(B[1..p], C[1..q], A[1..p+q])


set i=1, j=1, k=1
while i<=p and j<=q do
begin
if B[i]C[j] then
set A[k] = B[i] and i = i+1
else set A[k] = C[j] and j = j+1
k = k+1
end
if i==p+1 then copy C[j..q] to A[k..(p+q)]
else copy B[i..p] to A[k..(p+q)]

21, 32 )

5, 10, 13, 21, 32, 34, 51, 64

41

Pseudo code

16
12
MS( 34, 5 ) MS( 32, 21 )
13
14 17
18
MS(34)MS( 5)
MS( 32)MS(21)
15
19

MS( 51, 13 ) MS( 10, 64 )

5
M( 13, 51

MS( 34, 5, 32, 21

11
)

MS( 51, 13, 10, 64

MS( 34, 5 ) MS( 32, 21 )

MS( 51, 13 ) MS( 10, 64 )


MS( 51)MS( 13)

C: 5, 21, 32, 34

A[ ]

Before loop

empty

End of 1st iteration

End of 2nd iteration

5, 10

End of 3rd

5, 10, 13

End of 4th

5, 10, 13, 21

End of 5th

5, 10, 13, 21, 32

End of 6th

5, 10, 13, 21, 32, 34


5, 10, 13, 21, 32, 34, 51, 64

43

44

(Divide & Conquer)

(Divide & Conquer)

Time complexity

Time complexity

Prove that T(n) = 1

Let T(n) denote the time complexity of


running merge sort on n numbers.

T(n) =

1
2T(n/2) + n

is O(n log n)

2T(n/2) + n otherwise

Guess: T(n) 2 n log n

if n=1
otherwise

For the base case when n=2,


L.H.S = T(2) = 2T(1) + 2 = 4,
R.H.S = 2 2 log 2 = 4
L.H.S R.H.S

45

46

(Divide & Conquer)

(Divide & Conquer)

Time complexity
1 n)
Prove that T(n)
is O(n= log

if n=1

More example

if n=1

Prove that T(n) = 1

2T(n/2) + n otherwise

if n=1

is O(n)

2T(n/2) + 1 otherwise

Guess: T(n) 2 n log n


Assume true for all n'<n [assume T(n/2) 2 (n/2) log(n/2)]
by hypothesis
T(n) = 2
T(n/2)+n
2 (2
(n/2)log (n/2)) + n
= 2 n (log n - 1) + n
= 2 n log n - 2n + n
2 n log n

Guess: T(n) 2n 1

i.e., T(n) 2 n log n

For the base case when


n=1,
L.H.S = T(1) = 1
R.H.S = 21 - 1 = 1
L.H.S R.H.S

47

48

(Divide & Conquer)

(Divide & Conquer)

More example
Prove that

T(n) =

if n=1

is O(n)

2T(n/2) + 1 otherwise

Guess: T(n) 2n 1
Assume true for all n' < n [assume T(n/2) 2(n/2)-1]
T(n) = 2
T(n/2)+1
2 (2
(n/2)-1) + 1

Summary
Depending on the recurrence, we can guess the
order of growth
T(n) = T(n/2)+1
T(n) is O(log n)
T(n) = 2
T(n/2)+1
T(n) is O(n)
T(n) = 2
T(n/2)+n
T(n) is O(n log n)

by hypothesis

= 2n 2 + 1
= 2n - 1

i.e., T(n) 2n-1


49

50

(Divide & Conquer)

(Divide & Conquer)

Exercise
Prove that

T(n) =

Exercise
if n=1

O(n log n)

4T(n/4) + n otherwise

Prove that

T(n) =

if n=1

O(n log n)

4T(n/4) + n otherwise

Guess: T(n) n log n

Guess: T(n) n log n

Base case: When n = 4,

Induction hypothesis: Assume the property holds


for all n < n, i.e., assume that
T(n/4) (n/4) log (n/4)

L.H.S. = T(4) = 4 x T(1) + 4 = 4 x 1 + 4 = 8


R.H.S. = 4 x log 4 = 4 x 2 = 8

51

52

(Divide & Conquer)

(Divide & Conquer)

Exercise
Prove that

T(n) =

if n=1

is O(n log n)

4T(n/4) + n otherwise

Guess: T(n) n log n

Tower of Hanoi

Induction step:
T(n)

= 4 x T(n/4) + n
4 x ( (n/4) log (n/4) ) + n
= n log (n/4) + n
= n (log n log 4) + n
= n log n 2n + n < n log n

53
(Divide & Conquer)

Tower of Hanoi - Initial config

Tower of Hanoi - Final config

There are three pegs and some discs of different


sizes are on Peg A

1
2
3
A

Want to move the discs to Peg C

55
(Divide & Conquer)

1
2
3
C

56
(Divide & Conquer)

Tower of Hanoi - Rules

Tower of Hanoi - One disc only

Only 1 disk can be moved at a time


A disc cannot be placed on top of other discs that
are smaller than it

Easy!

3
2

Target: Use the smallest number of moves


57

1
A

(Divide & Conquer)

Tower of Hanoi - One disc only

(Divide & Conquer)

Tower of Hanoi - Two discs


We first need to move Disc-2 to C, How?

Easy! Need one move only.

58

by moving Disc-1 to B first, then Disc-2 to C

1
C

59
(Divide & Conquer)

1
2
A

60
(Divide & Conquer)

Tower of Hanoi - Two discs

Tower of Hanoi - Two discs

Next?
Move Disc-1 to C

Done!

1
B

2
C

61

1
2
C

(Divide & Conquer)

Tower of Hanoi - Three discs

We first need to move Disc-3 to C, How?


Move Disc-1&2 to B (recursively)
Then move Disc-3 to C

Move Disc-1&2 to B (recursively)

(Divide & Conquer)

Tower of Hanoi - Three discs

We first need to move Disc-3 to C, How?

1
2
3
A

62

63
(Divide & Conquer)

3
A

2
B

1
C

64
(Divide & Conquer)

Tower of Hanoi - Three discs

Tower of Hanoi - Three discs

Only task left: move Disc-1&2 to C (similarly as


before)

1
2
B

3
C

Only task left: move Disc-1&2 to C (similarly as


before)

65

1
A

2
B

(Divide & Conquer)

Tower of Hanoi - Three discs

ToH(num_disc, source, dest, spare)


begin
if (num_disc > 1) then
ToH(num_disc-1, source, spare, dest)
Move the disc from source to dest

if (num_disc > 1) then


ToH(num_disc-1, spare, dest, source)
end

1
2
3
C

66
(Divide & Conquer)

Tower of Hanoi

Done!

3
C

invoke by calling
ToH(3, A, C, B)

67

68

(Divide & Conquer)

(Divide & Conquer)

ToH(3, A, C, B)

ToH(3, A, C, B)
1

ToH(2, A, B, C)

ToH(1, A, C, B)

move 1 disc
from A to C

ToH(1, C, B, A)

ToH(2, B, C, A)

ToH(1, B, A, C)

move 1 disc
from A to B
move 1 disc
from A to C

ToH(2, A, B, C)

2
ToH(1, A, C, B)

move 1 disc
from B to C
move 1 disc
from C to B

move 1 disc
from B to A

ToH(1, A, C, B)

3
move 1 disc
from A to C

move 1 disc
from A to C

move 1 disc
from A to C

6
move 1 disc
from C to B

10

T(n) = T(n-1)

+ 1 + T(n-1)

move n-1
move n-1
discs from
discs from
A to B
B to C
move Disc-n
from A to C

T(n) =

if n=1

2T(n-1) + 1

otherwise

71
(Divide & Conquer)

12
ToH(1, A, C, B)

move 1 disc
from B to C

move 1 disc
from B to A

from A to C; from A to B; from C to B;


from A to C;
from B to A; from B to C; from A to C;

69

Let T(n) denote the


time complexity of
running the Tower of
Hanoi algorithm on n
discs.

ToH(1, B, A, C)

(Divide & Conquer)

Time complexity

ToH(2, B, C, A)

11

ToH(1, C, B, A)

move 1 disc
from A to B

13
move 1 disc
from A to C

70
(Divide & Conquer)

Time complexity (2)


T(n)

= 2
T(n-1) + 1
1
if n=1
T(n) =
2T(n-1) + 1 otherwise
T(n-2) + 1] + 1
= 2[2
= 22 T(n-2) + 2 + 1
T(n-3) + 1] + 21 + 20
= 22 [2
= 23 T(n-3) + 22 + 21 + 20

= 2k T(n-k) + 2k-1 + 2k-2 + + 22 + 21 + 20

= 2n-1 T(1) + 2n-2 + 2n-3 + + 22 + 21 + 20


= 2n-1 + 2n-2 + 2n-3 + + 22 + 21 + 20
i.e., T(n) is O(2n)
= 2n-1 In MI exercises, we prove by MI that
72

20 + 21 + + 2n-1 = 2n-1

(Divide & Conquer)

Summary - continued
Depending on the recurrence, we can guess the
order of growth
T(n) = T(n/2)+1

T(n) is O(log n)

T(n) = 2
T(n/2)+1
T(n) = 2
T(n/2)+n
T(n) = 2
T(n-1)+1

T(n) is O(n)
T(n) is O(n log n)
T(n) is O(2n)

Iterative Method

73
(Divide & Conquer)

Iterative method - Example 1

Iterative method (to solve recurrence)


The above method of solving a recurrence is
called the iterative method.
The method is to expand (iterate) the recurrence
until we arrive the base condition.

T(n) = T(n/2) + 1
= [T(n/4) + 1] + 1
= T(n/22) + 2
= [T(n/23) + 1] + 2
= T(n/23) + 3

T(n) =

if n=1

T(n/2) + 1

otherwise

Hence, T(n)
is O(log n)

= T(n/2k) + k

75
(Divide & Conquer)

= T(n/2log n) + log n
= T(1) + log n
= 1 + log n

76
(Divide & Conquer)

Iterative method - Example 2


T(n) = 2
T(n/2) + 1
T(n) =
T(n/4) + 1] + 1
= 2[2
= 22 T(n/22) + 2 + 1
= 22 [2
T(n/23) + 1] + 2 + 1
= 23 T(n/23) + 22 + 2 + 1

Iterative method - Example 3

if n=1

2T(n/2) + 1 otherwise

Hence,
T(n) is
O(n)

1
if n=1
T(n) = 2
T(n/2) + n
T(n) =
2T(n/2) + n otherwise
= 2[2
T(n/4) + n/2] + n
= 22 T(n/22) + n + n = 22 T(n/22) + 2n
= 22 [2
T(n/23) + n/22] + 2n
= 23 T(n/23) + 3n
Hence, T(n)

is O(n log
n)

2k T(n/2k)

2k-1

2k-2

++

22

+2+1

2k T(n/2k)

+ k
n

2log n T(n/2log n)

2logn-1 +

2logn-2

=
+
++
= n T(1) + n/2 + n/4 + ... + 4 + 2 + 1
= n + n/2 + n/4 + ... + 4 + 2 + 1 = 2n-1

22

+2+1

= 2log n T(n/2log n) + n log n


= n T(1) + n log n = n + n log n

77

78

(Divide & Conquer)

(Divide & Conquer)

Fibonacci's Rabbits
A pair of rabbits, one month old, is too young to reproduce.
Suppose that in their second month, and every month thereafter,
they produce a new pair.

Fibonacci number
end of
month-0

end of
month-1

end of
month-2

end of
month-4

end of
month-3

How many
at end of
month-5, 6,7
and so on? 80
(Divide & Conquer)

Petals on flowers

Fibonacci number

Fibonacci number F(n)

1
F(n-1) + F(n-2)

F(n) =
1 petal:
white calla lily

2 petals:
euphorbia

8 petals:
bloodroot

3 petals:
trillium

13 petals:
black-eyed susan

5 petals:
columbine

21 petals:
shasta daisy

if n = 0 or 1
if n > 1

F(n)

13

21

10

34 55 89

Pseudo code for the recursive algorithm:


Algorithm F(n)
if n==0 or n==1 then
return 1
else
return F(n-1) + F(n-2)

34 petals:
field daisy

Google: Fibonacci Numbers in Nature


81

82

(Divide & Conquer)

(Divide & Conquer)

The execution of F(7)

The execution of F(7)

F7

F6

F7

27

F6

F5

F5

18
F5

F4
F3

F4
F2

F3

F3

F2

F3

F2

F1 F0

F2

F1
F2

F3

F2

F1 F0

F1 F0 F1 F0
F1

F1 F0

F4

F1
83
(Divide & Conquer)

F2

F3

F2

F2
F1

F2

F1 F0

F2

F1
F2

F3

F1 F0

F1 F0 F1 F0
F1

F1 F0

F1 F0 F1 F0

F2

F3

F4

F1

F1
F1 F0

10
F2

F3

F1 F0 F1 F0

F3

13

F1
F2

F4

F2
F1

F4

F5

F1 F0

order of execution84

(not everything shown)


(Divide & Conquer)

Time complexity - exponential

The execution of F(7)

f(n) = f(n-1) + f(n-2) + 1

21
F7

13
F6

= [f(n-2)+f(n-3)+1] + f(n-2) + 1
F5

F5

F4

F3

> 2 f(n-2)

F4
F2

F3

F3

F2

Suppose f(n)
denote the
time
complexity to
compute F(n)

> 2 [2
f(n-2-2)] = 22 f(n-4)
> 22 [2
f(n-4-2)] = 23 f(n-6)

F2
F1

F4

3
F3

2
1

F2

2
F2

F3
F2

F2
F1 F0

F1 F0 F2
F1
F1 F0

> 23 [2
f(n-6-2)] = 24 f(n-8)

F1 F0 F1 F0
F1

F1

F1 F0 F1 F0

> 2k f(n-2k)

1 F1

F1 F0

return value

85

(not everything shown)


(Divide & Conquer)

Exercise on iterative method


T(n) =

T(n) = 2T(n-1) + 4
= 2[2xT(n-2) + 4] + 4
= 22 T(n-2) + 2x4 + 4
= 22 [2xT(n-3) + 4] + 21x4 + 20x4
= 23 T(n-3) + 22x4 + 21x4 + 20x4

2T(n-1) + 4 if n > 1

= 2k T(n-k) + 2k-1x4 + + 22x4 + 21x4 + 20x4

if n=1

= 2n-1 T(1) + 2n-2x4 + + 22x4 + 21x4 + 20x4


= 2n-1x4 + 2n-2x4 + + 22x4 + 21x4 + 20x4
= 4x(2n-1)

exponential in
n

If n is even, f(n) > 2n/2 f(0) = 2n/2


If n is odd, f(n) > f(n-1) > 2(n-1)/2
86
(Dynamic Programming)

You might also like