Download - Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong
![Page 1: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/1.jpg)
Algorithmic FoundationsCOMP108
COMP108Algorithmic FoundationsDivide and Conquer
Prudence Wonghttp://www.csc.liv.ac.uk/~pwong/teaching/comp108/201415
![Page 2: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/2.jpg)
Algorithmic FoundationsCOMP108
Pancake SortingInput: Stack of pancakes, each of different sizesOutput: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
finish
4
1
32
41
32
start
![Page 3: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/3.jpg)
Algorithmic FoundationsCOMP108Triomino Puzzle
Input: 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 overlappingIs it do-able?
2n
2n
![Page 4: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/4.jpg)
Algorithmic FoundationsCOMP108
4(Divide & Conquer)
Learning outcomes 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
![Page 5: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/5.jpg)
Algorithmic FoundationsCOMP108
5(Divide & Conquer)
Divide and ConquerOne of the best-known algorithm design
techniquesIdea:
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
![Page 6: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/6.jpg)
Algorithmic FoundationsCOMP108
Merge Sort …
![Page 7: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/7.jpg)
Algorithmic FoundationsCOMP108
7(Divide & Conquer)
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
![Page 8: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/8.jpg)
Algorithmic FoundationsCOMP108
8(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 21
we want to sort these 8 numbers,divide them into two halves
![Page 9: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/9.jpg)
Algorithmic FoundationsCOMP108
9(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
divide these 4 numbers into
halves
similarly for these 4
![Page 10: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/10.jpg)
Algorithmic FoundationsCOMP108
10(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 21further divide each shorter sequence …
until we get sequence with only 1 number
![Page 11: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/11.jpg)
Algorithmic FoundationsCOMP108
11(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
merge pairs of single number
into a sequence of 2 sorted numbers
![Page 12: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/12.jpg)
Algorithmic FoundationsCOMP108
12(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
13, 51 10, 64 5, 34 21, 32then merge again into
sequences of 4 sorted numbers
![Page 13: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/13.jpg)
Algorithmic FoundationsCOMP108
13(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
13, 51 10, 64 5, 34 21, 3210, 13, 51, 64 5, 21, 32, 34
one more merge give the final sorted sequence
![Page 14: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/14.jpg)
Algorithmic FoundationsCOMP108
14(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
13, 51 10, 64 5, 34 21, 32
5, 10, 13, 21, 32, 34, 51, 6410, 13, 51, 64 5, 21, 32, 34
![Page 15: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/15.jpg)
Algorithmic FoundationsCOMP108
15(Divide & Conquer)
SummaryDivide
dividing a sequence of n numbers into two smaller sequences is straightforward
Conquer merging two sorted sequences of total
length n can also be done easily, at most n-1 comparisons
![Page 16: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/16.jpg)
Algorithmic FoundationsCOMP108
16(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
To merge two sorted sequences,we keep two pointers, one to each sequence
Result:
Compare the two numbers pointed,copy the smaller one to the result
and advance the corresponding pointer
![Page 17: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/17.jpg)
Algorithmic FoundationsCOMP108
17(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
Then compare again the two numberspointed to by the pointer;
copy the smaller one to the resultand advance that pointer
5, Result:
![Page 18: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/18.jpg)
Algorithmic FoundationsCOMP108
18(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
Repeat the same process …5, 10, Result:
![Page 19: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/19.jpg)
Algorithmic FoundationsCOMP108
19(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
Again …5, 10, 13 Result:
![Page 20: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/20.jpg)
Algorithmic FoundationsCOMP108
20(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
and again …5, 10, 13, 21 Result:
![Page 21: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/21.jpg)
Algorithmic FoundationsCOMP108
21(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
…5, 10, 13, 21, 32Result:
![Page 22: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/22.jpg)
Algorithmic FoundationsCOMP108
22(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
When we reach the end of one sequence,simply copy the remaining numbers in the other
sequence to the result
5, 10, 13, 21, 32, 34 Result:
![Page 23: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/23.jpg)
Algorithmic FoundationsCOMP108
23(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34
Then we obtain the final sorted sequence5, 10, 13, 21, 32, 34, 51, 64 Result:
![Page 24: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/24.jpg)
Algorithmic FoundationsCOMP108
24(Divide & Conquer)
Pseudo codeAlgorithm Mergesort(A[1..n])
if n > 1 then begincopy 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
![Page 25: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/25.jpg)
Algorithmic FoundationsCOMP108
25(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
13, 51 10, 64 5, 34 21, 32
5, 10, 13, 21, 32, 34, 51, 6410, 13, 51, 64 5, 21, 32, 34
MS( )
MS(
MS(
MS(
MS( )
) MS( ) MS( ) MS( )
)MS( ) MS( )MS( ) MS( )MS( ) MS( )MS( )
M( ), M( ),
M( , )
)
![Page 26: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/26.jpg)
Algorithmic FoundationsCOMP108
)
26(Divide & Conquer)
51, 13, 10, 64, 34, 5, 32, 2151, 13, 10, 64 34, 5, 32, 21
51, 13 10, 64 34, 5 32, 2151 13 10 64 34 5 32 21
13, 51 10, 64 5, 34 21, 32
5, 10, 13, 21, 32, 34, 51, 6410, 13, 51, 64 5, 21, 32, 34
MS( )
MS(
MS(
MS(
MS( )
) MS( ) MS( ) MS( )
)MS( ) MS( )MS( ) MS( )MS( ) MS( )MS( )
M( ), M( ),
M( , )
1
2
3 4
5
6
7 8
9
10
11
12
13 14
15
16
17 18
19
20
21order of execution
![Page 27: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/27.jpg)
Algorithmic FoundationsCOMP108
27(Divide & Conquer)
Pseudo codeAlgorithm Merge(B[1..p], C[1..q], A[1..p+q])
set i=1, j=1, k=1while i<=p and j<=q dobegin
if B[i]C[j] thenset A[k] = B[i] and i = i+1
else set A[k] = C[j] and j = j+1k = k+1
endif i==p+1 then copy C[j..q] to A[k..(p+q)]else copy B[i..p] to A[k..(p+q)]
![Page 28: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/28.jpg)
Algorithmic FoundationsCOMP108
28(Divide & Conquer)
10, 13, 51, 64 5, 21, 32, 34B: C:p=4 q=4
i j k A[ ]
Before loop 1 1 1 empty
End of 1st iteration 1 2 2 5
End of 2nd iteration
2 2 3 5, 10
End of 3rd 3 2 4 5, 10, 13
End of 4th 3 3 5 5, 10, 13, 21
End of 5th 3 4 6 5, 10, 13, 21, 32
End of 6th 3 5 7 5, 10, 13, 21, 32, 34
5, 10, 13, 21, 32, 34, 51, 64
![Page 29: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/29.jpg)
Algorithmic FoundationsCOMP108
29(Divide & Conquer)
Time complexityLet T(n) denote the time complexity of running merge sort on n numbers.
1 if n=12T(n/2) + notherwise
T(n) =
We call this formula a recurrence.
A recurrence is an equation or inequality that describes a function in terms of its value on smaller inputs.To solve a recurrence is to derive asymptotic bounds on the solution
![Page 30: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/30.jpg)
Algorithmic FoundationsCOMP108
30(Divide & Conquer)
Time complexityProve that is O(n log n)
Make a guess: T(n) 2 n log n (We prove by MI)
For the base case when n=2,L.H.S = T(2) = 2T(1) + 2 = 4,R.H.S = 2 2 log 2 = 4L.H.S R.H.S
1 if n=12T(n/2) + notherwise
T(n) =
Substitution method
![Page 31: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/31.jpg)
Algorithmic FoundationsCOMP108
31(Divide & Conquer)
Time complexityProve that is O(n log n)
Make a guess: T(n) 2 n log n (We prove by MI)Assume true for all n'<n [assume T(n/2) 2 (n/2) log(n/2)]
T(n)= 2T(n/2)+n 2 (2(n/2)xlog(n/2)) + n= 2 n (log n - 1) + n= 2 n log n - 2n + n 2 n log n
i.e., T(n) 2 n log n
1 if n=12T(n/2) + notherwise
T(n) =
by hypothesis
![Page 32: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/32.jpg)
Algorithmic FoundationsCOMP108
32(Divide & Conquer)
Example
Guess: T(n) 2 log n
1 if n=1T(n/2) + 1 otherwise
T(n) =
For the base case when n=2,L.H.S = T(2) = T(1) + 1 =
2R.H.S = 2 log 2 = 2L.H.S R.H.S
![Page 33: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/33.jpg)
Algorithmic FoundationsCOMP108
33(Divide & Conquer)
Example
Guess: T(n) 2 log n
Assume true for all n' < n [assume T(n/2) 2 x log (n/2)] T(n) = T(n/2) + 1 2 x log(n/2) + 1 by hypothesis= 2x(log n – 1) + 1 log(n/2) = log n – log 2< 2log n
1 if n=1T(n/2) + 1 otherwise
T(n) =
i.e., T(n) 2 log n
![Page 34: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/34.jpg)
Algorithmic FoundationsCOMP108
34(Divide & Conquer)
More exampleProve that is O(n)
Guess: T(n) 2n – 1
For the base case when n=1,L.H.S = T(1) = 1R.H.S = 21 - 1 = 1 L.H.S R.H.S
1 if n=12T(n/2) + 1otherwise
T(n) =
![Page 35: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/35.jpg)
Algorithmic FoundationsCOMP108
35(Divide & Conquer)
More exampleProve that is O(n)
Guess: T(n) 2n – 1Assume true for all n' < n [assume T(n/2) 2(n/2)-
1] T(n) = 2T(n/2)+1
2 (2(n/2)-1) + 1 by hypothesis
=2n – 2 + 1=2n - 1
i.e., T(n) 2n-1
1 if n=12T(n/2) + 1otherwise
T(n) =
![Page 36: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/36.jpg)
Algorithmic FoundationsCOMP108
36(Divide & Conquer)
SummaryDepending on the recurrence, we can guess
the order of growthT(n) = T(n/2)+1 T(n) is O(log n)T(n) = 2T(n/2)+1 T(n) is O(n)T(n) = 2T(n/2)+n T(n) is O(n log n)
![Page 37: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/37.jpg)
Algorithmic FoundationsCOMP108
Tower of Hanoi …
![Page 38: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/38.jpg)
Algorithmic FoundationsCOMP108
38(Divide & Conquer)
Tower of Hanoi - Initial configThere are three pegs and some discs of different sizes are on Peg A
321
A B C
![Page 39: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/39.jpg)
Algorithmic FoundationsCOMP108
39(Divide & Conquer)
Tower of Hanoi - Final config Want to move the discs to Peg C
321
A B C
![Page 40: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/40.jpg)
Algorithmic FoundationsCOMP108
40(Divide & Conquer)
Tower of Hanoi - RulesOnly 1 disk can be moved at a timeA disc cannot be placed on top of other discs
that are smaller than it
32
Target: Use the smallest number of moves
![Page 41: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/41.jpg)
Algorithmic FoundationsCOMP108
41(Divide & Conquer)
Tower of Hanoi - One disc onlyEasy!
1A B C
![Page 42: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/42.jpg)
Algorithmic FoundationsCOMP108
42(Divide & Conquer)
Tower of Hanoi - One disc onlyEasy! Need one move only.
1A B C
![Page 43: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/43.jpg)
Algorithmic FoundationsCOMP108
43(Divide & Conquer)
Tower of Hanoi - Two discsWe first need to move Disc-2 to C, How?
21
A B C
by moving Disc-1 to B first, then Disc-2 to C
![Page 44: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/44.jpg)
Algorithmic FoundationsCOMP108
44(Divide & Conquer)
Tower of Hanoi - Two discsNext?
2A B C
1
Move Disc-1 to C
![Page 45: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/45.jpg)
Algorithmic FoundationsCOMP108
45(Divide & Conquer)
Tower of Hanoi - Two discsDone!
21
A B C
![Page 46: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/46.jpg)
Algorithmic FoundationsCOMP108
46(Divide & Conquer)
Tower of Hanoi - Three discsWe first need to move Disc-3 to C, How?
Move Disc-1&2 to B (recursively)
321
A B C
![Page 47: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/47.jpg)
Algorithmic FoundationsCOMP108
47(Divide & Conquer)
Tower of Hanoi - Three discsWe first need to move Disc-3 to C, How?
Move Disc-1&2 to B (recursively)
3 2A B C
1
Then move Disc-3 to C
![Page 48: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/48.jpg)
Algorithmic FoundationsCOMP108
48(Divide & Conquer)
Tower of Hanoi - Three discsOnly task left: move Disc-1&2 to C (similarly as
before)
321
A B C
![Page 49: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/49.jpg)
Algorithmic FoundationsCOMP108
49(Divide & Conquer)
Tower of Hanoi - Three discsOnly task left: move Disc-1&2 to C (similarly as
before)
32A B C1
![Page 50: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/50.jpg)
Algorithmic FoundationsCOMP108
50(Divide & Conquer)
Tower of Hanoi - Three discsDone!
321
A B C
![Page 51: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/51.jpg)
Algorithmic FoundationsCOMP108
Tower of HanoiToH(num_disc, source, dest, spare)begin
if (num_disc > 1) thenToH(num_disc-1, source, spare, dest)
Move the disc from source to destif (num_disc > 1) then
ToH(num_disc-1, spare, dest, source)end
51(Divide & Conquer)
invoke by callingToH(3, A, C, B)
![Page 52: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/52.jpg)
Algorithmic FoundationsCOMP108
52(Divide & Conquer)
ToH(3, A, C, B)
move 1 discfrom A to C
ToH(2, A, B, C) ToH(2, B, C, A)
ToH(1, A, C, B) ToH(1, C, B, A)
move 1 discfrom A to B
move 1 discfrom A to C
move 1 discfrom C to B
ToH(1, B, A, C) ToH(1, A, C, B)
move 1 discfrom B to C
move 1 discfrom B to A
move 1 discfrom A to C
![Page 53: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/53.jpg)
Algorithmic FoundationsCOMP108
53(Divide & Conquer)
ToH(3, A, C, B)
move 1 discfrom A to C
ToH(2, A, B, C) ToH(2, B, C, A)
ToH(1, A, C, B) ToH(1, C, B, A)
move 1 discfrom A to B
move 1 discfrom A to C
move 1 discfrom C to B
ToH(1, B, A, C) ToH(1, A, C, B)
move 1 discfrom B to C
move 1 discfrom B to A
move 1 discfrom A to C
1
2
3
45
6
7 8
9
10
1112
13
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;
![Page 54: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/54.jpg)
Algorithmic FoundationsCOMP108
54(Divide & Conquer)
move n-1 discs from
B to C
Time complexityT(n) = T(n-1) + 1 +T(n-1)
Let T(n) denote the time complexity of running the Tower of Hanoi algorithm on n discs.
1 if n=12T(n-1) + 1 otherwise
move n-1 discs from
A to Bmove Disc-n from A to C
T(n) =
![Page 55: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/55.jpg)
Algorithmic FoundationsCOMP108
55(Divide & Conquer)
Time complexity (2)T(n) = 2T(n-1) + 1
= 2[2T(n-2) + 1] + 1= 22 T(n-2) + 2 + 1= 22 [2T(n-3) + 1] + 21 + 20
= 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
= 2n-1
1 if n=12T(n-1) + 1otherwise
T(n) =
In Tutorial 2, we prove by MI that20 + 21 + … + 2n-1 = 2n-1
i.e., T(n) is O(2n)iterative method
![Page 56: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/56.jpg)
Algorithmic FoundationsCOMP108
56(Divide & Conquer)
Summary - continuedDepending on the recurrence, we can guess
the order of growthT(n) = T(n/2)+1 T(n) is O(log n)T(n) = 2T(n/2)+1 T(n) is O(n)T(n) = 2T(n/2)+n T(n) is O(n log n)T(n) = 2T(n-1)+1 T(n) is O(2n)
![Page 57: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/57.jpg)
Algorithmic FoundationsCOMP108
Fibonacci number …
![Page 58: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/58.jpg)
Algorithmic FoundationsCOMP108
Fibonacci's Rabbits
58(Divide & Conquer)
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.
end ofmonth-0
end ofmonth-1
end ofmonth-3
end ofmonth-4
How many at end of
month-5, 6,7and so on?
end ofmonth-2
![Page 59: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/59.jpg)
Algorithmic FoundationsCOMP108
Petals on flowers
59(Divide & Conquer)
1 petal:white calla lily
2 petals:euphorbia
3 petals:trillium
5 petals:columbine
8 petals:bloodroot
13 petals:black-eyed susan
21 petals:shasta daisy
34 petals:field daisy
Search: Fibonacci Numbers in Nature
![Page 60: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/60.jpg)
Algorithmic FoundationsCOMP108
60(Divide & Conquer)
Fibonacci numberFibonacci number F(n)
F(n) = 1 if n = 0 or 1F(n-1) + F(n-2) if n > 1
n 0 1 2 3 4 5 6 7 8 9 10F(n) 1 1 2 3 5 8 13 21 34 55 89
Pseudo code for the recursive algorithm:Algorithm F(n)
if n==0 or n==1 thenreturn 1
elsereturn F(n-1) + F(n-2)
![Page 61: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/61.jpg)
Algorithmic FoundationsCOMP108
61(Divide & Conquer)
The execution of F(7)F7
F6
F5
F5
F4 F3
F3
F2
F1 F0
F2
F1 F0
F1
F2
F1 F0
F2
F1 F0
F2
F1 F0
F4 F4
F3
F3
F3
F2
F1 F0
F2
F1 F0
F2
F1 F0
F1
F1 F1
F1
![Page 62: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/62.jpg)
Algorithmic FoundationsCOMP108
62(Divide & Conquer)
The execution of F(7)F7
F6
F5
F5
F4 F3
F3
F2
F1 F0
F2
F1 F0
F1
F2
F1 F0
F2
F1 F0
F2
F1 F0
F4 F4
F3
F3
F3
F2
F1 F0
F2
F1 F0
F2
F1 F0
F1
F1 F1
F1
12
3
4
56
78
9
1013
18
27
order of execution(not everything shown)
![Page 63: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/63.jpg)
Algorithmic FoundationsCOMP108
63(Divide & Conquer)
The execution of F(7)F7
F6
F5
F5
F4 F3
F3
F2
F1 F0
F2
F1 F0
F1
F2
F1 F0
F2
F1 F0
F2
F1 F0
F4 F4
F3
F3
F3
F2
F1 F0
F2
F1 F0
F2
F1 F0
F1
F1 F1
F1
return value(not everything shown)
1 12
31
2
5
8
3
5
13 821
![Page 64: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/64.jpg)
Algorithmic FoundationsCOMP108
64(Dynamic Programming)
Time complexity - exponentialf(n) = f(n-1) + f(n-2) + 1
= [f(n-2)+f(n-3)+1] + f(n-2) + 1> 2 f(n-2)> 2 [2f(n-2-2)] = 22 f(n-4)> 22 [2f(n-4-2)] = 23 f(n-6)> 23 [2f(n-6-2)] = 24 f(n-8)…> 2k f(n-2k)
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
exponential in n
Suppose f(n) denote the
time complexity to compute F(n)
![Page 65: Algorithmic Foundations COMP108 COMP108 Algorithmic Foundations Divide and Conquer Prudence Wong](https://reader035.vdocuments.mx/reader035/viewer/2022062401/5a4d1b887f8b9ab0599bd8d5/html5/thumbnails/65.jpg)
Algorithmic FoundationsCOMP108Robozzle - Recursion
Task: to program a robot to pick up all stars in a certain area
Command: Go straight, Turn Left, Turn Right