Algdat Eksamensforelesning. Nils Barlaug

Algdat Eksamensforelesning Nils Barlaug

Eksamen Pensum

Eksamen Pensum Oppgaver du har gjort og ting du har lest

Eksamen Pensum Oppgave på eksamen Oppgaver du har gjort og ting du har lest

Eksamen Pensum Vanskelighetsgrad Oppgave på eksamen Oppgaver du har gjort og ting du har lest

Diskmat-eksamen 2010 Pensum

Diskmat-eksamen - sum over tid Pensum

Exphil-eksamen Pensum

Exphil-eksamen Pensum Blom ster heft e

Matte 1-4 Pensum

Matte 1-4 (slik det oppleves for mange) Pensum

AlgDat-eksamen 2010 Pensum

AlgDat-eksamen - sum over tid Pensum

Hvordan forberede seg?

Traversering G = (V, E)

Dybde først søk

Bredde først søk

H2012, oppgave 1d

H2011, oppgave 1f

Hashing 3: 1432: 8393: 9638: Nils Magnus Odd Gustav

H2014, oppgave 2d

H2012, oppgave 1b

Topologisk sortering

H2011, oppgave 1a

Annet eksempel på topologisk sortering

Enda et eksempel

DAG - Directed Acyclic Graph ( rettet asyklisk graf) Ikke dag DAG DAG

Topologisk sortering Abstraksjon En topologisk sortering av en DAG G er en lineær ordning av nodene i G slik at hvis G inneholder en kant (u, v) kommer u før v i ordningen. (Cormen) Hvordan kan vi løse dette generelt?

Topologisk sortering - algoritmen (i boka) Kjør DFS på alle noder. Når en node er ferdigprosessert legges den først i den topologiske ordningen. La oss prøve algoritmen på denne snedige grafen

V2012, oppgave 1a

Minimale spenntrær

Annet eksempel

Minimale spenntrær Abstraksjon Spenntre Et utvalg kanter i en (urettet og sammenhengende) graf som danner et tre på en slik måte at alle noder er med i treet. Minimale spenntrær Spenntrær som minimerer summen av kantvekter i treet Hvordan kan vi finne et slikt minimalt spenntre?

Vi gjør det grådig Lokalt optimaliserte valg gir oss en globalt optimal løsning Legge til en og en trygg kant

Teorem 23.1 Snitt

Teorem 23.1 (lett kant trygg kant) Trygg / lett kant (u, v) ---- Kanter vi vet tilhører et minimalt spenntre (A) Et snitt som respekterer A Vanlig kant Lett kant: minimal kant som krysser snittet ----

Kruskal Sorter alle kanter etter stigende kantvekt Legg til kanter så lenge de ikke lager en sykel Hvorfor vil dette fungere (i henhold til teorem 23.1)? Kjøretid Implementasjonsavhengig O(E lg V) hvis man bruker disjoint-set forest

Prim Start med en tilfeldig node som startnode til treet T Legg hele tiden til billigste kant som utvider treet T med en ny node Hvorfor vil dette fungere (i henhold til teorem 23.1)? Kjøretid Kommer an på hvordan vi lager prioritetskøen Binary heap: O(E lg V) Fibonacci heap: O(E + V lg V) (ikke pensum)

H2011, oppgave 1b

H2014, oppgave 1d

H10, oppgave 5a

Kjøretid

2 2 x sortering 1 1

Θ О Ω

H2012, 1a

Worst/best case vs. O/Ω

H2012, oppgave 2c

Hvordan finne kjøretid?

Kahoot!

Rekurrenser

Hvordan løse? Iterasjon Rekursjonstre Variabelskifte Substitusjonsmetoden Masterteoremet

Iterasjon T(n) = 2T(n-1) + 2n Fo rov er? r? Ba k e ov

H2012, oppgave 1L) - Rekursjonstre

T(n) = 3T(n/4) + cn2

H2012, oppgave 1L) - variabelskifte

H2012, oppgave 1L) - substitusjonsmetoden

H2012, oppgave 1L) - masterteoremet

H2010, oppgave 4

MAX-HEAPIFY

BUILD-HEAP

HEAPSORT

INCREASE-KEY

H2010, oppgave 2a

