1 / 5

Lecture 9. Dynamic Programming: optimal coin change

Lecture 9. Dynamic Programming: optimal coin change .

kenyon
Télécharger la présentation

Lecture 9. Dynamic Programming: optimal coin change

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 9. Dynamic Programming: optimal coin change • We have seen this problem before: you are given an amount in cents, and you want to make change using a system of denominations, using the smallest number of coins possible. Sometimes the greedy algorithm gives the optimal solution. But sometimes (as we have seen) it does not -- an example was the system (12, 5, 1), where the greedy algorithm gives 15 = 12 + 1 + 1 + 1 but a better answer is 15 = 5 + 5 + 5. And sometimes Greedy cannot even find the proper changes: (25,10,4), change for 41 cents. • So how can we find the optimal solution (fewest coins) when the greedy algorithm may not work? One way is using dynamic programming.

  2. Optimal coin-changing -- • The idea: to make change for n cents, the optimal method must use some denomination di. That is, the optimal is made by choosing the optimal solution for n – di for some di, and adding one coin of di to it. We don't know which di to use, but some must work. So we try them all, assuming we know how to make optimal changes for < n cents. • To formalize: letting opt[j] be the optimal number of coins to make change for j cents, we have: opt[j] = 1 + min( opt[j-di]) over all di≤j

  3. Optimal coin-change: • coins(n, d[1..k]) /* returns optimal number of coins to make change for n using denominations d[1..k], with d[1] = 1 */ for j := 1 to n do opt[j] := infinity; for i := k downto 1 do if d[i] = j then opt[j] := 1; largest[j] := j; else if d[i] < j then a := 1+opt[j-d[i]]; if a < opt[j] then opt[j] := a; largest[j] := d[i]; return(opt[n]) Running time: O(nk) Input size: ?

  4. Example. j opt[j] largest[j] 1 1 1 2 2 1 3 3 1 4 4 1 5 1 5 6 2 5 7 3 5 8 4 5 9 5 5 10 2 5 11 3 5 12 4 5 13 5 5 14 6 5 j opt[j] largest[j] 15 3 5 16 4 5 17 5 5 18 1 18 19 2 18 20 3 18 21 4 18 22 5 18 23 2 18 24 3 18 25 1 25 26 2 25 27 3 25 28 3 18 29 4 18 • Suppose we use the system of denominations (1,5,18,25). To represent 29, the greedy algorithm gives 25+1+1+1+1, • Our algorithm: largest coin 18. 29-18=11, which has a representation of size 3, with largest coin 5. 11-5=6, which has a representation of size 2, with largest coin 5. 6-5=1. So 29 = 18 + 5 + 5 + 1.

  5. Paradigm #7. Exploiting the problems’ structure Example: Computing GCD Euclid’s Alg (300BC) Euclid(u,v) while (v ≠ 0) do (u, v) := (v, u mod v) return(u) Thm (Finck 1841). This algorithm runs in O(log v) steps, for u>v>0. Proof: Let r = u mod v. Case 1. v>u/2, then r =u-v < u/2 Case 2. v=u/2, then r=0 Case 3. v< u/2, then r<v<u/2 So after 2 steps, the numbers decrease by factor of 2. Hence after O(log v) steps, to 0. • We say d is a divisor of u if there exists an integer k such that u = kd. We write d | u. We say d is a common divisor of u and v if d | u and d | v. We say d is the greatest common divisor if d is a common divisor of u and v and no other common divisor is larger. • Example: gcd(12,18)=6. • Observe: d | u & d | v iff d | v and d | (u mod v)

More Related