Dynamisch Programmeren III

Presentatie over: "Dynamisch Programmeren III"— Transcript van de presentatie:

1 Dynamisch Programmeren III
Algoritmiek

2 Vandaag Dynamisch programmeren met wat lastiger voorbeelden:
Handelsreiziger Longest common subsequence Optimale zoekbomen Knapsack Algoritmiek - DP2

3 Handelsreiziger Een handelsreiziger moet een aantal steden bezoeken:
Elke stad 1 keer Elk paar steden v, w heeft een afstand d(v,w) Beginstad = eindstad Wat is de kortste route? Algoritmiek - DP2

4 Optimaal: totale lengte 13 c d 4
b 5 4 2 4 3 a b c d 4 5 4 2 4 Optimaal: totale lengte 13 c d 4 Niet optimaal: Totale lengte 16 Algoritmiek - DP2

5 Toepassingen Logistiek (belangrijk!!)
Robot (printplaten, productie, …) Data van een disk halen Verfmachine Sommige toepassingen zijn asymmetrisch: d(v,w) hoeft niet hetzelfde te zijn als d(w,v) Algoritmiek - DP2

6 “Held-Karp” Held-Karp algoritme voor Handelsreiziger:
Lost het probleem in O(2n n2) tijd op Werkt ook voor sommige generalisaties Ook als probleem asymetrisch is Langzaam (exponentieel) dus alleen handig als n klein is, maar wel sneller dan naief O(n!) Vandaag: algoritme voor: “foto’s in de dierentuin” Algoritmiek - DP2

7 n! en 2nn2 n n! 2nn2 5 120 800 10 102400 15 ^12 20 2,43 10^18 4,19 10^8 Algoritmiek - DP2

8 Foto’s in de dierentuin
n dieren Afstandentabel: tussen elk paar dieren de tijd in minuten om van het ene dier naar het andere te lopen omdat de dierentuin heuvelachtig is, hoeft deze niet symmetrisch te zijn Ik wil van elk dier een foto maken: hoe doe ik dat zo snel mogelijk? Algoritmiek - DP2

9 Oplossen met dynamisch programmeren
Wat is de rij keuzes? Welk dier bezoeken we eerst? Welk dier als 2e? Welk dier als 3e Etc. Top choice: laatste bezochte dier Deelstuk van keuzes: een rijtje van de eerste i bezochte dieren? Algoritmiek - DP2

10 Wat is een deelprobleem - I
Dit lukt niet: Hoeveel tijd kost het om i dieren te bezoeken? Ik mis belangrijke informatie over de deeloplossing Snelste route voor drie dieren hoeft geen deel te zijn van een snelste route voor vier dieren… Algoritmiek - DP2

11 Wat is een deelprobleem - II
Dit lukt ook niet: Welke verzameling van i dieren bezoek ik? 1 Algoritmiek - DP2

12 Aanpak Deelprobleem: Gegeven een verzameling dieren S en een dier k, wat is de minimum tijd om alle dieren in S te bezoeken (begin bij dier 1) en te eindigen bij dier k? Handige notatie: S is alle dieren ‘tussen 1 en k’, dus we bezoeken S U {1,k } A(S,k) = minimum tijd als we beginnen in 1, dan alle dieren in S bezoeken (met de beste volgorde) en dan naar k gaan Algoritmiek - DP2

13 Recurrente betrekking
A(Æ,g) = d(1,g) Als |S|>0, dan (“beste geval over alle mogelijkheden voor top-choice) A(S,k) = min { A(S – {g}, g) + d(g,k) | g in S} Algoritmiek - DP2

14 Uiteindelijk antwoord
min { A(V-{1,k},k) | k Î V-{1} } Als we niet naar het begin terug moeten Beste over alle mogelijkheden voor laatst bezochte dier Variant waar we een rondje lopen (terug naar het begin): min { A(V-{1,k},k) + d(k,1) | k Î V-{1} } Algoritmiek - DP2

15 Algoritme 1: memorisatie
Maak een hashtabel Q, initieel leeg Best = maxint For all g Î {2, …, n} do Best = min (Best, Compute(V –{1,g},g)) Output Best Met Compute een recursief algoritme met memorisatie (next) Algoritmiek - DP2

16 Compute Compute (S, g) {volgt recurrente betrekking}
If (S,g) in Q, then return Q(S,g) Else: If S= Æ then return d(1,g) Else antw = maxint; For k Î S do antw = min {antw, Compute(S – {g}, g) + d(g,k)) Zet Q(S,g) op antw Return antw Algoritmiek - DP2

17 Andere aanpak Reken alle A(S,g) uit: Eerst alleen S = Æ
Dan alle S met een dier Dan alle S met twee dieren Dan alle S met drie dieren Etc Of representeer S als integer … Ook practisch: reken bij elke verzameling de “opvolgende oplossingen” uit (met heuristieken om stukken die nooit optimaal kunnen zijn weg te laten) Algoritmiek - DP2

