Minor formatting

Algoritmer/Grafer/bellman-ford.md

@@ -22,7 +22,7 @@ Bellman-Ford algoritmen løser single-source shortest-path (SSSP) problemet i de
 ## Trinn for trinn
 <!-- Pseudokode med forklaring -->
 
-Gitt en vektet rettet graf $G=(V,E)$ med kilde $s$ og en vektfunksjon $w : E -> \R$, vil Bellman-Ford returnere `True` hvis og bare hvis grafens startnode ikke finner noen ingen negativ-vekt sykler.
+Gitt en vektet rettet graf $G=(V,E)$ med kilde $s$ og en vektfunksjon $w : E -> \mathbb{R}$, vil Bellman-Ford returnere `True` hvis og bare hvis grafens startnode ikke finner noen ingen negativ-vekt sykler.
 
 G = graf | w = vekting | i = teller | u = fra-node | v = til-node
 

Algoritmer/Grafer/dag-shortest-path.md

@@ -1,4 +1,4 @@
-# DAG Shortest path
+# DAG-Shortest-Path
 <!-- [J9] Forstå DAG-Shortest-Path -->
 
 <!-- 

Algoritmer/Grafer/floyd-warshall.md

@@ -10,9 +10,16 @@
 6. Kjenne kjøretidene under ulike omstendigheter, og forstå utregningen
 -->
 
+Floyd-Warshall brukes til å finne den korteste veien mellom alle noder i en vektet rettet graf ved bruk av dynamisk programmering og matriser.
+
 ## Den formelle definisjonen av det generelle problemet
 <!-- Et problem er relasjonen mellom input og output -->
 
+Input: En vektet, rettet graf $G=(V,E)$ uten negative sykler, der $V=[1,...,n]$, og vektene er gitt av matrisen $W=(w_{ij})$  
+Output: En $n*n$ matrise $D=(d_{ij})$ med avstander, dvs. $d_{ij}=s(i,j)$
+
+Returnerer en forgjengermatrise $\Pi=(\pi_{ij})$
+
 ## Tilleggskrav for korrekthet
 <!-- Korrekhet: algoritmer virker, gir det svaret den skal -->
 <!-- Eks: Binary search må ha en sortert liste -->
@@ -27,8 +34,10 @@
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+$\Theta(V^3)$ da det er tre nøstede løkker i algoritmen.
+
 Best case | Average case | Worst case | Minne
 ---------|----------|---------|---------
- TODO | TODO | TODO | TODO
+ $\Theta(V^3)$ | $\Theta(V^3)$ | $\Theta(V^3)$ | $\Theta(V^2)$
 
 ## Python kodeeksempel

Algoritmer/Grafer/transitive-closure.md

@@ -0,0 +1,39 @@
+# Transitive-Closure
+<!-- [K3] Forstå Transitive-Closure -->
+
+<!-- 
+1. Kjenne den formelle definisjonen av det generelle problemet den løser
+2. Kjenne til eventuelle tilleggskrav den stiller for å være korrekt
+3. Vite hvordan den oppfører seg; kunne utføre algoritmen, trinn for trinn!
+4. Forstå korrekthetsbeviset; hvordan og hvorfor virker algoritmen egentlig?
+5. Kjenne til eventuelle styrker eller svakheter, sammenlignet med andre
+6. Kjenne kjøretidene under ulike omstendigheter, og forstå utregningen
+-->
+
+Transitive-Closure er lik som Floyd-Warshall, men sjekker kun om det finnes en sti eller ikke, og ignorerer kantvekter.
+
+## Den formelle definisjonen av det generelle problemet
+<!-- Et problem er relasjonen mellom input og output -->
+
+Input: En rettet graf $G=(V,E)$  
+Output: En rettet graf $G*=(V,E*)$ der $(i,j)\in E*$ hvis og bare hvis det finnes en sti fra $i$ til $j$ i $G$
+
+## Tilleggskrav for korrekthet
+<!-- Korrekhet: algoritmer virker, gir det svaret den skal -->
+<!-- Eks: Binary search må ha en sortert liste -->
+
+## Trinn for trinn
+<!-- Pseudokode med forklaring -->
+
+## Korrekthetsbevis
+
+## Styrker og svakheter sammenlignet med andre
+
+## Kjøretid og utregning
+<!-- Under ulike omstendigheter -->
+
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+ TODO | TODO | TODO | TODO
+
+## Python kodeeksempel

Algoritmer/Sortering/selection_sort.md

@@ -37,7 +37,7 @@ En tidkrevende sorteringsalgoritme som søker gjennom en usortert liste og flytt
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
-I utgangspunktet kan vi se at algoritmen inneholder 2 løkker, som gir $n \sdot n = n^2$.
+I utgangspunktet kan vi se at algoritmen inneholder 2 løkker, som gir $n \cdot n = n^2$.
 
 Det å finne minimum i en liste krever at $n$ elementer sjekkes ($n-1$ sammenligninger), for så å flytte den til starten av lista. For å finne neste minste må man sjekke $n-1$ elementer, osv. Antall sammenligninger er dermed:
 $$(n-1)+(n-2) \space ...+1 = \sum_{i=1}^{n-1} i = \frac{1}{2}(n^2-n)$$

README.md

@@ -42,7 +42,7 @@
 
 En **algoritme** er en tydelig definert fremgangsmåte som kan ta en verdi eller en mengde verdier som **input** og produserer en verdi eller en mengde verdier som **output**. Algoritmen er ofte en sekvens av beregninger, presist beskrevet. Input verdiene kan deles opp i flere **instanser**.
 
