Greedy, Divide and Conquer
|
|
|
- Solomon Oliver
- 5 years ago
- Views:
Transcription
1 Greedy, ACA, IIT Kanpur October 5, 2013 Greedy,
2 Outline 1 Greedy Algorithms Greedy,
3 Greedy Algorithms Greedy algorithms are generally used in optimization problems Greedy,
4 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy,
5 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that Greedy,
6 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that try to maximize the function by making greedy choice at all points. In other words, we do at each step what seems best without planning ahead Greedy,
7 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that try to maximize the function by making greedy choice at all points. In other words, we do at each step what seems best without planning ahead ignores future possibilities (no planning ahead) Greedy,
8 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that try to maximize the function by making greedy choice at all points. In other words, we do at each step what seems best without planning ahead ignores future possibilities (no planning ahead) never changes choice (no backtracking) Greedy,
9 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that try to maximize the function by making greedy choice at all points. In other words, we do at each step what seems best without planning ahead ignores future possibilities (no planning ahead) never changes choice (no backtracking) Usually O(n) or O(n lg n) Solutions. Greedy,
10 Greedy Algorithms Greedy algorithms are generally used in optimization problems There is an optimal substructure to the problem Greedy Algorithms are algorithms that try to maximize the function by making greedy choice at all points. In other words, we do at each step what seems best without planning ahead ignores future possibilities (no planning ahead) never changes choice (no backtracking) Usually O(n) or O(n lg n) Solutions. But, We must be able to prove the correctness of a greedy algorithm if we are to be sure that it works Greedy,
11 Problem Problem 1: A family goes for picnic along a straight road. There are k hotels in their way situated at distances d 1,d 2... d k from the start. The last hotel is their destination. The can travel at most L length in day. However, they need to stay at a hotel at night. Find a strategy for the family so that they can reach hotel k in minimum number of days. Greedy,
12 Problem Solution: The rst solution that comes to mind is to travel on a particular day as long as possible, i.e. do not stop at a hotel i the next hotel can be reached on the same day. Greedy,
13 Problem Proof: Proof strategy 1 for greedy algorithms: Greedy solution stays ahead Suppose there is a better solution which stops at hotels i 1 < i 2... i r and greedy solution stops at j 1 < j 2... j s and r < s. Consider the rst place where the two solutions dier and let that index be p. Clearly i p < j p On a given day when non greedy solution starts from hotel i q <j q, non greedy solution cannot end up ahead of greedy solution. Therefore Greedy solution stays ahead Greedy,
14 Problem Problem 2: There are n processes that need to be executed. Process i takes a preprocessing time p i and time t i to execute afterwards. All preprocessing has to be done on a supercomputer and execution can be done on normal computers. We have only one supercomputer and n normal computers. Find a sequence in which to execute the processes such that the time taken to nish all the processes is minimum. Greedy,
15 Problem Solution: Sort in descending order of t i and execute them. At least this is the solution for which no counterexample is available. Greedy,
16 Problem Proof: Let there be any other ordering σ(1),σ(2)... σ(n) such that tσ(i) < tσ(i+1) for some i. Prove that by executing σ(i+1) before σ(i), we will do no worse. Keep applying this transformation until there are no inversions w.r.t. to t. This is our greedy solution. Greedy,
17 Problem Problem 3: A thief breaks into a shop only to nd that the stitches of his bag have become loose. There are N items in the shop that he can choose with weight W[i] and value V[i]. The total weight that the bag can carry is W. How should he choose the items to maximize the total value of the things he steals? Greedy,
18 Outline 1 Greedy Algorithms Greedy,
19 Greedy,
20 Suppose P(n) is the problem we are trying to solve, of size n Greedy,
21 Suppose P(n) is the problem we are trying to solve, of size n We can solve P(n) directly, for suciently small n Greedy,
22 Suppose P(n) is the problem we are trying to solve, of size n We can solve P(n) directly, for suciently small n Divides the problem P(n) into subproblems P 1 (n 1 ); P 2 (n 2 ); : : : ; P k (n k ) for some constant k Greedy,
23 Suppose P(n) is the problem we are trying to solve, of size n We can solve P(n) directly, for suciently small n Divides the problem P(n) into subproblems P 1 (n 1 ); P 2 (n 2 ); : : : ; P k (n k ) for some constant k Combine the solutions for P i (n i ) (1 i k) to solve P(n) Greedy,
24 Problem Problem 1: Merge-sort is divide-n-conquer. Analysis of merge-sort. T (n) 2T (n/2) + n Problem- Find number of inversions by modifying code for merge-sort slightly. Greedy,
25 ClosestPair Problem Closest Pair of points Given N points in a plane, nd the pair of points that are closest to each other. Greedy,
26 ClosestPair Problem Greedy,
27 ClosestPair Problem Figure: 1 Greedy,
28 ClosestPair Problem Figure: 1 Greedy,
29 ClosestPair Problem First sort the points in increasing order of X coordinate. Figure: 1 Greedy,
30 ClosestPair Problem First sort the points in increasing order of X coordinate. Divide the plane into two halves with equal number of points P1 and P2. Figure: 1 Greedy,
31 ClosestPair Problem First sort the points in increasing order of X coordinate. Divide the plane into two halves with equal number of points P1 and P2. Let d1 be the minimum distance between closest pair in the P1 and similarly d2 in P2. Figure: 1 Greedy,
32 ClosestPair Problem Figure: 1 First sort the points in increasing order of X coordinate. Divide the plane into two halves with equal number of points P1 and P2. Let d1 be the minimum distance between closest pair in the P1 and similarly d2 in P2. d1: minimum distance of P1 Greedy,
33 ClosestPair Problem Figure: 1 First sort the points in increasing order of X coordinate. Divide the plane into two halves with equal number of points P1 and P2. Let d1 be the minimum distance between closest pair in the P1 and similarly d2 in P2. d1: minimum distance of P1 d2: minimum distance of P2 Greedy,
34 ClosestPair Problem Figure: 1 First sort the points in increasing order of X coordinate. Divide the plane into two halves with equal number of points P1 and P2. Let d1 be the minimum distance between closest pair in the P1 and similarly d2 in P2. d1: minimum distance of P1 d2: minimum distance of P2 d min{d1, d2}. Greedy,
35 ClosestPair Problem Now, region of interest is the band of 2d around the dividing line. Greedy,
36 ClosestPair Problem Now, region of interest is the band of 2d around the dividing line. But, In fact, all of the points could be in the strip! This is disastrous, because we would have to compare n 2 pairs of points to merge the set, and hence our divideandconquer algorithm wouldn't save us anything in terms of eciency. Greedy,
37 ClosestPair Problem Figure: 2 Greedy,
38 ClosestPair Problem Thankfully, we can make another life saving observation at this point. For any particular point p in one strip, only points that meet the following constraints in the other strip need to be checked: 1 Those points within d of p in the direction of the other strip 2 Those within d of p in the positive and negative y directions because points outside of this bounding box cannot be less than d units from p. Figure: 2 Greedy,
39 ClosestPair Problem It just so happens that because every point in this box is at least d apart, there can be at most six points within it. Figure: 2 Greedy,
40 ClosestPair Problem It just so happens that because every point in this box is at least d apart, there can be at most six points within it. Now we don't need to check all n 2 points. All we have to do is sort the points in the strip by their y-coordinates and scan the points in order, checking each point against a maximum of 6 of its neighbors. Figure: 2 Greedy,
41 ClosestPair Problem It just so happens that because every point in this box is at least d apart, there can be at most six points within it. Now we don't need to check all n 2 points. All we have to do is sort the points in the strip by their y-coordinates and scan the points in order, checking each point against a maximum of 6 of its neighbors. This means at most 6 n comparisons are required to check all candidate pairs. Figure: 2 Greedy,
42 ClosestPair Problem Summary Greedy,
43 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. Greedy,
44 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. 2 Let d be the minimal of the two minimal distances. Greedy,
45 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. 2 Let d be the minimal of the two minimal distances. 3 Eliminate points that lie farther than d apart from l Greedy,
46 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. 2 Let d be the minimal of the two minimal distances. 3 Eliminate points that lie farther than d apart from l 4 Sort the remaining points according to their y-coordinates Greedy,
47 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. 2 Let d be the minimal of the two minimal distances. 3 Eliminate points that lie farther than d apart from l 4 Sort the remaining points according to their y-coordinates 5 Scan the remaining points in the y order and compute the distances of each point to its ve neighbors. Greedy,
48 ClosestPair Problem Summary 1 Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part. 2 Let d be the minimal of the two minimal distances. 3 Eliminate points that lie farther than d apart from l 4 Sort the remaining points according to their y-coordinates 5 Scan the remaining points in the y order and compute the distances of each point to its ve neighbors. 6 If any of these distances is less than d then update d. Greedy,
49 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Greedy,
50 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Greedy,
51 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Greedy,
52 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Step 4 is a sort that takes O(nlogn) time Greedy,
53 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Step 4 is a sort that takes O(nlogn) time Step 5 takes O(n) time (as we saw in the previous section) Greedy,
54 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Step 4 is a sort that takes O(nlogn) time Step 5 takes O(n) time (as we saw in the previous section) Step 6 takes O(1) time Greedy,
55 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Step 4 is a sort that takes O(nlogn) time Step 5 takes O(n) time (as we saw in the previous section) Step 6 takes O(1) time Hence the merging of the sub-solutions is dominated by the sorting at step 4, and hence takes O(nlogn) time. Greedy,
56 ClosestPair Problem Analysis Steps 2-6 dene the merging process which must be repeated log(n) times because this is a divide and conquer algortithm: Step 2 takes O(1) time Step 3 takes O(n) time Step 4 is a sort that takes O(nlogn) time Step 5 takes O(n) time (as we saw in the previous section) Step 6 takes O(1) time Hence the merging of the sub-solutions is dominated by the sorting at step 4, and hence takes O(nlogn) time. This must be repeated once for each level of recursion in the divide-and-conquer algorithm, hence the whole of algorithm ClosestPair takes O(logn*nlogn) = O(nlog 2 n) time. Greedy,
57 ClosestPair Problem Improving the Algorithm We can improve on this algorithm slightly by reducing the time it takes to achieve the y-coordinate sorting in Step 4. This is done by asking that the recursive solution computed in Step 1 returns the points in sorted order by their y coordinates. This will yield two sorted lists of points which need only be merged in Step 4 in order to yield a complete sorted list. Greedy,
58 ClosestPair Problem Improving the Algorithm Hence the revised algorithm involves making the following changes: Greedy,
59 ClosestPair Problem Improving the Algorithm Hence the revised algorithm involves making the following changes: Step 1: Divide the set into..., and recursively compute the distance in each part, returning the points in each set in sorted order by y-coordinate. Greedy,
60 ClosestPair Problem Improving the Algorithm Hence the revised algorithm involves making the following changes: Step 1: Divide the set into..., and recursively compute the distance in each part, returning the points in each set in sorted order by y-coordinate. Step 4: Merge the two sorted lists into one sorted list in O(n) time. Hence the merging process is now dominated by the linear time steps thereby yielding an O(nlogn) algorithm for nding the closest pair of a set of points in the plane. Greedy,
61 When to use divide and conquer Greedy,
62 When to use divide and conquer Divide and conquer works well when: Greedy,
63 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems Greedy,
64 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently Greedy,
65 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently The size of each subproblem is much smaller than the original Greedy,
66 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently The size of each subproblem is much smaller than the original is a bad choice when: Greedy,
67 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently The size of each subproblem is much smaller than the original is a bad choice when: There are too many subproblems Greedy,
68 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently The size of each subproblem is much smaller than the original is a bad choice when: There are too many subproblems The subproblems are not independent Greedy,
69 When to use divide and conquer Divide and conquer works well when: Divide step produces a constant number of subproblems The subproblems may be solved independently The size of each subproblem is much smaller than the original is a bad choice when: There are too many subproblems The subproblems are not independent The subproblems are too large Greedy,
70 Outline 1 Greedy Algorithms Greedy,
71 Problem: Finding a value in a sorted sequence For example, nd 55 in the sequence 0, 5, 13, 15, 24, 43, 55, 65, 72, 85, 96 Greedy,
72 Problem: Finding a value in a sorted sequence For example, nd 55 in the sequence 0, 5, 13, 15, 24, 43, 55, 65, 72, 85, 96 What is the time complexity? Greedy,
73 Problem: Finding a value in a sorted sequence For example, nd 55 in the sequence 0, 5, 13, 15, 24, 43, 55, 65, 72, 85, 96 What is the time complexity? At each step, we are discarding half of the array. Greedy,
74 Code Greedy,
75 Problem In a building with 100 (=n) storeys a person is required to nd starting from which oor an egg if thrown to the ground will be broken. He has been given just 2(=m) eggs for this task. All he can do is to go to certain storeys and throw his egg and record whether the egg broke or not. Assume that for each storey, an egg will either always break or will never break. Since, climbing stairs (there's no lift!), throwing eggs and going downstairs again to check whether the egg broke or not and to take the egg again to the next oor being checked can be a tiring process, devise a strategy following which the person will nd the required storey having after minimum number of throws Greedy,
76 Generalization Extending the idea of Problem 1 The same algorithm described above on any monotonic function f whose domain is the set of integers. The only dierence is that we replace an array lookup with a function evaluation: we are now looking for some x such that f(x) is equal to the target value Greedy,
77 Problem Problem: CodeJam Greedy,
78 Outline 1 Greedy Algorithms Greedy,
79 Links: Greedy,
80 Acknowledgements Image Credits: cs251/closestpair/closestpairdq.html Greedy,
LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS
Department of Computer Science University of Babylon LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS By Faculty of Science for Women( SCIW), University of Babylon, Iraq Samaher@uobabylon.edu.iq
CPSC W2 Midterm #2 Sample Solutions
CPSC 320 2014W2 Midterm #2 Sample Solutions March 13, 2015 1 Canopticon [8 marks] Classify each of the following recurrences (assumed to have base cases of T (1) = T (0) = 1) into one of the three cases
CAD Algorithms. Categorizing Algorithms
CAD Algorithms Categorizing Algorithms Mohammad Tehranipoor ECE Department 2 September 2008 1 Categorizing Algorithms Greedy Algorithms Prim s Algorithm (Minimum Spanning Tree) A subgraph that is a tree
Divide and Conquer 1
Divide and Conquer A Useful Recurrence Relation Def. T(n) = number of comparisons to mergesort an input of size n. Mergesort recurrence. T(n) if n T n/2 T n/2 solve left half solve right half merging n
Chapter 16: Greedy Algorithm
Chapter 16: Greedy Algorithm 1 About this lecture Introduce Greedy Algorithm Look at some problems solvable by Greedy Algorithm 2 Coin Changing Suppose that in a certain country, the coin dominations consist
Design and Analysis of Algorithms
Design and Analysis of Algorithms Instructor: SharmaThankachan Lecture 10: Greedy Algorithm Slides modified from Dr. Hon, with permission 1 About this lecture Introduce Greedy Algorithm Look at some problems
5.4 Closest Pair of Points
5.4 Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric primitive. Graphics, computer vision, geographic information
Divide-and-Conquer Algorithms
Divide-and-Conquer Algorithms Divide and Conquer Three main steps Break input into several parts, Solve the problem in each part recursively, and Combine the solutions for the parts Contribution Applicable
PRAM Divide and Conquer Algorithms
PRAM Divide and Conquer Algorithms (Chapter Five) Introduction: Really three fundamental operations: Divide is the partitioning process Conquer the the process of (eventually) solving the eventual base
ECE608 - Chapter 16 answers
¼ À ÈÌ Ê ½ ÈÊÇ Ä ÅË ½µ ½ º½¹ ¾µ ½ º½¹ µ ½ º¾¹½ µ ½ º¾¹¾ µ ½ º¾¹ µ ½ º ¹ µ ½ º ¹ µ ½ ¹½ ½ ECE68 - Chapter 6 answers () CLR 6.-4 Let S be the set of n activities. The obvious solution of using Greedy-Activity-
Programming II (CS300)
1 Programming II (CS300) Chapter 12: Sorting Algorithms MOUNA KACEM mouna@cs.wisc.edu Spring 2018 Outline 2 Last week Implementation of the three tree depth-traversal algorithms Implementation of the BinarySearchTree
Ch5. Divide-and-Conquer
Ch5. Divide-and-Conquer 1 5.1 Mergesort Sorting Sorting. Given n elements, rearrange in ascending order. Applications. Sort a list of names. Organize an MP3 library. obvious applications Display Google
5. DIVIDE AND CONQUER I
5. DIVIDE AND CONQUER I mergesort counting inversions closest pair of points randomized quicksort median and selection Lecture slides by Kevin Wayne Copyright 2005 Pearson-Addison Wesley Copyright 2013
16 Greedy Algorithms
16 Greedy Algorithms Optimization algorithms typically go through a sequence of steps, with a set of choices at each For many optimization problems, using dynamic programming to determine the best choices
Closest Pair of Points. Cormen et.al 33.4
Closest Pair of Points Cormen et.al 33.4 Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric problem. Graphics,
1 Dynamic Programming
CS161 Lecture 13 Dynamic Programming and Greedy Algorithms Scribe by: Eric Huang Date: May 13, 2015 1 Dynamic Programming The idea of dynamic programming is to have a table of solutions of subproblems
Applied Algorithm Design Lecture 3
Applied Algorithm Design Lecture 3 Pietro Michiardi Eurecom Pietro Michiardi (Eurecom) Applied Algorithm Design Lecture 3 1 / 75 PART I : GREEDY ALGORITHMS Pietro Michiardi (Eurecom) Applied Algorithm
4 INFORMED SEARCH AND EXPLORATION. 4.1 Heuristic Search Strategies
55 4 INFORMED SEARCH AND EXPLORATION We now consider informed search that uses problem-specific knowledge beyond the definition of the problem itself This information helps to find solutions more efficiently
COMP 352 FALL Tutorial 10
1 COMP 352 FALL 2016 Tutorial 10 SESSION OUTLINE Divide-and-Conquer Method Sort Algorithm Properties Quick Overview on Sorting Algorithms Merge Sort Quick Sort Bucket Sort Radix Sort Problem Solving 2
LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS
Department of Computer Science University of Babylon LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS By Faculty of Science for Women( SCIW), University of Babylon, Iraq Samaher@uobabylon.edu.iq
Programming II (CS300)
1 Programming II (CS300) Chapter 12: Sorting Algorithms MOUNA KACEM mouna@cs.wisc.edu Spring 2018 Outline 2 Last week Implementation of the three tree depth-traversal algorithms Implementation of the BinarySearchTree
Fast algorithms for max independent set
Fast algorithms for max independent set N. Bourgeois 1 B. Escoffier 1 V. Th. Paschos 1 J.M.M. van Rooij 2 1 LAMSADE, CNRS and Université Paris-Dauphine, France {bourgeois,escoffier,paschos}@lamsade.dauphine.fr
CPSC 320 Sample Solution: Physics, Tug-o-War, and Divide-and-Conquer
CPSC 30 Sample Solution: Physics, Tug-o-War, and Divide-and-Conquer February 4, 017 In tug-o-war, two teams face each other and carefully pull on a well-selected rope (to avoid injury). The team that pulls
CSE 421 Closest Pair of Points, Master Theorem, Integer Multiplication
CSE 421 Closest Pair of Points, Master Theorem, Integer Multiplication Shayan Oveis Gharan 1 Finding the Closest Pair of Points Closest Pair of Points (non geometric) Given n points and arbitrary distances
Notes in Computational Geometry Voronoi Diagrams
Notes in Computational Geometry Voronoi Diagrams Prof. Sandeep Sen and Prof. Amit Kumar Indian Institute of Technology, Delhi Voronoi Diagrams In this lecture, we study Voronoi Diagrams, also known as
7 Next choice is 4, not 3...
Math 0 opics for rst exam Chapter 1: Street Networks Operations research Goal: determine how to carry out a sequence of tasks most eciently Ecient: least cost, least time, least distance,... Example: reading
CMSC 451: Divide and Conquer
CMSC 451: Divide and Conquer Slides By: Carl Kingsford Department of Computer Science University of Maryland, College Park Based on Sections 5.1 5.3 of Algorithm Design by Kleinberg & Tardos. Greedy Recap
Design and Analysis of Algorithms 演算法設計與分析. Lecture 7 April 15, 2015 洪國寶
Design and Analysis of Algorithms 演算法設計與分析 Lecture 7 April 15, 2015 洪國寶 1 Course information (5/5) Grading (Tentative) Homework 25% (You may collaborate when solving the homework, however when writing
Divide and conquer algorithms. March 12, 2018 CSCI211 - Sprenkle. What is a recurrence rela&on? How can you compute D&C running &mes?
Objec&ves Divide and conquer algorithms Ø Coun&ng inversions Ø Closest pairs of points March 1, 018 CSCI11 - Sprenkle 1 Review What is a recurrence rela&on? How can you compute D&C running &mes? March
Theorem 2.9: nearest addition algorithm
There are severe limits on our ability to compute near-optimal tours It is NP-complete to decide whether a given undirected =(,)has a Hamiltonian cycle An approximation algorithm for the TSP can be used
Assignment 1. Stefano Guerra. October 11, The following observation follows directly from the definition of in order and pre order traversal:
Assignment 1 Stefano Guerra October 11, 2016 1 Problem 1 Describe a recursive algorithm to reconstruct an arbitrary binary tree, given its preorder and inorder node sequences as input. First, recall that
Greedy algorithms is another useful way for solving optimization problems.
Greedy Algorithms Greedy algorithms is another useful way for solving optimization problems. Optimization Problems For the given input, we are seeking solutions that must satisfy certain conditions. These
CSE 101 Homework 5. Winter 2015
CSE 0 Homework 5 Winter 205 This homework is due Friday March 6th at the start of class. Remember to justify your work even if the problem does not explicitly say so. Writing your solutions in L A TEXis
Convex Hull Algorithms
Convex Hull Algorithms Design and Analysis of Algorithms prof. F. Malucelli Villa Andrea e Ceriani Simone Outline Problem Definition Basic Concepts Bruteforce Algorithm Graham Scan Algorithm Divide and
Solutions to Problem Set 1
CSCI-GA.3520-001 Honors Analysis of Algorithms Solutions to Problem Set 1 Problem 1 An O(n) algorithm that finds the kth integer in an array a = (a 1,..., a n ) of n distinct integers. Basic Idea Using
Week - 04 Lecture - 01 Merge Sort. (Refer Slide Time: 00:02)
Programming, Data Structures and Algorithms in Python Prof. Madhavan Mukund Department of Computer Science and Engineering Indian Institute of Technology, Madras Week - 04 Lecture - 01 Merge Sort (Refer
CPSC 320 Sample Solution, Playing with Graphs!
CPSC 320 Sample Solution, Playing with Graphs! September 23, 2017 Today we practice reasoning about graphs by playing with two new terms. These terms/concepts are useful in themselves but not tremendously
Vertex Cover Approximations
CS124 Lecture 20 Heuristics can be useful in practice, but sometimes we would like to have guarantees. Approximation algorithms give guarantees. It is worth keeping in mind that sometimes approximation
Module 6 NP-Complete Problems and Heuristics
Module 6 NP-Complete Problems and Heuristics Dr. Natarajan Meghanathan Professor of Computer Science Jackson State University Jackson, MS 39217 E-mail: natarajan.meghanathan@jsums.edu P, NP-Problems Class
Sorting. There exist sorting algorithms which have shown to be more efficient in practice.
Sorting Next to storing and retrieving data, sorting of data is one of the more common algorithmic tasks, with many different ways to perform it. Whenever we perform a web search and/or view statistics
Algorithm classification
Types of Algorithms Algorithm classification Algorithms that use a similar problem-solving approach can be grouped together We ll talk about a classification scheme for algorithms This classification scheme
Figure 4.1: The evolution of a rooted tree.
106 CHAPTER 4. INDUCTION, RECURSION AND RECURRENCES 4.6 Rooted Trees 4.6.1 The idea of a rooted tree We talked about how a tree diagram helps us visualize merge sort or other divide and conquer algorithms.
Name: Lirong TAN 1. (15 pts) (a) Define what is a shortest s-t path in a weighted, connected graph G.
1. (15 pts) (a) Define what is a shortest s-t path in a weighted, connected graph G. A shortest s-t path is a path from vertex to vertex, whose sum of edge weights is minimized. (b) Give the pseudocode
Chapter 5. Divide and Conquer. Slides by Kevin Wayne. Copyright 2005 Pearson-Addison Wesley. All rights reserved.
Chapter 5 Divide and Conquer Slides by Kevin Wayne. Copyright 25 Pearson-Addison Wesley. All rights reserved. Divide-and-Conquer Divide-and-conquer. Break up problem into several parts. Solve each part
We will give examples for each of the following commonly used algorithm design techniques:
Review This set of notes provides a quick review about what should have been learned in the prerequisite courses. The review is helpful to those who have come from a different background; or to those who
Divide-Conquer-Glue Algorithms
Divide-Conquer-Glue Algorithms Closest Pair Tyler Moore CSE 3353, SMU, Dallas, TX Lecture 12 5. DIVIDE AND CONQUER mergesort counting inversions closest pair of points randomized quicksort median and selection
100 points total. CSE 3353 Homework 2 Spring 2013
Name: 100 points total CSE 3353 Homework 2 Spring 2013 Assignment is due at 9:30am on February 28. Submit a hard copy of the assignment, including a copy of your code and outputs as requested in the assignment.
CSE 421 Greedy Alg: Union Find/Dijkstra s Alg
CSE 1 Greedy Alg: Union Find/Dijkstra s Alg Shayan Oveis Gharan 1 Dijkstra s Algorithm Dijkstra(G, c, s) { d s 0 foreach (v V) d[v] //This is the key of node v foreach (v V) insert v onto a priority queue
Towards a Memory-Efficient Knapsack DP Algorithm
Towards a Memory-Efficient Knapsack DP Algorithm Sanjay Rajopadhye The 0/1 knapsack problem (0/1KP) is a classic problem that arises in computer science. The Wikipedia entry http://en.wikipedia.org/wiki/knapsack_problem
FINAL EXAM SOLUTIONS
COMP/MATH 3804 Design and Analysis of Algorithms I Fall 2015 FINAL EXAM SOLUTIONS Question 1 (12%). Modify Euclid s algorithm as follows. function Newclid(a,b) if a
Analysis of Algorithms - Greedy algorithms -
Analysis of Algorithms - Greedy algorithms - Andreas Ermedahl MRTC (Mälardalens Real-Time Reseach Center) andreas.ermedahl@mdh.se Autumn 2003 Greedy Algorithms Another paradigm for designing algorithms
Unconstrained Optimization
Unconstrained Optimization Joshua Wilde, revised by Isabel Tecu, Takeshi Suzuki and María José Boccardi August 13, 2013 1 Denitions Economics is a science of optima We maximize utility functions, minimize
Notes slides from before lecture. CSE 21, Winter 2017, Section A00. Lecture 9 Notes. Class URL:
Notes slides from before lecture CSE 21, Winter 2017, Section A00 Lecture 9 Notes Class URL: http://vlsicad.ucsd.edu/courses/cse21-w17/ Notes slides from before lecture Notes February 8 (1) HW4 is due
Greedy Algorithms. T. M. Murali. January 28, Interval Scheduling Interval Partitioning Minimising Lateness
Greedy Algorithms T. M. Murali January 28, 2008 Algorithm Design Start discussion of dierent ways of designing algorithms. Greedy algorithms, divide and conquer, dynamic programming. Discuss principles
Do you remember any iterative sorting methods? Can we produce a good sorting method by. We try to divide and conquer: break into subproblems
MERGESORT 315 Sorting Recursively Do you remember any iterative sorting methods? How fast are they? Can we produce a good sorting method by thinking recursively? We try to divide and conquer: break into
Sorting and Selection
Sorting and Selection Introduction Divide and Conquer Merge-Sort Quick-Sort Radix-Sort Bucket-Sort 10-1 Introduction Assuming we have a sequence S storing a list of keyelement entries. The key of the element
Greedy Algorithms CLRS Laura Toma, csci2200, Bowdoin College
Greedy Algorithms CLRS 16.1-16.2 Laura Toma, csci2200, Bowdoin College Overview. Sometimes we can solve optimization problems with a technique called greedy. A greedy algorithm picks the option that looks
Module 6 P, NP, NP-Complete Problems and Approximation Algorithms
Module 6 P, NP, NP-Complete Problems and Approximation Algorithms Dr. Natarajan Meghanathan Associate Professor of Computer Science Jackson State University Jackson, MS 39217 E-mail: natarajan.meghanathan@jsums.edu
Review implementation of Stable Matching Survey of common running times. Turn in completed problem sets. Jan 18, 2019 Sprenkle - CSCI211
Objectives Review implementation of Stable Matching Survey of common running times Turn in completed problem sets Jan 18, 2019 Sprenkle - CSCI211 1 Review: Asymptotic Analysis of Gale-Shapley Alg Not explicitly
Plan for Today. Finish recurrences. Inversion Counting. Closest Pair of Points
Plan for Today Finish recurrences Inversion Counting Closest Pair of Points Divide and Conquer Divide-and-conquer. Divide problem into several parts. Solve each part recursively. Combine solutions to sub-problems
Hi everyone. Starting this week I'm going to make a couple tweaks to how section is run. The first thing is that I'm going to go over all the slides
Hi everyone. Starting this week I'm going to make a couple tweaks to how section is run. The first thing is that I'm going to go over all the slides for both problems first, and let you guys code them
II (Sorting and) Order Statistics
II (Sorting and) Order Statistics Heapsort Quicksort Sorting in Linear Time Medians and Order Statistics 8 Sorting in Linear Time The sorting algorithms introduced thus far are comparison sorts Any comparison
Principles of Algorithm Design
Principles of Algorithm Design When you are trying to design an algorithm or a data structure, it s often hard to see how to accomplish the task. The following techniques can often be useful: 1. Experiment
Algorithm Design and Analysis
Algorithm Design and Analysis LECTURE 13 Divide and Conquer Closest Pair of Points Convex Hull Strassen Matrix Mult. Adam Smith 9/24/2008 A. Smith; based on slides by E. Demaine, C. Leiserson, S. Raskhodnikova,
CPSC W2: Quiz 3 Sample Solution
CPSC 320 2017W2: Quiz 3 Sample Solution 1 Ol' McDonald is safer, he hi he hi ho 1.1 Ol' McDonald is safer, he hi he hi ho (Group) The manager in a McDonald's comes to you with the following problem: she
CMPSCI 311: Introduction to Algorithms Practice Final Exam
CMPSCI 311: Introduction to Algorithms Practice Final Exam Name: ID: Instructions: Answer the questions directly on the exam pages. Show all your work for each question. Providing more detail including
Catalan Numbers. Table 1: Balanced Parentheses
Catalan Numbers Tom Davis tomrdavis@earthlink.net http://www.geometer.org/mathcircles November, 00 We begin with a set of problems that will be shown to be completely equivalent. The solution to each problem
9/10/12. Outline. Part 5. Computational Complexity (2) Examples. (revisit) Properties of Growth-rate functions(1/3)
Outline Part 5. Computational Complexity (2) Complexity of Algorithms Efficiency of Searching Algorithms Sorting Algorithms and Their Efficiencies CS 200 Algorithms and Data Structures 1 2 (revisit) Properties
Notes on Minimum Spanning Trees. Red Rule: Given a cycle containing no red edges, select a maximum uncolored edge on the cycle, and color it red.
COS 521 Fall 2009 Notes on Minimum Spanning Trees 1. The Generic Greedy Algorithm The generic greedy algorithm finds a minimum spanning tree (MST) by an edge-coloring process. Initially all edges are uncolored.
Dr. Amotz Bar-Noy s Compendium of Algorithms Problems. Problems, Hints, and Solutions
Dr. Amotz Bar-Noy s Compendium of Algorithms Problems Problems, Hints, and Solutions Chapter 1 Searching and Sorting Problems 1 1.1 Array with One Missing 1.1.1 Problem Let A = A[1],..., A[n] be an array
Analysis of Algorithms. Unit 4 - Analysis of well known Algorithms
Analysis of Algorithms Unit 4 - Analysis of well known Algorithms 1 Analysis of well known Algorithms Brute Force Algorithms Greedy Algorithms Divide and Conquer Algorithms Decrease and Conquer Algorithms
Midterm 2. Replace by cover page.
Midterm 2 Replace by cover page. Replace by conduct during examinations page. WRITE UGRAD IDs HERE (-1 mark if any missing or incorrect; use only the boxes you need) UGRAD ID #1: UGRAD ID #2: UGRAD ID
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING QUESTION BANK UNIT-III. SUB NAME: DESIGN AND ANALYSIS OF ALGORITHMS SEM/YEAR: III/ II PART A (2 Marks)
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING QUESTION BANK UNIT-III SUB CODE: CS2251 DEPT: CSE SUB NAME: DESIGN AND ANALYSIS OF ALGORITHMS SEM/YEAR: III/ II PART A (2 Marks) 1. Write any four examples
CSE 202 Divide-and-conquer algorithms. Fan Chung Graham UC San Diego
CSE 22 Divide-and-conquer algorithms Fan Chung Graham UC San Diego Announcements Homework due today before the class. About homework, write your own homework, allowing oral discussion with one fixed partner.
COSC 311: ALGORITHMS HW1: SORTING
COSC 311: ALGORITHMS HW1: SORTIG Solutions 1) Theoretical predictions. Solution: On randomly ordered data, we expect the following ordering: Heapsort = Mergesort = Quicksort (deterministic or randomized)
1 Format. 2 Topics Covered. 2.1 Minimal Spanning Trees. 2.2 Union Find. 2.3 Greedy. CS 124 Quiz 2 Review 3/25/18
CS 124 Quiz 2 Review 3/25/18 1 Format You will have 83 minutes to complete the exam. The exam may have true/false questions, multiple choice, example/counterexample problems, run-this-algorithm problems,
would be included in is small: to be exact. Thus with probability1, the same partition n+1 n+1 would be produced regardless of whether p is in the inp
1 Introduction 1.1 Parallel Randomized Algorihtms Using Sampling A fundamental strategy used in designing ecient algorithms is divide-and-conquer, where that input data is partitioned into several subproblems
Design and Analysis of Algorithms
CSE 101, Winter 018 D/Q Greed SP s DP LP, Flow B&B, Backtrack Metaheuristics P, NP Design and Analysis of Algorithms Lecture 8: Greed Class URL: http://vlsicad.ucsd.edu/courses/cse101-w18/ Optimization
12/30/2013 S. NALINI,AP/CSE
12/30/2013 S. NALINI,AP/CSE 1 UNIT I ITERATIVE AND RECURSIVE ALGORITHMS Iterative Algorithms: Measures of Progress and Loop Invariants-Paradigm Shift: Sequence of Actions versus Sequence of Assertions-
CSE 202 Divide-and-conquer algorithms. Fan Chung Graham UC San Diego
CSE 22 Divide-and-conquer algorithms Fan Chung Graham UC San Diego A useful fact about trees Any tree on n vertices contains a vertex v whose removal separates the remaining graph into two parts, one of
Design and Analysis of Algorithms
Design and Analysis of Algorithms CSE 5311 Lecture 16 Greedy algorithms Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 Overview A greedy
Greedy Algorithms CHAPTER 16
CHAPTER 16 Greedy Algorithms In dynamic programming, the optimal solution is described in a recursive manner, and then is computed ``bottom up''. Dynamic programming is a powerful technique, but it often
A 0 A 1... A i 1 A i,..., A min,..., A n 1 in their final positions the last n i elements After n 1 passes, the list is sorted.
CS6402 Design and Analysis of Algorithms _ Unit II 2.1 UNIT II BRUTE FORCE AND DIVIDE-AND-CONQUER 2.1 BRUTE FORCE Brute force is a straightforward approach to solving a problem, usually directly based
Weak Dynamic Coloring of Planar Graphs
Weak Dynamic Coloring of Planar Graphs Caroline Accurso 1,5, Vitaliy Chernyshov 2,5, Leaha Hand 3,5, Sogol Jahanbekam 2,4,5, and Paul Wenger 2 Abstract The k-weak-dynamic number of a graph G is the smallest
IN101: Algorithmic techniques Vladimir-Alexandru Paun ENSTA ParisTech
IN101: Algorithmic techniques Vladimir-Alexandru Paun ENSTA ParisTech License CC BY-NC-SA 2.0 http://creativecommons.org/licenses/by-nc-sa/2.0/fr/ Outline Previously on IN101 Python s anatomy Functions,
Lecture Notes on Quicksort
Lecture Notes on Quicksort 15-122: Principles of Imperative Computation Frank Pfenning Lecture 8 September 20, 2012 1 Introduction In this lecture we first sketch two related algorithms for sorting that
1 More on the Bellman-Ford Algorithm
CS161 Lecture 12 Shortest Path and Dynamic Programming Algorithms Scribe by: Eric Huang (2015), Anthony Kim (2016), M. Wootters (2017) Date: May 15, 2017 1 More on the Bellman-Ford Algorithm We didn t
1 Non greedy algorithms (which we should have covered
1 Non greedy algorithms (which we should have covered earlier) 1.1 Floyd Warshall algorithm This algorithm solves the all-pairs shortest paths problem, which is a problem where we want to find the shortest
The problem of minimizing the elimination tree height for general graphs is N P-hard. However, there exist classes of graphs for which the problem can
A Simple Cubic Algorithm for Computing Minimum Height Elimination Trees for Interval Graphs Bengt Aspvall, Pinar Heggernes, Jan Arne Telle Department of Informatics, University of Bergen N{5020 Bergen,
4 Dynamic Programming
4 Dynamic Programming Dynamic Programming is a form of recursion. In Computer Science, you have probably heard the tradeoff between Time and Space. There is a trade off between the space complexity and
Department of Computer Applications. MCA 312: Design and Analysis of Algorithms. [Part I : Medium Answer Type Questions] UNIT I
![Department of Computer Applications. MCA 312: Design and Analysis of Algorithms. [Part I : Medium Answer Type Questions] UNIT I](/thumbs/94/122075835.jpg "Department of Computer Applications. MCA 312: Design and Analysis of Algorithms. [Part I : Medium Answer Type Questions] UNIT I")
MCA 312: Design and Analysis of Algorithms [Part I : Medium Answer Type Questions] UNIT I 1) What is an Algorithm? What is the need to study Algorithms? 2) Define: a) Time Efficiency b) Space Efficiency
Introduction to Approximation Algorithms
Introduction to Approximation Algorithms Dr. Gautam K. Das Departmet of Mathematics Indian Institute of Technology Guwahati, India gkd@iitg.ernet.in February 19, 2016 Outline of the lecture Background
Analysis of Algorithms Prof. Karen Daniels
UMass Lowell Computer Science 91.503 Analysis of Algorithms Prof. Karen Daniels Spring, 2010 Lecture 2 Tuesday, 2/2/10 Design Patterns for Optimization Problems Greedy Algorithms Algorithmic Paradigm Context
CS 206 Introduction to Computer Science II
CS 206 Introduction to Computer Science II 03 / 25 / 2013 Instructor: Michael Eckmann Today s Topics Comments/Questions? More on Recursion Including Dynamic Programming technique Divide and Conquer techniques
We ve done. Now. Next
We ve done Fast Fourier Transform Polynomial Multiplication Now Introduction to the greedy method Activity selection problem How to prove that a greedy algorithm works Huffman coding Matroid theory Next
Artificial Intelligence Prof. Deepak Khemani Department of Computer Science and Engineering Indian Institute of Technology, Madras
Artificial Intelligence Prof. Deepak Khemani Department of Computer Science and Engineering Indian Institute of Technology, Madras (Refer Slide Time: 00:17) Lecture No - 10 Hill Climbing So, we were looking
Scan and Quicksort. 1 Scan. 1.1 Contraction CSE341T 09/20/2017. Lecture 7
CSE341T 09/20/2017 Lecture 7 Scan and Quicksort 1 Scan Scan is a very useful primitive for parallel programming. We will use it all the time in this class. First, lets start by thinking about what other
Richard E. Korf. June 27, Abstract. divide them into two subsets, so that the sum of the numbers in
A Complete Anytime Algorithm for Number Partitioning Richard E. Korf Computer Science Department University of California, Los Angeles Los Angeles, Ca. 90095 korf@cs.ucla.edu June 27, 1997 Abstract Given
What Is An Algorithm? Algorithms are the ideas behind computer programs. An algorithm is the thing which stays the same whether
What Is An Algorithm? Algorithms are the ideas behind computer programs An algorithm is the thing which stays the same whether the program is in Pascal running on a Cray innew York or is in BASIC running
(Refer Slide Time: 01.26)
Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture # 22 Why Sorting? Today we are going to be looking at sorting.