Dynamisch Programmeren II Algoritmiek

Dynamic Programming Uitgevonden door Bellman, plm 1950 Waarom deze term? Programming: maken van een plan (vgl. programma van bijv. een concert) Dynamic: “variabel met de tijd’’, en “klinkt indrukwekkend” Algoritmiek - DP2

Dynamisch programmeren vervolg Vinden van oplossingen Versie met Memorisatie Besparen van geheugen Ingewikkelder problemen Chained Matrix Multiplication Knapsack Zoekbomen met minimum gemiddelde zoektijd Het maken van een DP algoritme vereist: methodisch werken: volg de ontwerpmethode; inzicht in de structuur van het op te lossen probleem, en wat geduld en creativiteit. Algoritmiek - DP2

Het stappenplan Identificeer `deelproblemen’: gebruik rij van beslissingen en `top choice’ Ontwerp een recurrente betrekking voor het probleem. Wat is de berekeningsvolgorde? Bereken in volgorde de waardes voor de deelproblemen. Constructieve versie of Geheugenbesparing Probeer steeds het stappenplan te volgen wanneer je een dynamisch programmeer algoritme ontwerpt. Algoritmiek - DP2

Versies van problemen Beslissingsprobleem Vb: kan b betaald worden met hooguit i munten van waardes a1,…,an? (Antwoord is: JA of NEE.) Optimalisatieprobleem Wat is het kleinste aantal munten waarmee b betaald kan worden met munten van waardes a1,…,an? (Antwoord is een getal.) Constructieprobleem Op welke manier kan b betaald worden met zo min mogelijk munten van waardes a1,…,an? (Antwoord is een serie van waardes van munten.) Algoritmiek - DP2

Ons algoritme voor Optimalisatieversie van Wisselprobleem Function WisselDP(A[1…x], y) Maak 2-dim array W[0…x, 0…y]. W[0,0]=0. For j=1 to y do W[0,j] = +¥. For i=1 to x do For j=0 to y do If (A[i] > y) then W[i,j] = W[i – 1,j] Else W[i,j] = min (W[i – 1,j],W[i,j – A[i]]+1) Return W[x,y] Uit het vorige college. Algoritmiek - DP2

Munten van 2, 3, 6, 10; Betaal 7 cent. ¥ 1 2 3 4 5 6 Lege tabel 7 Algoritmiek - DP2

Munten van 2, 3, 6, 10; Betaal 7 cent. ¥ ¥ 1 2 3 1 2 3 4 5 6 Tabel met waardes ingevuld door algoritme 7 Algoritmiek - DP2

Constructieversies Doe eerst DP algoritme voor beslisprobleem of optimalisatieprobleem Eventueel met bijhouden van extra gegevens Construeer antwoord achterstevoren door gebruik te maken van de opgeslagen en door het DP algoritme berekende informatie Algoritmiek - DP2

3 6 2 10 ¥ ¥ 1 2 3 1 2 3 4 5 6 Teruglopen door de tabel 7 Algoritmiek - DP2

Munten: 2, 3, 6, 10 2 3 6 10 2 3 6 10 ¥ ¥ 1 2 3 - L O 1 2 3 4 5 6 7 L: Links; O: Omhoog Algoritmiek - DP2

Procedure WisselDPConstructive2(A[1…x], y) Maak 2-dim array W[0…x, 0…y]. W[0,0]=0. For j=1 to y do W[0,j] = +¥. For i=1 to x do For j=0 to y do If (A[i] > y) then { W[i,j] = W[i–1,j]; Z[i,j] = “L”; } Else If (i>0 and W[i – 1,j] < W[i,j – A[i]]+1) Then { W[i,j] = W[i – 1,j]; Z[i,j] = “L”; } Else { W[i,j] = W[i,j – A[i]]+1; Z[i,j] = “O”; } If (W[x,y] == +¥) then Foutmelding: onmogelijk j = y; i = x; While (j ¹ 0) Do if (A[i,j] == “O”) then { j = j – A[i]; Betaal munt A[i] terug } else i = i – 1; We kunnen gebruik maken van de opgeslagen waardes L en O om het probleem constructief op te lossen. We lopen als het ware terug door de tabel; de L en O’s vertellen of we een stapje naar links of een aantal stappen (A[i]) omhoog moeten doen. Algoritmiek - DP2