-Å **analysere en algoritme** har fått betydningen å "forutse ressurskravene til algoritmen": minne, kommunikasjonsbåndbredde, hardware, beregningstid, og ofte totalkostnaden av disse, i tillegg til å vise **korrekthet**. <!--Link til begrepet korrekthet-->
+Å **analysere en algoritme** har betydningen å "forutse ressurskravene til algoritmen": minne, kommunikasjonsbåndbredde, hardware, beregningstid, og ofte totalkostnaden av disse, i tillegg til å vise **korrekthet**. <!--Link til begrepet korrekthet-->
 
 ### Random-access machine modellen (RAM)
 <!-- [A2] Kjenne egenskapene til random-access machine-modellen (RAM) -->
@@ -324,9 +324,24 @@ Ved bruk av summen av toerpotenser kan man regne ut den amortiserte kjøretiden
 
 ### Dynamiske tabeller
 <!-- [B9] Forstå hvordan dynamiske tabeller fungerer (Table-Insert) -->
-Som nevnt i amortisert analyse ønsker vi å allokere minne sjeldent fordi det tar lineær tid å allokere nytt minne og kopiere elementer. Vi velger med dynamiske tabeller å heller allokere mye minne av gangen når det blir behov. Med amortisert arbeid blir kjøretiden akseptabel. Man øker størrelsen med en viss prosent. I eksempelet under øker den med x2 hver gang.
+Som nevnt i amortisert analyse ønsker vi å allokere minne sjeldent fordi det tar lineær tid å allokere nytt minne og kopiere elementer. Vi velger med dynamiske tabeller å heller allokere mye minne av gangen når det blir behov.
 
-![Table-Insert](https://i.imgur.com/wUEW9AW.png)
+Med amortisert arbeid blir kjøretiden akseptabel. Man øker størrelsen med en viss prosent. I eksempelet under øker den med x2 hver gang.
+
+```pseudo
+TABLE-INSERT(T,x)
+  if T.size == 0
+    allocate T.table with 1 slot
+    T.size = 1
+  if T.num == T.size
+    allocate new-table with 2*T.size slots
+    insert all items in T.table into new-table
+    free T.table
+    T.table = new-table
+    T.size = 2*T.size
+  insert x into T.table
+  T.num = T.num+1
+```
 
 ## Splitt og hersk
 <!-- ![C1] Forstå designmetoden divide-and-conquer (splitt og hersk) -->
@@ -855,7 +870,7 @@ Vi innfører **vekter** på kantene. Disse kan tolkes som **lengder** eller **ko
 
 Problemet:
 
-> **Input:** En urettet graf $G = (V,E)$ og en vektfunksjon $w : E \rightarrow \R$.  
+> **Input:** En urettet graf $G = (V,E)$ og en vektfunksjon $w : E \rightarrow \mathbb{R}$.  
 > **Output:** En asyklisk delmengde $T \subseteq E$ som kobler sammen nodene i $V$ og som minimerer vektsummen:
 > $$w(T)=\sum_{(u,v)\in T}w(u,v)$$
 
@@ -979,14 +994,16 @@ Vi drar med oss info fra forgjengerne, såkalt "pulling".
 
 Vi kan finne de korteste veiene fra hver node etter tur, men mange av delinstansene vil overlappe – om vi har mange nok kanter lønner det seg å bruke dynamisk programmering med dekomponeringen «Skal vi innom k eller ikke?»
 
+### Forgjengerstrukturen for alle-til-alle varianten av korteste vei problemet (Print-All-Pairs-Shortest-Path)
 <!-- [K1] Forstå forgjengerstrukturen for alle-til-alle-varianten av korteste vei-problemet (Print-All-Pairs-Shortest-Path) -->
 
 ### Floyd-Warshall algoritmen
 <!-- [K2] Forstå Floyd-Warshall -->
 [Link til Floyd-Warshall](Algoritmer/Grafer/floyd-warshall.md)
 
-### Transitive closure
+### Transitive-Closure
 <!-- [K3] Forstå Transitive-Closure -->
+[Link til Transitive-Closure](Algoritmer/Grafer/transitive-closure.md)
 
 ### Johnsons algoritme
 <!-- [K4] Forstå Johnson -->
@@ -1001,6 +1018,7 @@ Flyt-problemet spør rett og slett hvor mye vi kan sende fra en node til en anne
 
 Noder A og B. Kanten i mellom har en kapasitet.
 
+### Håndtering av antiparallelle kanter og flere kilder og sluk
 <!-- [L2] Kunne håndtere antiparallelle kanter og flere kilder og sluk -->
 
 ### Restnettet til et flytnett med en gitt flyt
@@ -1025,6 +1043,7 @@ Så lenge vi finner en sti som kan øke flyten kan vi endre flyten.
 ### Edmond Karp algoritmen
 <!-- [L9] Vite at Ford-Fulkerson med BFS kalles Edmonds-Karp-algoritmen -->
 
+### Maks-flyt kan finne en maksimum bipartitt matching
 <!-- [L10] Forstå hvordan maks-flyt kan finne en maksimum bipartitt matching -->
 
 ### Heltallsteoremet (integrality theorem)
@@ -1034,7 +1053,7 @@ Så lenge vi finner en sti som kan øke flyten kan vi endre flyten.
 
 NP er den enorme klassen av ja-nei-problemer der ethvert ja-svar har et bevis som kan sjekkes i polynomisk tid. Alle problemer i NP kan i polynomisk tid reduseres til de såkalt komplette problemene i NP. Dermed kan ikke disse løses i polynomisk tid, med mindre alt i NP kan det. Ingen har klart det så langt...
 
-> Merk: Det kreves ikke grundig forståelse av de ulike NP-kompletthetsbevisene
+> Det kreves ikke grundig forståelse av de ulike NP-kompletthetsbevisene
 
 - **Problem**: abstrakt, binær relasjon mellom input og output
 - **Konkret problem**: input og output er bitstrenger