Algorithms and data structures lecture iii
Download
1 / 42

Algorithms and Data Structures Lecture III - PowerPoint PPT Presentation


  • 142 Views
  • Uploaded on

Algorithms and Data Structures Lecture III. Simonas Šaltenis Aalborg University [email protected] 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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Algorithms and Data Structures Lecture III' - nadda


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Algorithms and data structures lecture iii

Algorithms and Data StructuresLecture III

Simonas Šaltenis

Aalborg University

[email protected]


This lecture
This Lecture

  • Divide-and-conquer technique for algorithm design. Example problems:

    • Tiling

    • Searching (binary search)

    • Sorting (merge sort).


Tiling

A tiling of the board with trominos:

Tiling

A tromino tile:

And a 2nx2n board with a hole:


Tiling trivial case n 1
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
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 problem1
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
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

  • 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: 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
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
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
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
Running Time of BS

  • T(n) = Q(lg n) !


Merge sort algorithm
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 algorithm1
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].
























Merge sort summarized
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
Running time of MergeSort

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


Repeated substitution method
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
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
Next Week

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


ad