Divide-and-Conquer 7 2  9 4   2   4   7

Slides:



Advertisements
Similar presentations
Divide-and-Conquer 7 2  9 4   2   4   7
Advertisements

AVL Trees1 Part-F2 AVL Trees v z. AVL Trees2 AVL Tree Definition (§ 9.2) AVL trees are balanced. An AVL Tree is a binary search tree such that.
A simple example finding the maximum of a set S of n numbers.
Theory of Computing Lecture 3 MAS 714 Hartmut Klauck.
Data Structures Lecture 9 Fang Yu Department of Management Information Systems National Chengchi University Fall 2010.
September 12, Algorithms and Data Structures Lecture III Simonas Šaltenis Nykredit Center for Database Research Aalborg University
Divide-and-Conquer Recursive in structure –Divide the problem into several smaller sub-problems that are similar to the original but smaller in size –Conquer.
1 Divide-and-Conquer CSC401 – Analysis of Algorithms Lecture Notes 11 Divide-and-Conquer Objectives: Introduce the Divide-and-conquer paradigm Review the.
Merge Sort1 Part-G1 Merge Sort 7 2  9 4   2  2 79  4   72  29  94  4.
Merge Sort1 7 2  9 4   2  2 79  4   72  29  94  4.
Divide-and-Conquer1 7 2  9 4   2  2 79  4   72  29  94  4.
Divide-and-Conquer1 7 2  9 4   2  2 79  4   72  29  94  4.
Data Structures, Spring 2004 © L. Joskowicz 1 Data Structures – LECTURE 3 Recurrence equations Formulating recurrence equations Solving recurrence equations.
Data Structures, Spring 2006 © L. Joskowicz 1 Data Structures – LECTURE 3 Recurrence equations Formulating recurrence equations Solving recurrence equations.
Analysis of Recursive Algorithms
Divide-and-Conquer1 7 2  9 4   2  2 79  4   72  29  94  4 Modified by: Daniel Gomez-Prado, University of Massachusetts Amherst.
CS 104 Introduction to Computer Science and Graphics Problems Data Structure & Algorithms (3) Recurrence Relation 11/11 ~ 11/14/2008 Yang Song.
Updates HW#1 has been delayed until next MONDAY. There were two errors in the assignment Merge sort runs in Θ(n log n). Insertion sort runs in Θ(n2).
Recurrences The expression: is a recurrence. –Recurrence: an equation that describes a function in terms of its value on smaller functions Analysis of.
CSE 421 Algorithms Richard Anderson Lecture 11 Recurrences.
Unit 1. Sorting and Divide and Conquer. Lecture 1 Introduction to Algorithm and Sorting.
Recurrences The expression: is a recurrence. –Recurrence: an equation that describes a function in terms of its value on smaller functions BIL741: Advanced.
October 1, Algorithms and Data Structures Lecture III Simonas Šaltenis Nykredit Center for Database Research Aalborg University
Divide-and-Conquer 7 2  9 4   2   4   7
CSC401: Analysis of Algorithms CSC401 – Analysis of Algorithms Chapter 5 – 2. Divide-and-Conquer Objectives: Introduce the Divide-and-conquer paradigm.
Divide-and-Conquer1 7 2  9 4   2  2 79  4   72  29  94  4.
Project 2 due … Project 2 due … Project 2 Project 2.
Divide and Conquer Andreas Klappenecker [based on slides by Prof. Welch]
File Organization and Processing Week 13 Divide and Conquer.
Recurrences David Kauchak cs161 Summer Administrative Algorithms graded on efficiency! Be specific about the run times (e.g. log bases) Reminder:
Divide and Conquer Andreas Klappenecker [based on slides by Prof. Welch]
Foundations II: Data Structures and Algorithms
Divide and Conquer. Recall Divide the problem into a number of sub-problems that are smaller instances of the same problem. Conquer the sub-problems by.
Master Method Some of the slides are from Prof. Plaisted’s resources at University of North Carolina at Chapel Hill.
Divide and Conquer Faculty Name: Ruhi Fatima Topics Covered Divide and Conquer Matrix multiplication Recurrence.
Recurrences It continues… Jeff Chastine. Recurrences When an algorithm calls itself recursively, its running time is described by a recurrence. A recurrence.
Merge Sort 1/12/2018 5:48 AM Merge Sort 7 2   7  2  2 7
Advanced Sorting 7 2  9 4   2   4   7
Chapter 11 Sorting Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms in C++, Goodrich, Tamassia and Mount.
Merge Sort 1/12/2018 9:39 AM Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia,
Merge Sort 1/12/2018 9:44 AM Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia,
Introduction to Algorithms
Mathematical Foundations (Solving Recurrence)
Modeling with Recurrence Relations
Lecture 11. Master Theorem for analyzing Recursive relations
Divide-and-Conquer 6/30/2018 9:16 AM
Unit 1. Sorting and Divide and Conquer
Chapter 4 Divide-and-Conquer
Quick-Sort 9/12/2018 3:26 PM Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia,
Divide and Conquer.
More on Merge Sort CS 244 This presentation is not given in class
CSCE 411 Design and Analysis of Algorithms
Algorithms and Data Structures Lecture III
Divide-and-Conquer 7 2  9 4   2   4   7
Richard Anderson Lecture 11 Recurrences
Ch 4: Recurrences Ming-Te Chi
Merge Sort 2/23/ :15 PM Merge Sort 7 2   7  2   4  4 9
Merge Sort 2/24/2019 6:07 PM Merge Sort 7 2   7  2  2 7
Trevor Brown CS 341: Algorithms Trevor Brown
Merge Sort 4/10/ :25 AM Merge Sort 7 2   7  2   4  4 9
Quick-Sort 4/25/2019 8:10 AM Quick-Sort     2
Divide & Conquer Sorting
At the end of this session, learner will be able to:
Algorithms Recurrences.
Divide-and-Conquer 7 2  9 4   2   4   7
Merge Sort 5/30/2019 7:52 AM Merge Sort 7 2   7  2  2 7
Divide and Conquer Merge sort and quick sort Binary search
Algorithms and Data Structures Lecture III
Divide-and-Conquer 7 2  9 4   2   4   7
Presentation transcript:

