100 points total. CSE 3353 Homework 2 Spring 2013

Transcription

1 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. You should also turn in a copy of the code to Blackboard in a.zip file. The Python file for Q1 must be named paren.py and closestpair.py for Q2, and you must not modify the names of any of the functions or their defined parameters. Any outputs from running the code should be included in files called closestpair output.txt, also included in the zip file. Both of these files must be included in a directory called LastnameFirstname. Please write your name(s) as a comment in the first line of code in the python files and output files. If you are working with a partner, turn in one set of code and one set of answers for questions Q3 Q8. You may choose to work with a partner on the code questions, the written questions, or both. PLEASE NOTE: If you worked with a partner on HW1, you may work with a partner again, but it must be a different partner than for HW1. You may submit a lateness coupon request BEFORE the assignment is due by ing tylerm@smu.edu with Subject CSE3353 Lateness Coupon. All other late work will receive a 10 percentage point deduction per day (including weekends), No late work is accepted beyond one week after the assignment is due. Q1 (10) Q2 (40) Q3 (6) Q4 (6) Q5 (6) Q6 (8) Q7 (12) Q8 (10) Q9 (2) Total (100) 1

2 Programming Q1. (10 points) A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string ((())())() contains properly nested pairs of parentheses, which the strings )()( and ()) do not. Write a Python function called that returns -1 if a string contains properly nested and balanced parentheses, and returns the position of the first offending parenthesis if the string is not properly nested and balanced. Write the function so that it operates in O(n) time, where n is the length of the string. Download starter code from tylerm/courses/cse3353/code/paren_ starter.txt. Name the file paren.py and leave the function name unchanged. 2

3 Q2. (40 points) In the closest-pair problem, you are to select the pair of points (p 1, p 2 ) from a set S that are closest to each other. In this question, you will solve the closest-pair problem for points in one and two dimensions. Download starter code from tylerm/courses/cse3353/code/ closestpair_starter.txt. Name the file closestpair.py and leave the function names unchanged. Please note: you may not consult online resources displaying Python code implementing a solution to the closest-pair problem. Doing so will be considered cheating, and dealt with accordingly. a. Your first task is to solve the closest-pair problem in one dimension using a divide-and-conquer algorithm. Consider the following set of points S = {l 1, l 2, l 3, r 1, r 2, r 3 } S l = {l 1, l 2, l 3 } S r = {r 1, r 2, r 3 } l 1 l 2 l 3 r 3 r 1 r 2 d min d min d min m A divide-and-conquer algorithm works as follows. (a) Base Case: If the list contains two points, then they must be the closest pair. (b) Divide: Divide the set into two halves (e.g., S l and S r in the figure above). Put all points less than the midpoint m in S l and all points greater than or equal to the midpoint in S r. (c) Conquer: Find the closest-pair for each half ((l 1, l 2 ) for S l and (r 1, r 2 ) for S r ). (d) Glue: To find the closest pair in the entire set, select from 3 options: i. closest pair in the left half ((l 1, l 2 )); ii. closest pair in the right half ((r 1, r 2 )); iii. a pair with one point each from S l and S r. For the closest pair to take a point from both sets, each point must be within distance d min of the midpoint m between the two sets (here d min = min(distance(l 1, l 2 ), distance(r 1, r 2 ))). Only the largest point in the left set l max and the smallest point in the right set r min could be closer than d min. Compute distance(l max,r min ) and update the closest pair if less than d min. Return the closest pair and the list of points. Implement this algorithm in the function closestpair line(). Input should be a list of numbers, and output is a list of the following form [(x 1, x 2 ), [list of points]], where (x 1, x 2 ) is the closest pair of points. You can make use of the distance() function for computing distance between points. b. Solve the closest pair problem in two dimensions using exhaustive search (i.e., compare all pairs of points and select the closest pair). Again, you can make use of the distance() function for computing distance between pairs of points. 3