Sortering

Hvilke egenskaper kan en sorteringsalgoritme ha? Sammenligning / ikke sammenligning Best / Average / Worst case kjøretid Minneforbruk - in-place? Stabil Parallelliserbar Konstanter?

Sorteringsalgoritmer Sammenligning Uten sammenligning Treigt aka O(n2) O(n) Bubble Insertion Selection Optimalt aka O(n lg n) Heapsort Merge sort Quicksort Counting sort Radix sort Bucket sort

Bubble sort Sammenligning Ja Best Θ(n) Average Θ(n2) Worst Θ(n2) Minne Θ(1) In-place Ja Stabil Ja Parallelliserbar Nei

Insertion sort Sammenligning Ja Best Θ(n) Average Θ(n2) Worst Θ(n2) Minne Θ(1) In-place Ja Stabil Ja Parallelliserbar Nei

Selection sort Sammenligning Ja Best Θ(n2) Average Θ(n2) Worst Θ(n2) Minne Θ(1) In-place Ja Stabil Nei Parallelliserbar Nei

Heapsort Sammenligning Ja Best O(n lg n) Average O(n lg n) Worst O(n lg n) Minne Θ(1) In-place Ja Stabil Nei Parallelliserbar Nei

Quicksort Sammenligning Ja Best Θ(n lg n) Average Θ(n lg n) Worst Θ(n2) Minne Θ(lg n) In-place Ja Stabil Nei Parallelliserbar Ja Kan finne et bestemt tall i rekkefølgen med PARTITION i lineær tid!

Merge sort Sammenligning Ja Best Θ(n lg n) Average Θ(n lg n) Worst Θ(n lg n) Minne Θ(n) In-place Nei Stabil Ja Parallelliserbar Ja

Counting sort Sammenligning Nei Best Θ(n + k) Average Θ(n + k) Worst Θ(n + k) Minne Θ(n + k) In-place Nei Stabil Ja Parallelliserbar Nei

Radix sort Sammenligning Nei Best Θ(d(n + k)) Average Θ(d(n + k)) Worst Θ(d(n + k)) Minne Θ(n + k) In-place Nei Stabil Ja Parallelliserbar Nei

Bucket sort Sammenligning Nei Best Θ(n) Average Θ(n) Worst Θ(n2) Minne Θ(n) In-place Nei Stabil Ja Parallelliserbar Nei

Hvor fort kan vi gå?

H2011, oppgave 2c

H2010, oppgave 1g

H2014, oppgave 3a

H2014, oppgave 3b

Korteste vei - en til alle

Eksempel på bruk

Negative kanter

Gøy med negative kanter Profitt =

Negative sykler er ikke alltid et problem

Positive sykler

Abstraksjon Vi har en rettet vektet graf G = (V, E) og skal finne korteste vei fra s til t. En korteste vei til node t er en sti fra t til s som minimerer summen av kantvektene langs stien.

Optimal substruktur!

Relaxation INITIALIZE-SINGLE-SOURCE (G, s) for each vertex v G.V v.d = v.π = NIL s.d = 0 RELAX (u, v, w) if v.d > u.d + w(u,v) v.d = u.d + w(u,v) v.π = u u.d = 3 u w(u,v) = 2 v.d = 8 5 v

H2014, oppgave 2b

DAG Shortest Path Topologisk sorter grafen For hver node u i den topologiske ordningen: For hver nabo v av u: Relax(u, v) La oss finne korteste vei fra A! Hvorfor fungerer dette? Kjøretid Topologisk sortering: Initialisere nodeavstander: Relax: Totalt: Θ(E + V) Θ(V) Θ(E) tiv n re i ha rh e Θ(E + V) Hv kj as v vis D en g t in e rd e a ga ne el? k y s! G DA

Bellman-Ford La oss gå løs på denne! Gjør V - 1 ganger: For alle kanter (u,v): Relax(u,v) Kjøretid Θ(VE)

Hvorfor fungerer Bellman-Ford?

Negative sykler i Bellman-Ford