Divide-and-Conquer 7 2  9 4  2 4 7 9 7  2  2 7 9  4  4 9 7  7 4/7/2019 1:14 AM Divide-and-Conquer 7 2  9 4  2 4 7 9 7  2  2 7 9  4  4 9 7  7 2  2 9  9 4  4 Divide-and-Conquer

Divide-and-Conquer Divide-and conquer is a general algorithm design paradigm: Divide: divide the input data S in two or more disjoint subsets S1, S2, … Conquer: solve the subproblems recursively Combine: combine the solutions for S1, S2, …, into a solution for S The base case for the recursion are subproblems of constant size Analysis can be done using recurrence equations Divide-and-Conquer

Divide the problem and Conquer the subproblems (“decomposition”) Divide-and-Conquer

Combine the solutions (“composition”) Divide-and-Conquer

Merge-Sort Merge-sort on an input sequence S with n elements consists of three steps: Divide: partition S into two sequences S1 and S2 of about n/2 elements each Conquer: recursively sort S1 and S2 Combine: merge S1 and S2 into a unique sorted sequence Algorithm mergeSort(S) Input sequence S with n elements Output sequence S sorted according to C if S.size() > 1 (S1, S2)  partition(S, n/2) mergeSort(S1) mergeSort(S2) S  merge(S1, S2) Divide-and-Conquer

Merging 2 sorted sequences 1 5 7 10 2 3 6 8 Divide-and-Conquer

Merging 2 sorted sequences 1 5 7 10 left 2 3 6 8 right 1 Divide-and-Conquer

Merging 2 sorted sequences 1 5 7 10 left 2 3 6 8 right 1 2 Divide-and-Conquer

Merging 2 sorted sequences 1 5 7 10 left 2 3 6 8 right 1 2 3 Divide-and-Conquer

Merging 2 sorted sequences 1 5 7 10 left 2 3 6 8 right 1 2 3 5 Divide-and-Conquer

Merging—Analysis Comparison and copying are the main operations 1 5 7 10 2 3 6 8 1 2 3 5 6 7 8 10 Comparison and copying are the main operations Copying—always n operations (n items after merging) Comparison when does the worst case occur? when does the best case occur? Divide-and-Conquer

