Redigerer Dynamisk programmering

'''Dynamisk programmering''' (DP) er en teknikk for å løse en bred klasse problemer{{uklart|Hva slags problemer? Hvordan?}} effektivt. Metoden innebærer å dele opp et komplisert problem, for så å løse de overlappende delproblemene på en måte slik at hvert delproblem kun blir løst en gang. Dynamisk programmering er en av de mest brukte og viktigste generelle teknikkene for å utvikle gode algoritmer til dataprogrammer.

== Overblikk ==

Dynamisk programmering er en generell teknikk, men implementering på hvert enkelt problem kan være svært annerledes. Dynamisk programmering fungerer kun dersom den underliggende kombinatoriske strukturen er sortert på en eller annen måte. Problemet må kunne deles opp i mindre delproblemer, og disse problemene må overlappe. Dersom delproblemene ikke overlapper kalles teknikken for en ''splitt og hersk'' algoritme.

For å implementere dynamisk programmering må man:
# Identifisere en rekursjon som løser problemet
# Starte med å løse de enkleste tilfellene
# Bygge opp løsningen i en rekkefølge slik at ingen delproblemer blir løst mer enn en gang

Ofte blir utregninger lagret i en tabell, slik at de kan hentes senere. En slik tabell kan være en en-dimensjonal liste, to-dimensjonal matrise, og så videre.

== Eksempler ==
Nedenfor er et eksempel.
=== Fibonacci-tallene ===
Fibonacci-tallene er <math>0,1,1,2,3,5,8, \ldots</math>, der hvert tall er lik summen av de 2 forrige tallene. Dynamisk programmering kan brukes til å regne ut <math>F_n</math> raskere enn en naiv implementasjon. Første skritt er å finne den rekursive sammenhengen mellom Fibonacci-tallene. Den er gitt ved:
:<math>F_n = F_{n-1} + F_{n-2}</math>
Å implementere dette direkte vil føre til eksponentiell kjøretid <math>\mathcal{O}(\alpha^n)</math>, der <math>\alpha</math> er en konstant. En direkte, naiv implementasjon er ikke ideell fordi delproblemer blir løst flere ganger. Etter å ha funnet den rekursive sammenhengen er neste skritt å løse initial-problemene:
:<math>F_0 = 0</math>
:<math>F_1 = 1</math>
Dersom vi løser <math>F_{n-1}</math> før <math>F_{n}</math> for alle <math>n</math>, vil kjøretiden være <math>\mathcal{O}(n)</math>. Man starter med å løse <math>F_2</math>, deretter <math>F_3</math>, og så videre. Dette krever lineær tid i <math>n</math>, og man trenger heller ikke mye plass i minnet.

=== Binominalkoeffisientene ===
Binominalkoeffisientene er koeffisientene man får dersom man utvider uttrykket <math>\left ( a+b \right )^n</math>, og skrives som <math>\tbinom{n}{r}</math>. Eksempelvis er <math>\tbinom{3}{2} = 3</math>, fordi det andre leddet i <math>\left ( a+b \right )^3 = a^3 + 3a^2b + 3ab^2 + b^3</math> har koeffisienten <math>3</math>. Sagt på en annen måte teller <math>\tbinom{n}{r}</math> antall måter vi kan velge <math>r</math> elementer fra en samling med <math>n</math> elementer. En naiv implementasjon ville vært å bruke formelen:
:<math>\binom{n}{r} = \frac{n!}{(n-r)! r!}</math>
Problemet er at man potensielt gjør store utregninger av <math>n!</math> som er tidkrevende for en datamaskin. <math>\tbinom{n}{n} = 1</math>,
men en datamaskin må utføre <math>n</math> multiplikasjoner for å regne dette ut. Et bedre utgangspunkt er den rekursive formelen:
:<math>  \binom nk = \binom{n-1}{k-1} + \binom{n-1}k </math>
med startverdier
:<math>\binom n0 = \binom nn = 1</math>
Dette gir utgangspunktet for en implementasjon ved hjelp av dynamisk programmering. Delproblemene overlapper, med dersom vi løser de i riktige rekkefølge
vil kjøretiden være <math>\mathcal{O}(nr)</math> addisjoner.
==Referanser==
<references/>
*{{Cite book| publisher = McGraw Hill| isbn = 978-0-07-352340-8| last = Dasgupta| first = Sanjoy| title = Algorithms| url = https://archive.org/details/algorithms0000dasg| date = 2008}}
*{{Cite book| edition = 2nd ed.| publisher = Springer| isbn = 978-1-84996-720-4| last = Steve S. Skiena| title = The Algorithm Design Manual| date = 2009}}

{{Autoritetsdata}}

[[Kategori:Optimeringsalgoritmer og -metoder]]