Procedure WisselDPConstructive(A[1…x], y) Maak 2-dim array W[0…x, 0…y]. W[0,0]=0. For j=1 to y do W[0,j] = +¥. For i=1 to x do For j=0 to y do If (A[i] > y) then W[i,j] = W[i – 1,j] Else W[i,j] = min (W[i – 1,j],W[i,j – A[i]]+1) If (W[x,y] == +¥) then Foutmelding: onmogelijk j = y; i = x; While (j ¹ 0) Do if (A[i] £ j and W[i,j] == W[i,j – A[j]]+1) then { j = j – A[i]; Betaal munt A[i] terug } else i = i – 1; Het is op zich ook mogelijk om zonder de tabel met L’s en O’s het probleem op te lossen. We `reconstrueren’ welke Algoritmiek - DP2

Techniek werkt vaak Voor constructieprobleem Bijhouden van extra informatie die vertelt waar je vandaan komt, of dit later zien aan de opgeslagen informatie Terugredeneren van antwoord Algoritmiek - DP2

Eerlijke Boedelverdeling Twee broers moeten een stel voorwerpen verdelen van waarde a1, a2, …, an. Hoe doen ze dat zo eerlijk mogelijk? (D.w.z., verdeel a1, a2, …, an in twee verzamelingen waarvan de som zo weinig mogelijk verschilt.) 1, 5, 8, 10, 11 {8, 10} en {1, 5, 11} is eerlijkste verdeling (verschil 1.) Ook wel eens: twee rovers willen een buit verdelen. Algoritmiek

Stappenplan voor DP Stap 1: wat is de rij van keuzes? Voor de hand liggend: Welke broer krijgt voorwerp 1? Welke broer krijgt voorwerp 2? … Welke broer krijgt voorwerp n? Stap 2: Top choice: welke broer krijgt voorwerp n? Algoritmiek

Stappenplan voor DP Stap 3: Identificeer deelproblemen Vaak werkt volgende strategie: Deelprobleem is: Beginstuk van gebeurtenissen of beslissingen + Situatie na een stel gebeurtenissen en beslissingen Algoritmiek

Boedelprobleem Stap 1 1e poging Beslissingen: welke broer krijgt voorwerp 1; welke broer krijgt voorwerp 2; etc. Idee voor deelproblemen: Wat is de eerlijkste verdeling van de eerste i voorwerpen? Hiermee is geen DP algoritme te maken: optimaliteitsprincipe geldt niet. Voorwerpen 1, 5, 6: eerlijkste verdeling 1e twee voorwerpen zegt niets over eerlijkste verdeling alle drie voorwerpen mislukt Algoritmiek

Waarom werkt dit niet? Er zijn mogelijke begin-keuzes die tot een optimale oplossing leiden die niet in een deelprobleem `gevangen worden’ Voorwerpen 1, 5, 6, 10 Begin: (1 en 5, 6) is geen deel van de optimale oplossing (1 en 10, 5 en 6) Algoritmiek

Boedelprobleem Stap 1 Verdeel(i, c): is er een verdeling van de eerste i voorwerpen met verschil in waarde precies c? 1,5,8,10,11: Verdeel(2,4) = true Verdeel(2,5) = false Verdeel(2,6) = true (1,5 vs niets) Verdeel(3,2) = true (1,5 vs 8) Algoritmiek

Welke deelproblemen zijn relevant? Algoritmiek

Stap 3 Ontwerp recurrente betrekking die oplossing van deelprobleem uitdrukt in oplossingen van andere deelproblemen. Verdeel(0,0) = true Voor c ¹ 0: Verdeel(0,c) = false Voor i>0: Verdeel(i,c) = Verdeel(i-1,c-ai) or Verdeel(i-1,c+ai) ide voorwerp naar 1e of 2e broer: gevalsonderscheid op de top-choice Algoritmiek

Stap 4 i: voorwerpen Wat is de berekeningsvolgorde? Hier: kolomsgewijs, d.w.z, stijgend aantal voorwerpen c: verschil Algoritmiek

Stap 5 Bereken de deelproblemen met behulp van de recurrente betrekking in de gevonden volgorde. Bereken T = Maak array V[0…n, –T…T] for i = 0 to n do for c = -T to T do if i=0 and c=0, then V[i,c]= true else if i=0 and c ¹ 0 then V[i,c]=false else V[i,c] = V[i-1,c-ai] or V[i-1,c+ai] Nu nog het antwoord vinden… Dit is nog niet goed: we zoeken buiten de array. Juiste code neemt een “false” voor elementen uit de array-bounds Algoritmiek

Vervolg stap 5: Antwoord vinden: poging 1 for c = 0 to T do if V[n,c] == true then return c Dit vindt het kleinst mogelijke verschil in de waarde van de verdeling tussen de broers. Maar… nog niet de eerlijkste verdeling zelf? Hoe dat te doen is Stap 6. Algoritmiek

