CS 206 Introduction to Computer Science II

Transcription

1 CS 206 Introduction to Computer Science II 03 / 25 / 2013 Instructor: Michael Eckmann

2 Today s Topics Comments/Questions? More on Recursion Including Dynamic Programming technique Divide and Conquer techniques Michael Eckmann - Skidmore College - CS Fall 2009

3 1. have at least one base case that is not recursive 2. recursive case(s) must progress towards the base case 3. trust that your recursive call does what it says it will do (without having to unravel all the recursion in your head.) 4. try not to do redundant work. That is, in different recursive calls, don't recalculate the same info.

4 Change making algorithms. Problem: have some amount of money for which you need to make change in the fewest coins possible. You have unlimited numbers of coins C 1... C N each with different values. example: make change for.63 and the coins you have are C 1 =.01, C 2 =.05, C 3 =.10, and C 4 =.25 only. ideas?

5 Change making algorithms. Problem: have some amount of money for which you need to make change in the fewest coins possible. You have unlimited numbers of coins C 1... C N each with different values. example: make change for.63 and the coins you have are C 1 =.01, C 2 =.05, C 3 =.10, and C 4 =.25 only. The algorithm that works for these denominations is a greedy algorithm (that is, one that makes an optimal choice at each step to achieve the optimal solution to the whole problem.) Let's write it in Java.

6 What if : make change for.63 and the coins you have are C 1 =.01, C 2 =.05, C 3 =.10, C 4 =.21 and C 5 =.25 only. A 21 cent piece comes into the picture.

7 What if : make change for.63 and the coins you have are C 1 =.01, C 2 =.05, C 3 =.10, C 4 =.21 and C 5 =.25 only. A 21 cent piece comes into the picture. The greedy algorithm doesn't work in this case because the minimum is 3 coins all of C 4 =.21 whereas the greedy algorithm would yield 2.25's, 1.10 and 3.01's for a total of 6 coins. We always assume we have.01 coin to guarantee a way to make change.

8 So, we want to create a way to solve the minimum # of coins problem with arbitrary coin denominations. A recursive strategy is: BASE CASE: If the change K, we're trying to make is exactly equal to a coin denomination, then we only need 1 coin, which is the least # of coins. RECURSIVE STEP: Otherwise, for all possible values of i, split the amount of change K into two sets i and K- i. Solve these two sets recursively and when done with all the i's, keep the minimum sum of the number of coins among all the i's.

9 split the total into parts and solve those parts recursively. e.g..63 = = = = = See example on page 330, figure 7.22 Each time through, save the least number of coins.

10 split the total into parts and solve those parts recursively. e.g..63 = = = = = Each time through, save the least number of coins. The base case of the recursion is when the change we are making is equal to one of the coins hence 1 coin. Otherwise recurse. Why is this bad?

11 split the total into parts and solve those parts recursively. e.g..63 = = = = = Each time through, save the least coins. The base case of the recursion is when the change we are making is equal to one of the coins hence 1 coin. Otherwise recurse. Why is this bad? Let's see (let's try to make change for some amounts with a Java implementation of this.)

12 The major problem with that change making algorithm is that it makes so many recursive calls and it duplicates work already done. Example anyone? An idea called dynamic programming is a good solution in this case. Dynamic Programming is an idea that instead of making recursive calls to figure out something that we already figured out we compute it once and save the value in a table for lookup later.

13 Dynamic Programming Could we use dynamic programming for the fibonacci numbers? Yes. We wrote the fibonacci method to take advantage of the stored values when we can.

14 Divide and Conquer The divide and conquer technique is a way of converting a problem into smaller problems that can be solved individually and then combining the answers to these subproblems in some way to solve the larger problem DIVIDE = solve smaller problems recursively, except the base case(s) CONQUER = compute the solution to the overall problem by using the solutions to the smaller problems solved in the DIVIDE part.

15 Divide and Conquer (MergeSort) There are several popular divide and conquer sort algorithms. One is called MergeSort. Later in the semester we'll talk about two others HeapSort and QuickSort. But for now, let's just discuss the MergeSort algorithm and see how it uses the divide and conquer technique. To apply the divide & conquer technique to the problem of sorting, can anyone guess what might be the base case(s) what might happen in the divide stage or what happens in the conquer stage

16 Divide and Conquer (MergeSort) Structure of Merge Sort: if list has 0 or 1 element it is sorted, done (base case) else Divide list into two lists and do MergeSort on each of these lists. Combine the two sorted lists into one sorted list. Let's look at: Let's assume we're sorting an array of ints. what will we need to keep track of? is it recursive? what will we need to pass in as parameters to MergeSort? if we write a separate method for the combine part, what will be its parameters and return values?

17 Divide and Conquer (MergeSort) Structure of Merge Sort: if list has 0 or 1 element it is sorted, done (base case) else Divide list into two lists and do MergeSort on each of these lists. Combine (merge) the two sorted lists into one sorted list. We'll need to pass in an array as a parameter to MergeSort, but since sometimes we'll only be sorting part of it, we need to pass in the range of indices to sort (or first index and length). The parameters for the merge method will be the array and information to tell it the two ranges of indices that need to be combined.

18 Divide and Conquer (MergeSort) Can anyone think of a good way to merge two sorted parts of an array?