Ming Li Talk about Bioinformatics

dasypygalstockingsΒιοτεχνολογία

2 Οκτ 2013 (πριν από 3 χρόνια και 8 μήνες)

77 εμφανίσεις

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.


Optimal coin
-
changing
--


The idea: to make change for n cents, the optimal
method must use some denomination d
i
. That is, the
optimal is made by choosing the optimal solution for
n


d
i


for some d
i
, and adding one coin of d
i

to it. We
don't know which d
i

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
-
d
i
]) over all d
i
≤j


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: ?

Example.


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.


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

Paradigm #7. Exploiting the problems’ structure

Example: Computing GCD


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)

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.