Föreläsning 13. Dynamisk programmering

Föreläsning 13 Dynamisk programmering

Föreläsning 13 Dynamisk programmering Fibonacci Myntväxling Floyd-Warshall Kappsäck Handelsresandeproblemet Uppgifter

Dynamisk programmering Dynamisk programmering används typiskt när man vid uppdelning av ett problem i subproblem får subproblem som överlappar. En naiv metod blir då ineffektiv eftersom den löser samma problem flera gånger. Grundtanken med dynamisk programmering är då att (genom tabellering) se till att vi löser varje subproblem endast en gång. Top-down: Rekursiv uppdelning där vi memorerar (memoize) subproblem när de är lösta och alltid kontrollerar om vi redan löst ett problem innan vi löser det. Bottom-up: Här börjar vi med de minsta subproblemen och bygger i steg upp lösningar på större och större problem. Ibland behöver man även här tabulera resultat och ibland blir det helt enkelt en iterativ lösning. En del programspråk har automatiskt stöd för memoreringen via funktionsanrop som sparar resultat av tidigare anrop.

Fibonacci static long fib(int n){//fib(40) ger 204668309 anrop if(n==1 n==2) return 1; return fib(n-1)+fib(n-2); } Dynamiskt top-down: static long[] tab = new long[100000]; for(int i=0;i<tab.length;i++) tab[i]=0; tab[1]=tab[2]=1; static long fibdyn(int n){ if(tab[n]!=0) return tab[n]; return tab[n]=fibdyn(n-1)+fibdyn(n-2); } fibdyn(40) ger 77 anrop! Dynamiskt bottom-up: static long fibiterativ(int nfinal) { long fn=0,fnminus1=1,fnminus2=1; for(int n=3;n<=nfinal;n++){ fn=fnminus1+fnminus2; fnminus2=fnminus1; fnminus1=fn; } return fn; }

Myntväxling Input: belopp kr i växel mynt[n] array med de n olika valörerna växel(belopp) För i = 0 till n-1 Om mynt[i]=belopp return 1 v=belopp För i = 1 till belopp/2 v=min(v,växel(i)+växel(belopp-i)) return v Hur gör vi dynamiskt?

Myntväxling - dynamiskt växel(belopp) Om tab[belopp] 0 return tab[belopp] För i = 0 till n-1 Om mynt[i]=belopp tab[belopp] = 1 return tab[belopp] v=belopp För i = 1 till belopp/2 v=min(v,växel(i)+växel(belopp-i)) Sätt tab[belopp] = v return tab[belopp]

Floyd-Warshall Löser kortaste vägen i en viktad graf. Hittar kortaste vägen mellan varje par av noder i O( V 3 ) vilket är ganska snabbt med tanke på att det kan finnas O( V 2 ) bågar. Använder dynamisk programmering, bottom up, för att åstadkomma detta.

Princip Input: V mängden av noder numrerade 1,, N w(i,j) vikt för båge från nod i till nod j kortastevägen(i,j,k) kortaste vägen från nod i till nod j endast användande noderna 1,, k som mellannoder. kortastevägen(i,j,k+1) = min(kortastevägen(i,j,k), kortastevägen(i,k+1,k)+ kortastevägen(k+1,j,k)) där kortastevägen(i,j,0) = w(i,j) Här kund man nu ha löst detta top-dowm och tabellerat svar. Bottom-up blir dock mycket effektivare:

Algoritm Input: V mängden av noder numrerade 1,, N w(i,j) vikt för båge från nod i till nod j Output: a(i,j) 2D-array för avståndet från i till j (kortaste) Sätt a(i,j) = för alla i,j Sätt a(i,i) = 0 för alla i För alla bågar sätt a(i,j) = w(i,j) För k = 1 till N För i = 1 till N För j = 1 till N a(i,j)=min(a(i,j),a(i,k)+a(k,j)) Observera att vi endast får avståndet ej vägen!

Kappsäck Det finns n olika sorters varor vars värde är v i och vikt är w i. Av varje sorts vara finns det obegränsat antal. Hur ska vi packa en kappsäck som maximalt tar vikten W så att vi får med oss det maximala värdet? Låt m(w) vara det maximala värdet vi kan få i i en kappsäck av storlek w. Då gäller: m(w) = max(v 1 +m(w-w 1 ), v 2 +m(w-w 2 ),, v n +m(w-w n )) där endast de fall då w-w i 0 är med. Vi har också att: m(0) = 0. Precis som i förra exemplet bygger vi enklast upp detta genom bottomup där vi bestämmer maximala värdet för en kappsäck med plats för 1, 2,, W.

Handelsresandeproblemet Givet n städer (1, n) och avståndet mellan varje par av städer, w(i,j). Vilken väg ska en handelsresande välja för att minimera resvägen och besöka alla städer exakt en gång och börja och sluta i samma stad? Kan vi inte bara prova alla kombinationer? O(n!)

Algoritm dynamisk, bottom-up Låt oss bestämma oss för att börja och sluta i stad 1. V - mängden av alla städer utom stad 1. S V och S Låt j S. Då är a(s,j) kortaste vägen som börjar i 1 passerar alla städer i S exakt en gång och slutar i j För alla j a({j},j) = w(1,j) För s = 2 till n-1 //s är storleken på S För alla subset S av storlek s För alla j S a(s,j)=min i S-{j} [a(s-{j},i)+w(i,j)] return min j V [c(v,j)+w(j,1)] blir O(n 2 2 n )

Exempel 1 2 3 4 6 5 5 6 3 4 6 2 3 4 5 w(i,j) 1 2 3 4 5 1 3 6 5 6 2 3 4 5 6 3 6 4 3 4 4 5 5 3 2 5 6 6 4 2

w(i,j) 1 2 3 4 5 1 3 6 5 6 2 3 4 5 6 3 6 4 3 4 4 5 5 3 2 För alla j a({j},j) = w(1,j) 5 6 6 4 2 a({j},j) j=2 j=3 j=4 j=5 3 6 5 6

j=2 j=3 j=4 j=5 a({j},j) 3 6 5 6 a({2,3},j) a({2,4},j) a({2,5},j) w(i,j) 1 2 3 4 5 1 3 6 5 6 2 3 4 5 6 3 6 4 3 4 4 5 5 3 2 5 6 6 4 2 För s = 2 till n-1 //s är storleken på S För alla subset S av storlek s För alla j S a(s,j)=min i S-{j} [a(s-{j},i)+w(i,j)] j=2 j=3 j=4 j=5 min[a({3},3)+ w(3,2)] = 10 min[a({4},4)+ w(4,2)]=10 min[a({5},5)+ w(5,2)]=12 min[a({2},2)+ w(2,3)]=7 a({3,4},j) - min[a({4},4)+ w(4,3)]=8 - - - min[a({2},2)+ w(2,4)]=8 - - min[a({2},2)+ w(2,5)]=9 min[a({3},3)+ w(3,4)]=9 -

För s = 2 till n-1 //s är storleken på S För alla subset S av storlek s För alla j S a(s,j)=min i S-{j} [a(s-{j},i)+w(i,j)] j=2 j=3 j=4 j=5 a({2,3,4},j) min[a({3,4},3)+w(3,2),a({3,4},4)+w(4,2)] - a({2,3,5},j) min[a({3,5},3)+w(3,2),a({3,5},5)+w(5,2)] -

Uppgifter NB54 Skriv en funktion som beräknar högsta summan man kan få genom att lägga ihop talen längs valfri väg från toppen av en taltriangel till botten. a) Lös problemet med enkel rekursion b) Förbättra effektiviteten genom att tabulera värden du räknat ut (dynamisk programmering top-down). Jämför antalet anrop med a) för en 30-tal hög triangel. c) Skriv en funktion som bygger upp lösningen nerifrån och upp (dynamisk programmering bottom up)