18 Over dit algoritme Tijd: we kijken naar alle deelverzamelingen: 2n
Per verzameling n keuzes voor laatste dier Per combinatie n tijd, want kijken naar elk een-na-laatste dier: O(2n n2) Generalisatie: bijvoorbeeld: hoeveel dieren kan je binnen k tijd bezoeken? (Tussen openingstijd en sluitingstijd?) Algoritmiek - DP2

19 Longest common subsequence
Toepassing: DNA vergelijking Sequence: rij elementen <x(1), … , x(m)> Deelsequence: voor 1 £ i1< i2< i3<… < ik £ m de rij elementen <x(i1), x(i2), x(i3), … x(ik) > Deelsequences van <7, 2, 4, 3, 7> zijn bijv: <7,2> of <7,4,7> of <3> of <> of <7,2,4,3,7> of <2,3> Probleem: gegeven twee sequences, vind een sequence die een deelsequence van beide sequences is en zo lang mogelijk is. Bijv.: <3,6,7,1,8,2,8> en <3,4,8,6,7,3,8> geeft <3,6,7,8> als antwoord Algoritmiek

20 Wat notatie Subsequence Gemeenschappelijke (common) subsequence
Prefix (beginstuk) Xi=<x(1), … , x(i)> is een prefix van X=<x(1), … , x(m)> (0 £ i £ m) Z3=<7,2,4> is prefix van Z=<7,2,4,5,6,7,8> LCS van X en Y: longest common subsequence Algoritmiek

21 Optimaliteitsprincipe
Als Z=<z(1), … , z(k)> is een LCS van X=<x(1), … , x(m)> en Y=<y(1), … , y(n)>, dan: Als x(m)=y(n) dan: z(k)=x(m)=y(n) en Zk –1 is een LCS van Xm-1 en Yn-1 Als x(m) ¹ y(n) dan: Als z(k) ¹ x(m) dan Z is een LCS van Xm-1 en Y Als z(k) ¹ y(n) dan Z is een LCS van X en Yn-1 Algoritmiek

22 Deelproblemen Voor elke prefix van X en elke prefix van Y, kijk naar de lengte van de LCS c[i,j] = lengte van LCS van Xi en Yj. Voor elke i, 0 £ i £ m en elke j, 0 £ j £ n. Topkeuze: laatste letter van LCS Algoritmiek

23 Recurrente betrekking
Als i = 0 of j = 0, dan c[i,j] = 0. Als i>0 en j>0 en x(i) = y(j) dan c[i,j] = c[i-1,j-1] +1. Als i>0 en j>0 en x(i) ¹ y(j) dan c[i,j] = max( c[i,j-1] , c[i-1,j] ). Algoritmiek

24 Berekeningsvolgorde c[i,j] heeft nodig evt c[i-1,j], c[i,j-1], c[i-1,j-1]. Dus, bijv. For i = 0 to m Do for j = 0 to n Bereken c[i,j] Algoritmiek

25 Code om lengte LCS te berekenen
m = lengte (X) n = lengte Y Maak array c[0…m, 0…n] For i = 1 to m do c[i,0] = 0 For j = 0 to n do c[0,j] = 0 For i = 1 to m do For j = 1 to n do If x(i) == y(j) then c[i,j] = c[i-1,j-1] +1 Else c[i,j] = max( c[i,j-1] , c[i-1,j] ) Return c[m,n] Algoritmiek

26 Tijd O(mn) m = lengte (X) n = lengte Y Maak array c[0…m, 0…n]
For i = 1 to m do c[i,0] = 0 For j = 0 to n do c[0,j] = 0 For i = 1 to m do For j = 1 to n do If x(i) == y(j) then c[i,j] = c[i-1,j-1] +1 Else c[i,j] = max( c[i,j-1] , c[i-1,j] ) Return c[m,n] Algoritmiek

27 Constructieve versie: Houd bij waar je vandaankwam
m = lengte (X); n = lengte Y Maak array c[0…m, 0…n] For i = 1 to m do c[i,0] = 0 For j = 0 to n do c[0,j] = 0 For i = 1 to m do For j = 1 to n do If x(i) == y(j) then c[i,j] = c[i-1,j-1] +1; b[i,j]= LO Else if c[i-1,j] £ c[i,j-1] Then c[i,j] = c[i,j-1] ; b[i,j] = O Else c[i,j] = c[i-1,j]; b[i,j] = L Print-LCS(b,X,m,n) Print-LCS(b,X,i,j) If i==0 or j==0 then return If b[i,j] = LO then Print-LCS(b,X,i-1,j-1); print x(i) Elseif b[i,j] = O then Print-LCS(b,X,i,j-1) Else {b[i,j] = L} Print-LCS(b,X,i-1,j) Algoritmiek

28 Opmerkingen Tabel b is handig voor constructie, maar constructie kan ook zonder tabel b. Als we alleen de lengte willen weten, kunnen we met twee rijen van de tabel volstaan Algoritmiek