La oss kjøre Dijkstra på denne! Dijkstra La Q være en min-prioritetskø Legg alle noder i Q Så lenge Q ikke er tom: u = Q.pop() for hver nabo v av u: Relax(u,v) Kjøretid: V Innsettinger og pop inger E Relax Array: O(V2) Binary heap: O((V + E) lg V) Array Binary Heap Innsetting Pop Oppdater 1 V 1 log V log V log V

Hvorfor fungerer Dijkstra? Når vi pop er u vil u.d være korteste vei. Altså: Når vi velger å besøke node u har vi allerede funnet korteste vei til u. Hvorfor?

Negative kanter og Dijksktra Den som venter på noe godt... Dijkstra + negative kanter sant

H2013, oppgave 11

Kahoot!

Maks flyt

Kapasitet begge veier i boka

Residual-nettverk

Kansellere / reversere flyt 0/3

Kansellere / reversere flyt 2/3 2 2

Kansellere / reversere flyt 1/3 1 1

Kansellere / reversere flyt 2 2

Kansellere / reversere flyt 1 1

Kansellere / reversere flyt 2/3 1 1 1

Flytforøkende sti

Ford-Fulkersons metode Så lenge du finner en flytforøkende sti Øk flyten langs denne stien så mye som mulig

Ford-Fulkerson kjøretid? Finne flytforøkende sti: Θ(V + E) aka Θ(E) i en sammenhengende graf Hvor mange ganger må vi finne flytforøkende sti? O( f* ) O(E f* )

Edmond-Karp Bruk bredde først søk til å finne flytforøkende sti i Ford-Fulkerson Trenger kun finne flytforøkende sti O(VE) ganger O(VE2)

Maks flyt vs. min snitt

Maks flyt vs. min kutt s t

Maks flyt vs. min kutt S s t T

H2014, oppgave 4b

H2011, oppgave 2d

H2010, oppgave 6a

H2010, oppgave 6a Fag Forelesere 1 1 1 2 1 1 1 1 s 1 1 1 2 1 1 1 t

H2010, oppgave 6b

H2010, oppgave 6b Kollisjonsgrupe Forelesere 1 1 1 Fag 1 1 2 1 1 1 1 1 s 1 1 1 1 1 1 3 1 1 1 t

Dynamisk Programmering - motivasjon Fibonacci-tall 0 1 1 2 3 5 8 13 21 34...

Fibonacci def fib(n): if n == 0: return 0 elif n == 1: return 1 else: return fib(n-1) + fib(n-2) La oss prøve å kjøre den på noen n er! Det er jo kjempetregt! po s k E ell i t n ne! d i t e kjør fib(5)

Forbedre Fibonacci Vi må utnytte de overlappende delproblemene 3 i <! d et r ø j k r æ e n i L La oss prøvekjøre vidunderet! fib(5)

Enda bedre? 0 1 1 2 3 5 8 13 Også lineær kjøretid <3 La oss prøvekjøre denne

Fibonacci 8 6 7 4 5 2 3 Det er en DAG! Vi løste den i motsatt topologisk rekkefølge 0 1

Dynamisk programmering Naiv (dum) løsning: Lett, men eksponentiell tid Memoisering Lineær tid Bottom up Lineær tid Problemer som består av delproblemer Delproblemene overlapper (brukes flere ganger) Som regel er vi interessert i optimaliseringsproblemer La oss se på et

Rod Cutting 9 + 10 + 1 = 20 Optimal substruktur 1 $1 2 $5 3 $8 4 $9 5 $10 6 $17 7 $17 8 $20 9 $24 10 $30

Rod Cutting rn: maks avkastning for stang av lengde n pn: prisen for en stang av lengde n rn = max(pn, r1+rn-1, r2+rn-2,, rn-2+r2, rn-1+r1) 1 $1 2 $5 3 $8 4 $9 5 $10 6 $17 7 $17 8 $20 9 $24 10 $30

Rod Cutting 1 $1 2 $5 3 $8 4 $9 5 $10 6 $17 7 $17 Eksponentiell kjøretid :-( 8 $20 Men vi kan memoisere :-) 9 $24 Hva blir kjøretiden da? 10 $30 rn: maks avkastning for stang av lengde n pn: prisen for en stang av lengde n CUT-ROD(p,n) if n == 0 return 0 q = - for i = 1 to n q = max(q, p[i] + CUT-ROD(p, n-i)) return q