Boedelverdeling: vinden van oplossing Probleem: gegeven getallen a1,…,an: verdeel ze in twee verzamelingen met verschil van som zo klein mogelijk. We zagen een algoritme dat het kleinste verschil uitrekent Bereken T = som van alle ai’s Maak array V[0…n, –T…T] For i = 0 to n do For c = -T to T do If i=0 and c=0, then V[i,c]= true Else if i=0 and c ¹ 0 then V[i,c]=false Else V[i,c] = V[i-1,c-ai] or V[i-1,c+ai] For c = 0 to T do If V[n,c] == true then return c Algoritmiek - DP2

Vinden van antwoord Terugredeneren! Begin bij V[n,c] als het antwoord c is Je kan zien aan de waarden in de array welke broer voorwerp n krijgt En dan ga je een stapje terug … Algoritmiek - DP2

Vinden van antwoord Bereken T = som van alle ais Maak array V[0…n, –T…T] For i = 0 to n do For c = – T to T do If i=0 and c=0, then V[i,c]= true Else if i=0 and c ¹ 0 then V[i,c]=false Else V[i,c] = V[i – 1,c – ai] or V[i – 1,c+ai] c=0; While V[n,c] == false do c++; For i = n downto 1 do If V[i – 1, c – ai] == true Then Put item i in first set; c = c – ai; Else (V[i – 1, c + ai]== true) Put item i in second set; c = c + ai; Return first and second set. Algoritmiek - DP2

Besparen van geheugen Analyseer welke informatie het algoritme wanneer raadpleegt. Informatie die niet meer gebruikt wordt kan overschreven worden. Nu behandelen we een andere techniek. Deze kan vaak ook niet samen met de constructietechniek gebruikt worden. Algoritmiek - DP2

Bij muntwisselprobleem: i: munten Bij muntwisselprobleem: Alleen informatie hoger in zelfde kolom of in vorige kolom wordt geraadpleegd Een-na-vorige kolom kan dus hergebruikt worden! j: bedrag Algoritmiek - DP2

Nieuwe versie met O(y) geheugen Function WisselDP(A[1…x], y) Maak 2 arrays W[0…y], Z[0…y]. W[0]=0. For j=1 to y do W[j] = +¥. For i=1 to x do For j=0 to y do If (A[i] > y) then Z[j] = W[j] Else Z[j] = min (W[j],Z[j – A[i]]+1) For j=0 to y do W[j]=Z[j] Return W[y] Nieuwe versie van beslissingsalgoritme dat minder geheugen gebruikt Algoritmiek - DP2

Geheugen hergebruikt werkt heel vaak In het algemeen niet met constructie van oplossingen. Soms nuttig bij grote probleeminstanties. Algoritmiek - DP2

Memorisatie / Geheugenfuncties In plaats van zelf berekeningsvolgorde te bepalen. Datastructuur (Geheugenfunctie) Verzameling van al uitgerekende waardes Plan: Als we een recursieve aanroep doen A(x): Kijk of x in de datastructuur. Zo ja: lever op wat de datastructuur voor x verteld. Zo nee: bereken A(x) en sla x met bijbehorend antwoord op in de datastructuur Nog een techniek: memorisatie. Wordt in sommige compilers gebruikt. Algoritmiek - DP2

Wissel met Memorisatie Function WM2(W,A, x, y) Kijk of (x,y) in W. Zo ja, return de integer waarde bij key (x,y) uit W. Zo nee: If (x==0 and y==0) then antw = 0; Else If (x==0 and y>0) then antw = +¥. Else If (A[x] > y) Then antw = WM2(W,A,x – 1,y) Else antw = min (WM2(W,A,x – 1,y), WM2(W,A,x ,y – A[x]])+1) Zet (x,y) met waarde antw in W Return antw Function WisselMemorisatie1(A[1…x], y) Maak Dictionary W met paren (i,j) als keys, met bij paren een integer opgeslagen. Return WM2 (W,A, x,y) Het algoritme voor het geldwisselprobleem, nu met memorisatie. Algoritmiek - DP2

Betaal 7 met munten van 1, 2, en 5 1 2 3 4 5 6 7 Algoritmiek - DP2

Voor- en nadelen geheugenfuncties Sommige onnodige informatie wordt niet berekend. Iets meer overhead soms door implementatie geheugenfunctie. Algoritmiek - DP2

Nu Lasterig problemen met DP: Matrix-chain multiplicatie Optimale zoekbomen Volgende week: Meer DP o.a. Handelsreiziger (nuttig voor opgave 6; “DP-en met verzamelingen”) Algoritmiek - DP2

Matrix-chain multiplication Haakjes zetten bij vermenigvuldigen van rij matrices. Vermenigvuldigen van matrices A en B: if aantalkolommen(A) ¹ aantalrijen(B) then error (kan niet) Else for i = 1 to aantalrijen(A) do for j = 1 to aantalkolommen(B) do C(i,j) = 0; for k = 1 to aantalkolommen(A) do C(i,j) += A(i,j) * B(i,j) Return C Vermenigvuldigen van p by q en q bij r matrix kost p*q*r vermenigvuldigingen. Algoritmiek - DP2

