Algdat Eksamensforelesning. Nils Barlaug

Transkript

1 Algdat Eksamensforelesning Nils Barlaug

2 Eksamen Pensum

3 Eksamen Pensum Oppgaver du har gjort og ting du har lest

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

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

6 Diskmat-eksamen 2010 Pensum

11 Diskmat-eksamen - sum over tid Pensum

12 Exphil-eksamen Pensum

13 Exphil-eksamen Pensum

14 Exphil-eksamen Pensum Blom ster heft e

15 Matte 1-4 Pensum

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

17 AlgDat-eksamen 2010 Pensum

21 AlgDat-eksamen - sum over tid Pensum

22

23 Hvordan forberede seg?

24 Traversering G = (V, E)

25 Dybde først søk

26 Bredde først søk

29 H2012, oppgave 1d

30 H2011, oppgave 1f

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

33 H2012, oppgave 1b

34 Topologisk sortering

35 H2011, oppgave 1a

36 Annet eksempel på topologisk sortering

37 Enda et eksempel

38 Enda et eksempel

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

40 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?

41 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

42 V2012, oppgave 1a

43 Minimale spenntrær

44 Annet eksempel

45 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?

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

47 Teorem 23.1 Snitt

48 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 ----

49 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

50 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)

53 H10, oppgave 5a

54 Kjøretid

55 2 1

56 2 2 x sortering 1 1

57

58 n3

59 n3 n2

60 O

61 Θ О Ω

62 H2012, 1a

63 Worst/best case vs. O/Ω

64 H2012, oppgave 2c

65 Hvordan finne kjøretid?

66 Kahoot!

67 Rekurrenser

68 Hvordan løse? Iterasjon Rekursjonstre Variabelskifte Substitusjonsmetoden Masterteoremet

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

70 H2012, oppgave 1L) - Rekursjonstre

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

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

73 H2012, oppgave 1L) - variabelskifte

74

75 H2012, oppgave 1L) - substitusjonsmetoden

76

77 H2012, oppgave 1L) - masterteoremet

78 H2010, oppgave 4

79 Heap

80 MAX-HEAPIFY

81 BUILD-HEAP

82 HEAPSORT

83 INCREASE-KEY

85 Sortering

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

87 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

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

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

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

91 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

92 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!

93 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

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

95 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

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

97 Hvor fort kan vi gå?

98 H2011, oppgave 2c

99 H2010, oppgave 1g

102 Korteste vei - en til alle

103 Eksempel på bruk

106 Negative kanter

107 Gøy med negative kanter Profitt =

108 Negative sykler er ikke alltid et problem

109 Positive sykler

110 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.

111 Optimal substruktur!

112 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

114 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

115 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)

116 Hvorfor fungerer Bellman-Ford?

117 Negative sykler i Bellman-Ford

118 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

119 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?

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

121 H2013, oppgave 11

122 Kahoot!

123 Maks flyt

124 Kapasitet begge veier i boka

125 Residual-nettverk

126 Kansellere / reversere flyt 0/3

127 Kansellere / reversere flyt 2/3 2 2

128 Kansellere / reversere flyt 1/3 1 1

129 Kansellere / reversere flyt 2 2

130 Kansellere / reversere flyt 1 1

131 Kansellere / reversere flyt 2/

132 Flytforøkende sti

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

134

135

136 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* )

137 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)

138 Maks flyt vs. min snitt

139 Maks flyt vs. min kutt s t

142 Maks flyt vs. min kutt S s t T

146 H2010, oppgave 6a Fag Forelesere s t

148 H2010, oppgave 6b Kollisjonsgrupe Forelesere Fag s t

149 Dynamisk Programmering - motivasjon Fibonacci-tall

150 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)

151 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)

152 Enda bedre? Også lineær kjøretid <3 La oss prøvekjøre denne

153 Fibonacci Det er en DAG! Vi løste den i motsatt topologisk rekkefølge 0 1

154 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

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

156 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

157 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

158 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 $24 r[i] $30

159 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]

160 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

161 Abstraksjon Vi må ha: Optimal substruktur Overlappende delproblemer

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

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

164 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

165 Så hvordan går vi fram? 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

167 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

168 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

169 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

170 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

171 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

172 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