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)