Dynamisch Programmeren III Algoritmiek

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

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

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

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

“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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Voorbeeld van zoekboom Algoritmiek

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

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

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

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

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

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

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

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

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

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

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

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

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