CS 373 Homework 4 (due 4/1/99) Spring 1999
CS 373: Combinatorial Algorithms, Spring 1999
http://www-courses.cs.uiuc.edu/~cs373
Homework 4 (due Thu. Apr. 1, 1999 by noon)
Name:
Net ID: Alias:
Everyone must do the problems marked ◮. Problems marked are for 1-unit grad students
and others who want extra credit. (There’s no such thing as “partial extra credit”!) Unmarked
problems are extra practice problems for your benefit, which will not be graded. Think of them as
potential exam questions.
Hard problems are marked with a star; the bigger the star, the harder the problem.
Note: When a question asks you to “give/describe/present an algorithm”, you need to do four
things to receive full credit:
1. (New!) If not already done, model the problem appropriately. Often the problem is stated in
real world terms; give a more rigorous description of the problem. This will help you figure
out what is assumed (what you know and what is arbitrary, what operations are and are not
allowed), and find the tools needed to solve the problem.
2. Design the most efficient algorithm possible. Significant partial credit will be given for less
efficient algorithms, as long as they are still correct, well-presented, and correctly analyzed.
3. Describe your algorithm succinctly, using structured English/pseudocode. We don’t want full-
fledged compilable source code, but plain English exposition is usually not enough. Follow
the examples given in the textbooks, lectures, homeworks, and handouts.
4. Justify the correctness of your algorithm, including termination if that is not obvious.
5. Analyze the time and space complexity of your algorithm.
Undergrad/.75U Grad/1U Grad Problems
◮1. (5 pts total) Collinearity
Give an O(n2log n)algorithm to determine whether any three points of a set of npoints are
collinear. Assume two dimensions and exact arithmetic.
◮2. (4 pts, 2 each) Convex Hull Recurrence
Consider the following generic recurrence for convex hull algorithms that divide and conquer:
T(n, h) = T(n1, h1) + T(n2, h2) + O(n)
where n≥n1+n2, h =h1+h2and n≥h. This means that the time to compute the convex
hull is a function of both n, the number of input points, and h, the number of convex hull
vertices. The splitting and merging parts of the divide-and-conquer algorithm take O(n)time.
When nis a constant, T(n, h)is O(1), but when his a constant, T(n, h)is O(n). Prove that
for both of the following restrictions, the solution to the recurrence is O(nlog h):
1
