Minor general update

Algoritmer/Grafer/breadth_first_search.md

@@ -1,4 +1,5 @@
 # Breadth first search (BFS)
+<!-- [H2] Forstå BFS, også for å finne korteste vei uten vekter -->
 
 <!-- 
 1. Kjenne den formelle definisjonen av det generelle problemet den løser

Algoritmer/Grafer/depth_first_search.md

@@ -1,4 +1,5 @@
 # Depth first search (DFS)
+<!-- [H3] Forstå DFS og parentesteoremet -->
 
 <!-- 
 1. Kjenne den formelle definisjonen av det generelle problemet den løser

Algoritmer/Grafer/dijkstra.md

@@ -44,6 +44,7 @@ Optimal substruktur. Gitt ingen negative kanter vil det umulig kunne være noen
 
 Array: $O(V^2)$  
 Binary heap: $O((V+E)\log V)$
+<!-- TODO: Sjekk opp. Fra eksamensforelesning 2020 -->
 
 Best case | Average case | Worst case | Minne
 ---------|----------|---------|---------

Algoritmer/Grafer/heap_sort.md

@@ -35,4 +35,6 @@ Heap sort er en sammenligningsbasert algoritme, lik selection sort, hvor vi før
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+<!-- En heap bruker logaritmisk tid for å ta ut det største eller minste elementet i heapen (?) -->
+
 ## Python kodeeksempel

Algoritmer/Sortering/bucket_sort.md

@@ -18,6 +18,7 @@ Bucket sort antar at input-listen er generert tilfeldig og er uniformt fordelt o
 ## Tilleggskrav for korrekthet
 <!-- Korrekhet: algoritmer virker, gir det svaret den skal -->
 <!-- Eks: Binary search må ha en sortert liste -->
+For at bucket sort skal fungere må vi unngå at alle tallene havner i samme bøtte.
 
 ## Trinn for trinn
 <!-- Pseudokode med forklaring -->

Algoritmer/Sortering/counting_sort.md

@@ -34,15 +34,15 @@ Anta at du kan kun ha $k$ distinkte elementer. Tell hvor mange instanser det er
 - Ikke sammenligningsbasert
 - **Counting sort** slår **radix sort** hvis antallet elementer $n \gg k$ forskjellige elementer. (_Dette er også det tilfellet hvor algoritmen er mest effektiv._)
 - Sorterer basert på at alle input-elementene $n$ er heltall med en range mellom $0$ og $k$.
-- Ikke in-place da den lager en ny liste midlertidig for å telle antall forekomster av hvert element
-- Stabil: den relative rekkefølgen til elementene i listen opprettholdes under sorteringen
+- In-place: Nei, da den lager en ny liste midlertidig for å telle antall forekomster av hvert element
+- Stabil: Ja, den relative rekkefølgen til elementene i listen opprettholdes under sorteringen
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
 Best case | Average case | Worst case | Minne
 ---------|----------|---------|---------
-TODO | TODO | TODO | TODO
+$\Theta(n+k)$ | $\Theta(n+k)$ | $\Theta(n+k)$ | $O(n+k)$
 
 ## Python kodeeksempel
 

Algoritmer/Sortering/radix_sort.md

@@ -43,6 +43,7 @@ $\Theta(d(n+k))$ | $\Theta(d(n+k))$ | $\Theta(d(n+k))$ | $O(n+k)$
 der $d$ er antallet siffer i maksimum, $n$ er antall elementer og $k$ er antallet unike elementer.
 
 ## Python kodeeksempel
+
 ```python
 def modified_counting_sort(A, B, idx): # A = Usortert liste. B = Liste hvor resultatet skal puttes. idx = indeksen som sorteringen skal basere seg på
     k = 10

Algoritmer/Sortering/selection_sort.md

@@ -31,8 +31,8 @@ En tidkrevende sorteringsalgoritme som søker gjennom en usortert liste og flytt
 
 ## Styrker og svakheter sammenlignet med andre
 
-- In-place: det blir ikke opprettet kopier av lista, elementer blir kun flyttet.
-- Ustabil: garanterer ikke at den relative rekkefølgen til like elementer er lik under sorteringen av listen.
+- In-place: Ja, det blir ikke opprettet kopier av lista, elementer blir kun flyttet.
+- Stabil: Nei, garanterer ikke at den relative rekkefølgen til like elementer er lik under sorteringen av listen.
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->

README.md

@@ -515,6 +515,8 @@ $$[B1, C2, C1, A1]$$
 og sorterer den kun etter bokstaver, vil rekkefølgen for $C$ forbli uforandret:
 $$[A1, B1, C2, C1]$$
 
+Vi sier ofte at _den relative rekkefølgen_ opprettholdes.
+
 ### Counting sort
 <!-- [D3] Forstå Counting-Sort, og hvorfor den er stabil -->
 [Link til counting sort](Algoritmer/Sortering/counting_sort.md)
@@ -622,17 +624,15 @@ Memoisering innebærer at man cacher løsninger på delproblemer for så å kunn
 ```python
 F = [-1]*50 #array to store fibonacci terms
 
-def dynamic_fibonacci(n):
+def fibonacci_top_down(n):
   if (F[n] < 0):
     if (n==0):
       F[n] = 0
     elif (n == 1):
       F[n] = 1
     else:
-      F[n] = dynamic_fibonacci(n-1) + dynamic_fibonacci(n-2)
+      F[n] = fibonacci_top_down(n-1) + fibonacci_top_down(n-2)
   return F[n]
-
-print(dynamic_fibonacci(46))
 ```
 
 ### Iterasjon (bottom-up)
@@ -648,15 +648,16 @@ def fibonacci_bottom_up(n):
   for i in range(2, n+1):
     F[i] = F[i-1] + F[i-2]
   return F[n]
-
-print(fibonacci_bottom_up(46))
 ```
 
 ### Konstruere løsning fra lagrede beslutninger
 <!-- [F5] Forstå hvordan man rekonstruerer en løsning fra lagrede beslutninger -->
 
 ### Optimal delstruktur
 <!-- [F6] Forstå hva optimal delstruktur er -->
+Optimal delstruktur vil si at løsningen er en kombinasjon av optimale løsninger på delinstansene.
+
+Hva om vi ikke har overlappende delproblemer? Da kan vi ikke bruke memoisering da det ikke er noe hensikt i å huske svarene.
 
 ### Overlappende delinstanser
 <!-- [F7] Forstå hva overlappende delinstanser er -->
@@ -666,7 +667,7 @@ print(fibonacci_bottom_up(46))
 
 Stavkuttingsproblemet: du har en stav av størrelse $n$ som skal deles i biter og selges for størst fortjeneste. Forskjellige størrelser selges for forskjellige priser.
 
-La $n=7$ og $p=<1,4,3,6,8,5,9>$ være en instans av stavkuttingsproblemet. Hva blir den maksimale inntekten, $r_7$?
+La $n=7$ og $p=[1,4,3,6,8,5,9]$ være en instans av stavkuttingsproblemet. Hva blir den maksimale inntekten, $r_7$?
 
 $$4+4+4+1 = 13$$
 $$4+8 = 12$$
@@ -771,7 +772,7 @@ $\Theta(V)$ | $\Theta(V+E)$
 
 Hver node & kant blir sjekket en gang.
 
-### Depth first search (DFS)
+### Depth first search (DFS) og parentesteoremet
 <!-- [H3] Forstå DFS og parentesteoremet -->
 <!-- [H4] Forstå hvordan DFS klassifiserer kanter -->