Rod Cutting rn: maks avkastning for stang av lengde n pn: prisen for en stang av lengde n Hva hvis vi skal bygge løsningen nedenfra og opp? La oss prøve å gjøre det 1 $1 2 $5 3 $8 4 $9 5 $10 6 $17 7 $17 8 $20 i 0 1 2 3 4 5 6 7 8 9 10 9 $24 r[i] 0 1 5 8 10 13 17 18 22 25 30 10 $30

Rod Cutting 1 $1 2 $5 3 $8 4 $9 5 $10 6 $17 Hva blir kjøretiden? 7 $17 Θ(n2) Akkurat som memoisering 8 $20 9 $24 10 $30 rn: maks avkastning for stang av lengde n pn: prisen for en stang av lengde n BOTTOM-UP-CUT-ROD(p, n) let r[0..n] be a new array r[0] = 0 for j = 1 to n q = - for i = 1 to j q = max(q, p[i] + r[j - i]) r[j] = q return r[n]

Hva skjedde nå? Delproblem-grafen Problemet vårt hadde optimal substruktur Problemet hadde overlappende delproblemer Vi sørget for å løse et delproblem kun én gang, og effektivt byttet lagringsplass mot bedre kjøretid Vi behandlet problemene i omvendt topologisk rekkefølge

Abstraksjon Vi må ha: Optimal substruktur Overlappende delproblemer

DP-algoritmer dere kjenner fra før DAG Shortest Path Bellman-Ford Floyd-Warshall

Floyd Warshall Noder man kan gå innom Noder man ikke kan gå innom k k j i Alle noder

Obs! For å ha optimal delstruktur må delproblemene være uavhengige! Lengste enkle sti q r t For å ha optimal delstruktur må q r og r t være lengste stier også Det er de ikke! Delproblemene er ikke uavhengige

Så hvordan går vi fram? 1. 2. 3. 4. Beskriv/karakteriser strukturen til en optimal løsning (definer problem-parametere og finn delproblem-dag en) - tenk på hvilke valg som må gjøres Definer rekursivt verdien til en optimal løsning Regn ut verdien til en optimal løsning (og husk valgene du gjør) Bygg opp en optimal løsning basert på beregnet informasjon

H2012, oppgave 1f

Knapsack w i-2 vi-2 = $3 wi-2 = 2L i-1 vi-1 = $2 wi-1 = 2L i vi = $5 wi = 3L i+1 i+2 vi+1 = $7 wi+1 = 5L vi+2 = $2 wi+1 = 1L

Knapsack - Ikke ta med i w i-2 vi-2 = $3 wi-2 = 2L i-1 vi-1 = $2 wi-1 = 2L i vi = $5 wi = 3L i+1 i+2 vi+1 = $7 wi+1 = 5L vi+2 = $2 wi+1 = 1L

Knapsack - Ta med i w - wi i-2 vi-2 = $3 wi-2 = 2L i-1 vi-1 = $2 wi-1 = 2L i vi = $5 wi = 3L i+1 i+2 vi+1 = $7 wi+1 = 5L vi+2 = $2 wi+1 = 1L

i-2 vi-2 = $3 wi-2 = 2L i-1 vi-1 = $2 wi-1 = 2L vi = $5 wi = 3L Knapsack - wi > w w i i+1 i+2 vi+1 = $7 wi+1 = 5L vi+2 = $2 wi+1 = 1L

i-2 vi-2 = $3 wi-2 = 2L i-1 vi-1 = $2 wi-1 = 2L vi = $5 wi = 3L Knapsack - i = 0 w i i+1 i+2 vi+1 = $7 wi+1 = 5L vi+2 = $2 wi+1 = 1L

Reduksjon X P Y

NPC NP-Complete 1. 2. Må være i NP Må være minst like vanskelig som alle andre problemer i NP (NP-Hard hvis 2. er oppfylt, men ikke nødvendigvis 1)

???????? P=NP???????

Hva kan vi bruke det til? NPC-problem P Ditt problem

Hetland sin fjell-sammenligning

Hva vi har å ta av

H2013, oppgave 9

H2008, oppgave 1f

H2014, oppgave 7a

Kahoot!