4 Q2. (continued) c. Solve the closest pair problem in two dimensions using a divide-and-conquer approach. Consider the following 2-D data points: l 1 l 2 d min r 3 S l S r r 2 r 1 l 3 d mind min m The divide-and-conquer approach from one-dimension still applies, but with a few tweaks to accommodate two dimensions. Implement this algorithm in the function closestpair plane(). Input should be a list of pairs of points, and output is a two element list of the closest pair [(x 1, y 1 ), (x 2, y 2 )]. You should begin by creating two sorted lists of the points, one sorted by x-coordinates and the other sorted by y-coordinates. (You can use Python s built-in sort method for this step. Another hint: to sort the list by y-coordinates, you can use two list comprehensions to swap coordinates, sort, then swap coordinates back.) Next, invoke the divide-and-conquer portion of the algorithm inside a recursive cpphelper(seqx,seqy) function, providing the x- and y-sorted lists as arguments. The algorithm should work as follows: (a) Base Case: If the list contains two pairs of points or fewer, then they must be the closest pair. (b) Divide: Divide the sets into two halves (e.g., S l and S r in the figure above). Divide seqx (the sequence sorted by x-coordinate) in half. Divide seqy (the sequence sorted by y-coordinate) according to how the x-sorted list is split. (c) Conquer: Find the closest-pair for each half ((l 1, l 2 ) for S l and (r 1, r 2 ) for S r ). Supply the divided x- and y-sorted lists as arguments. (d) Glue: The glue procedure is a bit more complicated in two dimensions. Unlike for the one-dimensional case, we cannot assume that only one point from both sublists could be the minimum. However, we can still glue in constant time. When comparing points spanning S l and S r, we must only consider those points with x-coordinates within the current minimum distance d min. Using a geometry trick, we can be assured that a point can have no more than six neighboring points within d min distance. Here are the steps required for the glue procedure: i. Find the the closest pair for the two sublists (and d min ). ii. Select the midpoint m of the x-coordinates. iii. Construct a list of sorted y-points using a Mergesort-style merge. While doing so, also construct a second candidate list of sorted y-points whose x values are within d min distance of the midpoint m. iv. Check the 6-nearest neighbors of each element in the candidate list for a closer distance than d min, and update the closest-pair accordingly. You should make use of the provided getneighbors() function to find a point s 6 neighbors. When finished, return the closest pair and the x- and y-sorted lists. 4

5 Q2. (continued) d. Test the divide-and-conquer algorithm you wrote for part (c) by creating 100 different-sized sequences of points using the provided generatepairs() function. Verify that you find the same closest pair using the exhaustive algorithm written for part (b) as well as for the divide-and-conquer algorithm written in part (c). e. Using the testit package, compare the time it takes to execute the exhaustive and divide-and-conquer algorithms for a random sequence of 10,000 pairs. 5

6 Data Structures and Sorting Q3. (6 points) a. What is the best-case performance for search on input of size n using an unbalanced binary search tree? b. What is the average-case performance for search on input of size n using an unbalanced binary search tree? c. What is the worst-case performance for search on input of size n using an unbalanced binary search tree? 6

7 Q4. (6 points) def mysort ( seq ) : prev = seq [ 0 ] noconf = True f o r e l t in seq : i f e l t < p rev : noconf = F a l s e break i f noconf : return seq f o r i in r a n g e ( l e n ( seq ) ) : j = i while j >0 and s [ j ]< s [ j 1]: s [ j ], s [ j 1]= s [ j 1], s [ j ] j = j 1 return seq a. What is the best-case performance for mysort? Given an example input that attains the best-case performance. b. What is the worst-case performance for mysort? Give an example input that attains the worst-case performance. 7

8 Q5. (6 points) a. Suppose you are using a Quicksort algorithm that always selects the first value in the list as pivot. Give an example input sequence that takes Θ(n 2 ) time to complete. b. Suppose quicksort could always pivoted on the median of the current sublist. How many comparisons would Quicksort make then in the worst case? 8

9 Q6. (8 points) A company database consists of 10,000 sorted names, 40% of whom are known as good customers and who together account for 60% of the accesses to the database. There are two data structure options to consider for representing the database: 1. Put all the names in a single array and use binary search. 2. Put the good customers in one array and the rest of them in a second array. Only if we do not find the query name on a binary search of the first array do we do a binary search of the second array. a. Demonstrate which option gives better expected performance. b. Does your recommendation change if linear search on an unsorted array is used instead of binary search for both options? Why or why not? 9

10 Recurrence Relations Q7. (12 points) Use the master theorem to give tight asymptotic bounds for the following recurrences: a. T (n) = 2T ( n 2 ) + 7n b. T (n) = 2T ( n 2 ) + n2 c. T (n) = 3T ( n 2 ) + 2n d. T (n) = 7T ( n 3 ) + 4n2 10

11 Q8. (10 points) Consider the following recursive function. def myfun ( seq ) : i f l e n ( seq ) = = 1 : return seq [ 0 ] l e = l e n ( seq ) / 3 lo, mid, h i = seq [ : l e ], seq [ l e : 2 l e ], seq [2 l e : ] p l o = myfun ( l o ) pmid = myfun ( mid ) p h i = myfun ( h i ) t o t a l =0 f o r x in p l o +pmid+ p h i : f o r y in p l o +pmid+ p h i : t o t a l +=x y return t o t a l a. Write a recurrence relation for myfun. b. Use the master theorem to obtain a tight asymptotic bound for myfun. Q9. (2 points) How long (in hours) did you spend on this assignment? Please estimate separately how long you spent on programming (Q1 Q2) and the other questions (Q3 Q8) (full credit for any truthful answer) 11