29 Zoekbomen Zoekboom voor het vinden van keys
Keys zijn (bijv. lexicographisch) geordend. Keys hebben verschillende frequenties Welke zoekboom kost kleinste gemiddelde aantal stappen? Diepte: aantal kanten tot wortel. (Je bekijkt dus diepte+1 knopen in boom.) Algoritmiek

30 Twee zoekbomen gezond een appel is appel is een wel wel gezond
Algoritmiek

31 Input van probleem Gegeven: Keys k(1), …, k(n), (geordend)
Frequenties p(1), …, p(n), p(i) geeft de frequentie waarmee key k(i) gezocht wordt Frequenties q(0), q(1), …, q(n) q(i) geeft de frequentie aan waarmee we een key zoeken die ligt tussen k(i-1) en k(i). q(0) voor keys kleiner dan k(1), q(n) voor keys groter dan k(n) Som van alle p(i)’s en q(i)’s is precies 1. Algoritmiek

32 Voorbeeld van zoekboom
Algoritmiek

33 Zoekboom en gemiddelde tijd
Geordende binare boom met keys als interne knopen, en knopen d(i) als bladeren (geven aan als gezochte key niet in boom zit) Verwachtte tijd van een zoekactie bij boom T: = Algoritmiek

34 Probleem Gegeven keys, en frequenties p(i) en q(i), vind een zoekboom voor de keys met minimum verwachtte tijd van een zoekactie Nagaan van alle mogelijke zoekbomen is veel te duur (er zijn W(4n/n3/2) mogelijke bomen als we n keys hebben). DP algoritme kan dit probleem in O(n3) tijd oplossen Algoritmiek

35 Subproblemen: structuur
k(b) k(r) k(l) k(?) : gebruik een optimale boom voor de keys k(b+1) … k(r-1) Bevat dummy keys d(b+1) … d(r-1) Algoritmiek

36 Deelproblemen e(i,j): minimum gemiddelde zoektijd voor een zoekboom met keys k(i) … k(j) en dummy keys d(i-1) … d(j) (en bijbehorende frequenties p(i) … p(j) en q(i-1) … q(j).) Speciaal geval: e(i,i-1): zoekboom bevat alleen dummy key d(i-1) Algoritmiek

37 Recurrente betrekking
e(i,i-1) = q(i-1) Als i £ j, dan: neem minimum over alle keuzes van key als wortel: Werk in linkerboom Werk in rechterboom Tijd voor bekijken van de wortel Algoritmiek

38 Rekenvolgorde Weer rij-gewijs, maar van elke rij alleen maar een stukje: Eerst alle e(i,i-1) uitrekenen For l = 1 to n do For i = 1 to n – l + 1 do j = i + l – 1; Bereken e(i,j) Algoritmiek

39 Preprocessing Steeds direct berekenen van termen: kan lang duren. Dus tabelleren we die. Neem matrix w[1…n,0…n]. For i=1 to n+1 do w[i,i-1] = q(i-1) For i=1 to n+1 do For j = 0 to n do w[i,j] = w[i,j-1] + p(j)+q(j) O(n2) Algoritmiek

40 DP algoritme voor optimale zoekbomen probleem
Tabelleer w. For i = 1 to n+1 do e[i,i+1] = q(i-1) For l = 1 to n do For i = 1 to n – l + 1 do j = i + l – 1; e[i,j] = maxint; For r = i to j do t = e[i,r-1]+ e[r+1,j] + w[i,j] If t < e[i,j] Then e[i,j] = t; root[i,j] = r De tabel root staat ons in staat de gezochte boom te construeren Uitrekenen van minimum uit recurrente betrekking Algoritmiek

41 Slotopmerkingen Maken van boom zelf kan met behulp van terugredeneren met tabel root Tijd van algoritme is O(n3) Er bestaat een versie van het algoritme dat O(n2) tijd gebruikt (Knuth, 1971). Algoritmiek

42 Knapsack probleem Voorwerpen met Waardes v1, … vn Gewichten w1, … , wn
Maximum gewicht W Zoek verzameling voorwerpen met totaalgewicht hooguit W en maximum waarde Algoritmiek - DP2

43 Deelproblemen en recurrente betrekking
K[i,b] = maximum waarde van deelverzameling van de eerste i voorwerpen met totaalgewicht hooguit b. K[0,b] = 0 (voor elke niet negatieve b) K[i, b] = max (K[i-1,b], K[i-1,b-W[i]] + V[i]) Algoritmiek - DP2

44 En dan… Berekeningsvolgorde: matrix bijv. rij-gewijs vullen.
Dubbele loop… Constructie-versie Algoritmiek - DP2

45 Conclusies Soms meer inzicht nodig voor ontwerp van DP algoritme.
Steeds het stappenplan volgen; bij de eerste stap kijken naar deelbeslissingen en wat voor soort deelproblemen je dan overhoudt. Algoritmiek