Time Complexity Merging two sorted sequences, each with n/2 elements takes at most bn steps, for some constant b. base case (n < 2) [or n = 1] takes at most b steps. let T(n) denote the running time: closed form solution to the above equation. That is, a solution that has T(n) only on the left-hand side. Divide-and-Conquer

Time Complexity Merging two sorted sequences, each with n/2 elements takes at most bn steps, for some constant b. base case (n < 2) [or n = 1] takes at most b steps. let T(n) denote the running time: closed form solution to the above equation. That is, a solution that has T(n) only on the left-hand side. or T(1) = b Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Base case, T(1)=b, occurs when 2i=n. That is, i = log n. Divide-and-Conquer

Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Base case, T(1)=b, occurs when 2i=n. That is, i = log n. So, Thus, T(n) is O(n log n). Divide-and-Conquer

(last level plus all previous levels) The Recursion Tree Draw the recursion tree for the recurrence relation and look for a pattern: time bn … depth T’s size 1 n 2 n/2 i 2i n/2i … Total time = bn + bn log n (last level plus all previous levels) Divide-and-Conquer

Skipping the rest Divide-and-Conquer

Guess-and-Test Method In the guess-and-test method, we guess a closed form solution and then try to prove it is true by induction: Guess: T(n) < cn log n. Wrong: we cannot make this last line be less than cn log n Divide-and-Conquer

Guess-and-Test Method, (cont.) Recall the recurrence equation: Guess #2: T(n) < cn log2 n. if c > b. So, T(n) is O(n log2 n). In general, to use this method, you need to have a good guess and you need to be good at induction proofs. Divide-and-Conquer

Master Method (Appendix) Many divide-and-conquer recurrence equations have the form: The Master Theorem: Divide-and-Conquer

Solution: logba=2, so case 1 says T(n) is O(n2). Master Method, Example 1 The form: The Master Theorem: Example: Solution: logba=2, so case 1 says T(n) is O(n2). Divide-and-Conquer

Solution: logba=1, so case 2 says T(n) is O(n log2 n). Master Method, Example 2 The form: The Master Theorem: Example: Solution: logba=1, so case 2 says T(n) is O(n log2 n). Divide-and-Conquer

Solution: logba=0, so case 3 says T(n) is O(n log n). Master Method, Example 3 The form: The Master Theorem: Example: Solution: logba=0, so case 3 says T(n) is O(n log n). Divide-and-Conquer

Solution: logba=3, so case 1 says T(n) is O(n3). Master Method, Example 4 The form: The Master Theorem: Example: Solution: logba=3, so case 1 says T(n) is O(n3). Divide-and-Conquer

Solution: logba=2, so case 3 says T(n) is O(n3). Master Method, Example 5 The form: The Master Theorem: Example: Solution: logba=2, so case 3 says T(n) is O(n3). Divide-and-Conquer

Solution: logba=0, so case 2 says T(n) is O(log n). Master Method, Example 6 The form: The Master Theorem: Example: (binary search) Solution: logba=0, so case 2 says T(n) is O(log n). Divide-and-Conquer

Solution: logba=1, so case 1 says T(n) is O(n). Master Method, Example 7 The form: The Master Theorem: Example: (heap construction) Solution: logba=1, so case 1 says T(n) is O(n). Divide-and-Conquer

Iterative “Proof” of the Master Theorem Using iterative substitution, let us see if we can find a pattern: We then distinguish the three cases as The first term is dominant Each part of the summation is equally dominant The summation is a geometric series Divide-and-Conquer

Integer Multiplication Algorithm: Multiply two n-bit integers I and J. Divide step: Split I and J into high-order and low-order bits We can then define I*J by multiplying the parts and adding: So, T(n) = 4T(n/2) + n, which implies T(n) is O(n2). But that is no better than the algorithm we learned in grade school. Divide-and-Conquer

An Improved Integer Multiplication Algorithm Algorithm: Multiply two n-bit integers I and J. Divide step: Split I and J into high-order and low-order bits Observe that there is a different way to multiply parts: So, T(n) = 3T(n/2) + n, which implies T(n) is O(nlog23), by the Master Theorem. Thus, T(n) is O(n1.585). Divide-and-Conquer