Objective: To gain experience with a simple, recursive, divide-and-conquer implementation and how to develop
faster solutions using an iterative dynamic programming implementation
To start the lab: Download and unzip the file at:
Part A: We’ve seen several recursive “divide-and-conquer” algorithms: binary search and fibonacci. The
general idea of divide-and-conquer algorithms is:
•dividing the original problem it into small problem(s) (e.g., fib(n-1) and fib(n-2))
•solving the smaller problem(s)
•combine the solution(s) to smaller problem(s) to solve the original problem (e.g., return fib(n-1) + fib(n-2) )
Mathematics has several simple recursively defined functions. For example, the factorial function can be
recursively defined as:
(1) n! = n * (n - 1)! for n ≥ 1, and
0! = 1
Implement a recursive factorial(n) function using this recursive definition and test it with several small
examples (e.g., 3! = 3*2! = 3*2*1! = 3*2*1*0! = 3*2*1*1 = 6, and 5! = 5*4*3*2*1*1 = 120).
In Discrete Structures (CS 1800) you used (or will use) the binomial coefficient formula:
(2)
C(n,k) = n!
k!(n−k)!
to calculate the number of combinations of “n choose k,” i.e., the number of ways to choose k objects from n
objects. For example, when calculating the number of unique 5-card hands from a standard 52-card deck (e.g.,
C(52, 5)) we need to calculate 52! / 5! 47! = 2,598,960.
Implement the function C(n, k) using formula (2) above and your recursive factorial function.
Completed your factorial and binomial coefficient functions, raise your hand and demonstrate your code.
Part B: One problem with using formula (2) in most languages is that n! grows very fast and overflows the
integer representation before you can do the division to bring the value back to a value that can be represented.
(NOTE: Python does not suffer from this problem, but lets pretend that it does.)
For example, when calculating C(52, 5) we need to calculate 52! / 5! 47!. However, the value of
52! = 80,658,175,170,943,878,571,660,636,856,403,766,975,289,505,440,883,277,824,000,000,000,000
is much, much bigger than can fit into a 64-bit integer representation. Fortunately, another way to view C(52, 5)
is recursively by splitting the problem into two smaller problems by focusing on:
the hands containing a specific card, say the ace of clubs, and
the hands that do not contain the ace of clubs.
For those hands that do contain the ace of clubs, we need to choose 4 more cards from the remaining 51 cards,
i.e., C(51, 4). For those hands that do not contain the ace of clubs, we need to choose 5 cards from the remaining
51 cards, i.e., C(51, 5). Therefore, C(52, 5) = C(51, 4) + C(51, 5).
In general,
(3) for , and
C(n,k) = C(n−1, k−1) + C(n−1, k)1[k[(n−1)
1 for k = 0 or k = n
C(n,k) =
Implement the recursive “divide-and-conquer” binomial coefficient function using equation (3). Call your
function DC(n,k) for “divide-and-conquer”. Notice the difference in run-time between calculating the binomial
coefficient using C(24, 12) vs. DC(24, 12), C(26, 13) vs. DC(26, 13), and C(28, 14) vs. DC(28, 14).
Completed your binomial coefficient function, DC, raise your hand and demonstrate your code.
Part C: Much of the slowness of your “divide-and-conquer” binomial coefficient function, DC(n, k), is due to
redundant calculations performed due to the recursive calls. For example, the recursive calls associated with
DC(5, 3) = 10 would be:
Data Structures (CS 1520) Lab 6 Name:_________________
Lab
6
-
1
Docsity.com
