Dynamisch Programmeren II

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

1 Dynamisch Programmeren II
Algoritmiek

2 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

3 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

4 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

5 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

6 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

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

8 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

9 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

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

11 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

12 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

13 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

21 Welke deelproblemen zijn relevant?
Algoritmiek

22 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

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

24 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

25 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

26 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

27 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

28 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

29 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

30 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

31 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

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

33 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

34 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

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

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

37 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

38 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

39 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

40 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

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

42 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

43 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

44 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

45 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

46 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

47 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

48 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

49 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

50 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

51 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

52 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

53 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

54 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

55 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

56 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

57 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

58 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

59 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

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

61 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

62 Voorbeeld van zoekboom
Algoritmiek

63 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

64 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

65 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

66 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

67 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

68 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

69 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

70 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

71 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

72 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

73 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

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

75 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