Chained matrix multiplicatie We hebben nu matrices A1 , …, Ar van formaat d0 bij d1, d1 bij d2, … dr-1 bij dr. Wat is de beste volgorde om het product A1 . A2 . A3 … . Ar uit te rekenen? Nog een paar voorbeelden van dynamisch programmeren. Algoritmiek - DP2

Vb Matrices van formaat 3 bij 5, 5 bij 2, 2 bij 10. (A1 A2) A3 kost 3*5*2 + 3*2*10 = 90 vermenigvuldigingen, want A1 A2 is een 3 bij 2 matrix A1 (A2 A3) kost 5*2*10 + 3*5*10 = 250 vermenigvuldigingen, want A2 A3 is 5 bij 10 matrix. Als we een lange rij matrices moeten vermenigvuldigen zijn er veel manieren om haakjes te zetten! ABCDE kan: (AB)((CD)E) of A(B(C(DE))) Algoritmiek - DP2

Rij beslissingen en top choice Beslissingen: waar zet je de haakjes Laatste beslissing is “laatste vermenigvuldiging”: Kan middenin zitten! Boomstructuur … Algoritmiek - DP2

Deelproblemen voor Chained Matrix Multiplication (1) Alleen naar deelproblemen kijken die iets zeggen over vermenigvuldigen van de eerste i matrices is niet voldoende: Als (AB)(CD) optimaal is, heb je niet genoeg aan de informatie over hoe ABC te vermenigvuldigen Wat is de `laatste’ vermenigvuldiging (‘top choice’) (A1 .…. As) . (As+1 .…. Ar) En dan de stukken A1 .…. As en As+1 .…. Ar optimaal. Die stukken splitsen weer, bijv A1 .…. As kan als A1 .…. At en At+1 .…. As: ook die moeten dan weer optimaal. Verder splitsen leidt alleen tot `stukken’ van achtereenvolgende matrices uit de reeks. Algoritmiek - DP2

Deelproblemen CMM (2) Voor i, j tussen 1 en r, i £ j: OPT(i,j) = minimum aantal vermenigvuldingen nodig voor Ai .…. Aj. Dus OPT(3,6) geeft minimum aantal vermenigvuldigingen voor A3.A4.A5.A6. Algoritmiek - DP2

Recurrente betrekkingen OPT(i,i) = 0 OPT(i,i+1) = di-1 di di+1 (matrices van formaat di-1 bij di en di bij di+1 ). j>i+1: OPT(i,i+s) = min { OPT(i,k) + OPT(k+1,i+s) + di-1dkdi+s | i £ k < i+s } (Ai . …. Ak ) (Ak+1 . …. Ai+s ) Algoritmiek - DP2

Berekeningsvolgorde Als we een stuk i … i+s uitrekenen gebruiken we alleen informatie over kortere stukken, d.w.z., stukken van de vorm j … j+t met t < s. Suggereert volgorde: For s = 0 to r do For i = 1 to r do Bereken OPT(i,i+s) i+s a e h j b f i c g d i Algoritmiek - DP2

Algoritme Function CMC(D[0…r]) Maak matrix C[1…r,1…r] (geeft OPT weer) For i = 1 to r do C[i,i] = 0; C[i,i+1] = D[i-1]*D[i]*D[i+1]. For s = 2 to r do C[i,i+s] = maxint; For k= i to i + s – 1 do C[i,i+s] = min (C[i,i+s] , C[i,k] + C[k+1,i+s] + D[i-1]*D[k]*D[i+s] ). C[1,r] geeft het aantal nodige vermenigvuldingen Algoritmiek - DP2

Constructief Sla op welke k het minimum gaf For k= i to i + s – 1 do C[i,i+s] = min (C[i,i+s] , C[i,k] + C[k+1,i+s] + D[i-1]*D[k]*D[i+s] ). Wordt z = C[i,k] + C[k+1,i+s] + D[i-1]*D[k]*D[i+s] ; If (z < C[i,i+s]), then C[i,i+s] = z; Q[i,i+s] = k Algoritmiek - DP2

Oplossing construeren Recursief Haakjes(Q,i,j) If (i==j) then return “Ai” If (i+1 == j) then return “(“+Ai +“*” + Ai+1 +)” k = Q[i,j] Return “(”+ Haakjes(Q,i,k) + “*” + Haakjes(Q,k+1,j) + “)” 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(n) dan Z is een LCS van Xm-1 en Y Als z(k) ¹ y(m) 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. 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-1,j) Else (b[i,j] = L) Print-LCS(b,X,i,j-1) 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-1,i): 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. Volgende keer: DP voor Handelsreizigersprobleem Algoritmiek