NB55 Skriv en funktion som löser det generella myntväxlingsproblemet med hjälp av dynamisk programmering a) top-down b) bottom-up

NB56 Floyd-Warshall Implementera Floyd-Warshall.

NB57 Implementera ett program som löser kappsäcksproblemet enligt föreläsningen. Skriv också ett enkelt gränssnitt.

NB58 Hur många unika vägar finns det från övre högra hörnet till nedre vänstra hörnet om vi bara får gå väst och syd? Förbättra vår lösning med hjälp av dynamisk programmering. Hur många funktionsanrop blir det för (12,6)? Jämför med vår gamla algoritm utan tabulering.

NB59 I en följd av heltal ska vi försöka hitta den längden hos den längsta sekvensen stigande tal. Alla stigande sekvenser i talföljden 5, 2, 8, 6, 3, 6, 9, 7 är markerade ovan. Den längsta blir då 4 lång och är 2, 3, 6, 9 eller 2, 3, 6, 7. a) Skriv en funktion som löser problemet ovan. Tänk fritt. b) Börja längst till vänster. Varje nytt tal ger två alternativ: Talet är större än föregående tal i vår sekvens: 1. Ta med talet 2. Hoppa över talet Talet är inte större än föregående tal i vår sekvens: 1. Påbörja ny sekvens 2. Hoppa över talet Skriv en rekursiv lösning som använder detta. c) Effektivisera den rekursiva lösningen med tabulering av beräknade delresultat. Försök också gärna att göra en bottom-up lösning.

NB60 Implementera en dynamisk algoritm som löser handelsresandeproblemet