1 / 42

Algorithms and Data Structures Lecture III

Learn about the divide-and-conquer technique in algorithm design with examples like tiling, searching, and sorting. Understand how to solve problems using recursion and combining subproblem solutions.

rosehelen
Download Presentation

Algorithms and Data Structures Lecture III

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Algorithms and Data StructuresLecture III Simonas Šaltenis Aalborg University simas@cs.auc.dk

  2. This Lecture • Divide-and-conquer technique for algorithm design. Example problems: • Tiling • Searching (binary search) • Sorting (merge sort).

  3. A tiling of the board with trominos: Tiling A tromino tile: And a 2nx2n board with a hole:

  4. Tiling: Trivial Case (n = 1) • Trivial case (n = 1): tiling a 2x2 board with a hole: • Idea – try somehow to reduce the size of the original problem, so that we eventually get to the 2x2 boards which we know how to solve…

  5. Tiling: Dividing the Problem • To get smaller square boards let’s divide the original board into for boards • Great! We have one problem of the size 2n-1x2n-1! • But: The other three problems are not similar to the original problems – they do not have holes!

  6. Tiling: Dividing the Problem • Idea: insert one tromino at the center to get three holes in each of the three smaller boards • Now we have four boards with holes of the size 2n-1x2n-1. • Keep doing this division, until we get the 2x2 boards with holes – we know how to tile those

  7. Tiling: Algorithm INPUT: n – the board size (2nx2n board), L – location of the hole. OUTPUT: tiling of the board Tile(n, L) if n = 1 then Trivial case Tile with one tromino return Divide the board into four equal-sized boards Place one tromino at the center to cut out 3 additional holes Let L1, L2, L3, L4 denote the positions of the 4 holes Tile(n-1, L1) Tile(n-1, L2) Tile(n-1, L3) Tile(n-1, L4)

  8. Divide and Conquer • Divide-and-conquer method for algorithm design: • If the problem size is small enough to solve it in a straightforward manner, solve it. Else: • Divide: Divide the problem into two or more disjoint subproblems • Conquer: Use divide-and-conquer recursively to solve the subproblems • Combine: Take the solutions to the subproblems and combine these solutions into a solution for the original problem

  9. Tiling: Divide-and-Conquer • Tiling is a divide-and-conquer algorithm: • Just do it trivially if the board is 2x2, else: • Divide the board into four smaller boards (introduce holes at the corners of the three smaller boards to make them look like original problems) • Conquer using the same algorithm recursively • Combine by placing a single tromino in the center to cover the three introduced holes

  10. Binary Search • Find a number in a sorted array: • Just do it trivially if the array is of one element • Else divide into two equal halves and solve each half • Combine the results INPUT: A[1..n] – a sorted (non-decreasing) array of integers, s – an integer. OUTPUT: an index j such that A[j] = s. NIL, if "j (1£j£n): A[j] ¹ s Binary-search(A, p, r, s): if p = r then if A[p] = s then return p else return NIL q¬ë(p+r)/2û ret ¬ Binary-search(A, p, q, s) if ret = NIL then return Binary-search(A, q+1, r, s) else return ret

  11. Recurrences • Running times of algorithms with Recursive calls can be described using recurrences • A recurrence is an equation or inequality that describes a function in terms of its value on smaller inputs • Example: Binary Search

  12. Binary Search (improved) INPUT: A[1..n] – a sorted (non-decreasing) array of integers, s – an integer. OUTPUT: an index j such that A[j] = s. NIL, if "j (1£j£n): A[j] ¹ s Binary-search(A, p, r, s): if p = r then if A[p] = s then return p else return NIL q¬ë(p+r)/2û if A[q] £ s then return Binary-search(A, p, q, s) else return Binary-search(A, q+1, r, s) • T(n) = Q(n) – not better than brute force! • Clever way to conquer: • Solve only one half!

  13. Running Time of BS • T(n) = Q(lg n) !

  14. Merge Sort Algorithm • Divide: If S has at least two elements (nothing needs to be done if S has zero or one elements), remove all the elements from S and put them into two sequences, S1 and S2 , each containing about half of the elements of S. (i.e. S1 contains the firstén/2ù elements and S2 contains the remaining ën/2û elements). • Conquer: Sort sequences S1 and S2 using Merge Sort. • Combine: Put back the elements into S by merging the sorted sequences S1 and S2 into one sorted sequence

  15. Merge Sort: Algorithm Merge-Sort(A, p, r) if p < r then q¬ ë(p+r)/2û Merge-Sort(A, p, q) Merge-Sort(A, q+1, r) Merge(A, p, q, r) Merge(A, p, q, r) Take the smallest of the two topmost elements of sequences A[p..q] and A[q+1..r] and put into the resulting sequence. Repeat this, until both sequences are empty. Copy the resulting sequence into A[p..r].

  16. MergeSort (Example) - 1

  17. MergeSort (Example) - 2

  18. MergeSort (Example) - 3

  19. MergeSort (Example) - 4

  20. MergeSort (Example) - 5

  21. MergeSort (Example) - 6

  22. MergeSort (Example) - 7

  23. MergeSort (Example) - 8

  24. MergeSort (Example) - 9

  25. MergeSort (Example) - 10

  26. MergeSort (Example) - 11

  27. MergeSort (Example) - 12

  28. MergeSort (Example) - 13

  29. MergeSort (Example) - 14

  30. MergeSort (Example) - 15

  31. MergeSort (Example) - 16

  32. MergeSort (Example) - 17

  33. MergeSort (Example) - 18

  34. MergeSort (Example) - 19

  35. MergeSort (Example) - 20

  36. MergeSort (Example) - 21

  37. MergeSort (Example) - 22

  38. Merge Sort Summarized • To sort n numbers • if n=1 done! • recursively sort 2 lists of numbers ën/2û and én/2ù elements • merge 2 sorted lists in Q(n) time • Strategy • break problem into similar (smaller) subproblems • recursively solve subproblems • combine solutions to answer

  39. Running time of MergeSort • Again the running time can be expressed as a recurrence:

  40. Repeated Substitution Method • Let’s find the running time of merge sort (let’s assume that n=2b, for some b).

  41. Example: Finding Min and Max • Given an unsorted array, find a minimum and a maximum element in the array INPUT: A[l..r] – an unsorted array of integers, l £ r. OUTPUT: (min, max) such that "j (l£j£r): A[j] ³min and A[j] £max MinMax(A, l, r): if l = r then return (A[l], A[r]) Trivial case q¬ ë(l+r)/2û Divide (minl, maxl)¬ MinMax(A, l, q) (minr, maxr)¬ MinMax(A, q+1, r) if minl < minr then min = minl else min = minr if maxl > maxr then max = maxl else max = maxr return (min, max) Conquer Combine

  42. Next Week • Analyzing the running time of recursive algorithms (such as divide-and-conquer)

More Related