Algorithms and Data Structures Lecture III

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

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

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

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…

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!

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

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)

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

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

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

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

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!

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

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

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].

MergeSort (Example) - 1

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

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

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

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

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

Algorithms and Data Structures Lecture III