diff --git a/ADK-labb3-Testing/BipRed.java b/ADK-labb3-Testing/BipRed.java
new file mode 100644
index 0000000..dd3847e
--- /dev/null
+++ b/ADK-labb3-Testing/BipRed.java
@@ -0,0 +1,141 @@
+import java.util.*;
+
+/**
+ * Programmet löser matchningsproblemet med hjälp av en svart låda som löser flödesproblemet. 
+ * 
+ * @author Emilia Rieschel & Charlotta Johnsson
+ * @date 2021-11-03
+ */
+
+ 
+public class BipRed {
+    private Kattio io;
+    private int vertices;
+    private int xNodes;
+    private int yNodes;
+    private int maxFlow;
+    private int sink;
+    private int source;
+    private LinkedList<Edge>[]edges;
+    private int numberOfEdges;
+    private LinkedList<SimpleEdge> result;
+
+    void readBipartiteGraph() {
+
+        // Läs antal hörn och kanter
+        int x = io.getInt();
+        int y = io.getInt();
+        int e = io.getInt();
+
+        // Spara globala variabler
+        numberOfEdges = e + x + y;
+        vertices = x + y + 2; //För vi lägger till s och t
+        edges = new LinkedList[x+y+2]; //en array av LinkedList med plats för alla noder förutom sink
+        xNodes = x;
+        yNodes = y;
+        source = 1;
+        sink = vertices;
+
+        // Skapar en LinkedList för varje nod, där kommer kanter till noden att vara
+        for(int i = 1; i < edges.length; i++){
+            edges[i] = new LinkedList<Edge>();
+        }
+
+        // Skapar en kant mellan source och alla X-noder
+        for(int i = 1; i <= x; i++){
+            edges[1].add(new Edge((i+1),1,0,0));
+        }
+
+        // Skapar en kant mellan alla Y-noder och sink
+        for(int i = x+1; i < vertices-1; i++){
+            edges[i+1].add(new Edge(vertices, 1, 0, 0));
+        }
+
+        // Läs in kanterna och skapa en Edge för kanten
+        for (int i = 0; i < e; ++i) {
+            int a = io.getInt();
+            int b = io.getInt();
+            edges[a+1].add(new Edge((b+1), 1, 0, 0));
+        }
+    }
+
+
+    void writeFlowGraph() {
+
+        // Skriv ut antal hörn och kanter samt källa och sänka
+        io.println(vertices);
+        io.println((source) + " " + (sink));
+        io.println(numberOfEdges);
+
+        // Skriv ut alla kanter och dess kapacitet
+        for (int i = 1; i < edges.length; i++){
+            for(Edge e: edges[i]){
+                io.println(i + " " + e.getY() + " " +  e.getCapacity());
+            }
+        }
+
+        io.flush();
+    }
+
+
+    void readMaxFlowSolution() {
+
+        // Läs in antal hörn, kanter, källa, sänka, och totalt flöde
+        int v = io.getInt();
+        int s = io.getInt();
+        int t = io.getInt();
+        int totalflow = io.getInt();
+        int e = io.getInt();
+
+        // Spara global variabel
+        maxFlow = totalflow;
+
+        // Skapa lista för resultatet
+        result = new LinkedList<>();
+
+        // Läs in alla kanter och flödet
+        for (int i = 0; i < e; ++i) {
+            int a = io.getInt();
+            int b = io.getInt();
+            int f = io.getInt();
+
+            // Om kanten inte är från source eller till sink och flöder är 1, lägg till i resultatlistan
+            if(f == 1 && a != source && b != sink){
+                result.add(new SimpleEdge((a-1),(b-1)));
+            }
+        }
+    }
+    
+
+    void writeBipMatchSolution() {
+        
+        // Skriv ut antal hörn och storleken på matchningen
+        io.println(xNodes + " " + yNodes);
+        io.println(maxFlow);
+
+        // Skriv ut kanterna i matchningen
+        for(SimpleEdge e: result){
+            io.println(e.getFrom() + " " + e.getTo());
+        }
+    }
+
+
+    BipRed() {
+
+        io = new Kattio(System.in, System.out);
+
+        readBipartiteGraph();
+
+        writeFlowGraph();
+        
+        readMaxFlowSolution();
+
+        writeBipMatchSolution(); 
+
+        io.close();    
+    }
+
+    public static void main(String args[]) {
+        new BipRed();
+    }
+}
diff --git a/ADK-labb3-Testing/Edge.class b/ADK-labb3-Testing/Edge.class
new file mode 100644
index 0000000..1a81d84
Binary files /dev/null and b/ADK-labb3-Testing/Edge.class differ
diff --git a/ADK-labb3-Testing/Edge.java b/ADK-labb3-Testing/Edge.java
new file mode 100644
index 0000000..b81ab7d
--- /dev/null
+++ b/ADK-labb3-Testing/Edge.java
@@ -0,0 +1,51 @@
+/**
+ * @author Emilia Rieschel & Charlotta Johnsson
+ * @date 2021-11-03
+ */
+
+
+public class Edge {
+    private int capacity;
+    private int flow;
+    private int y;
+    private int res;
+
+    Edge(int y, int c, int flow, int res){
+        this.y = y;
+        this.capacity = c;
+        this.flow = flow;
+        this.res = res;
+    }
+
+    public int getY(){
+        return y;
+    }
+
+    public int getCapacity() {
+        return capacity;
+    }
+
+    public int getFlow() {
+        return flow;
+    }
+
+    public int getRes(){
+        return res;
+    }
+
+    public void setCapacity(int c) {
+        capacity = c;
+    }
+
+    public void changeRes(int f) {
+        res = capacity + f;
+    }
+
+    public void setFlow(int f) {
+        flow = f;
+    }
+
+    public void increaseFlow(int f) {
+        flow += f;
+    }
+}
diff --git a/ADK-labb3-Testing/Kattio.class b/ADK-labb3-Testing/Kattio.class
new file mode 100644
index 0000000..909180c
Binary files /dev/null and b/ADK-labb3-Testing/Kattio.class differ
diff --git a/ADK-labb3-Testing/Kattio.java b/ADK-labb3-Testing/Kattio.java
new file mode 100644
index 0000000..45a9bee
--- /dev/null
+++ b/ADK-labb3-Testing/Kattio.java
@@ -0,0 +1,66 @@
+import java.util.StringTokenizer;
+import java.io.BufferedReader;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.OutputStream;
+
+public class Kattio extends PrintWriter {
+   public Kattio(InputStream i) {
+       super(new BufferedOutputStream(System.out));
+       r = new BufferedReader(new InputStreamReader(i));
+   }
+   public Kattio(InputStream i, OutputStream o) {
+       super(new BufferedOutputStream(o));
+       r = new BufferedReader(new InputStreamReader(i));
+   }
+
+   public boolean hasMoreTokens() {
+       return peekToken() != null;
+   }
+
+   public int getInt() {
+       return Integer.parseInt(nextToken());
+   }
+
+   public double getDouble() {
+       return Double.parseDouble(nextToken());
+   }
+
+   public long getLong() {
+       return Long.parseLong(nextToken());
+   }
+
+   public String getWord() {
+       return nextToken();
+   }
+
+
+
+   private BufferedReader r;
+   private String line;
+   private StringTokenizer st;
+   private String token;
+
+   private String peekToken() {
+       if (token == null)
+           try {
+               while (st == null || !st.hasMoreTokens()) {
+                   line = r.readLine();
+                   if (line == null) return null;
+                   st = new StringTokenizer(line);
+               }
+               token = st.nextToken();
+           } catch (IOException e) { }
+       return token;
+   }
+
+   private String nextToken() {
+       String ans = peekToken();
+       token = null;
+       return ans;
+   }
+}
+
diff --git a/ADK-labb3-Testing/Matchreduce.java b/ADK-labb3-Testing/Matchreduce.java
new file mode 100644
index 0000000..cd99f99
--- /dev/null
+++ b/ADK-labb3-Testing/Matchreduce.java
@@ -0,0 +1,182 @@
+import java.util.*;
+
+/**
+ * Löser matchningsproblemet för bipartita grafer.
+ * 
+ * @author Emilia Rieschel & Charlotta Johnsson
+ * @date 2021-11-03
+ */
+
+public class MatchReduce {
+    private Kattio io;
+    private int vertices;
+    private int xNodes;
+    private int yNodes;
+    private int maxFlow;
+    private int sink;
+    private int source;
+    private LinkedList<Edge>[]edges;
+    private int numberOfEdges;
+    private Queue<Integer> queue;
+    private int[] parent;
+
+    void readBipartiteGraph() {
+
+        // Läser in antal hörn och kanter
+        int x = io.getInt();
+        int y = io.getInt();
+        int e = io.getInt();
+
+        numberOfEdges = e + x + y;
+        vertices = x + y + 2;
+        edges = new LinkedList[vertices+1];
+        xNodes = x;
+        yNodes = y;
+        source = 1;
+        sink = vertices;
+
+        //Initialisera linkedlist för alla index i edges
+        for(int i = 1; i < edges.length; i++){
+            edges[i] = new LinkedList<Edge>();
+        }
+
+        //Lägg till kanter från source till alla X-noder
+        for(int i = 1; i <= x; i++){
+            edges[1].add(new Edge((i+1),1,0,1));
+        }
+
+        //Lägg till kanter från alla Y-noder till sink
+        for(int i = x+1; i < vertices-1; i++){
+            edges[i+1].add(new Edge(vertices, 1, 0, 1));
+        }
+
+        // Läs in kanterna
+        for (int i = 0; i < e; ++i) {
+            int a = io.getInt();
+            int b = io.getInt();
+            edges[a+1].add(new Edge((b+1), 1, 0, 1));
+        }
+    }
+
+
+    public int findIndex(int from, int to){
+        int index = 0;
+        for(Edge e: edges[from]){
+            if(e.getY() == to){
+                return index;
+            }
+            index++;
+        }
+        edges[from].add(new Edge(to, 0, 0, 0));
+        return edges[from].size()-1;
+    }
+
+
+    public boolean bfs(int[] parent){
+
+        boolean[] visited = new boolean[vertices+1];
+        for (int i = 0; i < vertices + 1; ++i)
+            visited[i] = false;
+ 
+        queue.add(source);
+        visited[source] = true;
+        parent[source] = -1;
+ 
+        while (queue.size() != 0) {
+            int u = queue.poll();
+ 
+            for(Edge e: edges[u]){
+                int v = e.getY();
+                if(visited[v] == false && e.getRes() > 0){
+                    if (v == sink) {
+                        parent[v] = u;
+                        return true;
+                    }
+                    queue.add(v);
+                    parent[v] = u;
+                    visited[v] = true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+
+    public int fordFulkerson(){
+
+        queue = new LinkedList<Integer>();
+        parent = new int[vertices+1];
+        int maxFlow = 0;
+
+        while (bfs(parent)) {
+       
+            int pathFlow = Integer.MAX_VALUE;
+            int v = sink;
+            int u;
+            int indexOfElement;
+            LinkedList<Integer> indexList = new LinkedList<>();
+            
+            while(v != source){
+                u = parent[v];
+                indexOfElement = findIndex(u, v);
+                pathFlow = Math.min(pathFlow, edges[u].get(indexOfElement).getRes());
+                v = u;
+                indexList.add(indexOfElement);
+            }
+
+            v = sink;
+            int tempflow = 0;
+            int indexOfElementU;
+            
+            while (v != source) {
+                indexOfElement = indexList.poll();
+                u = parent[v];
+                indexOfElementU = findIndex(v, u);
+                edges[u].get(indexOfElement).increaseFlow(pathFlow);
+                tempflow = edges[u].get(indexOfElement).getFlow();
+                edges[v].get(indexOfElementU).setFlow(-tempflow);
+                edges[u].get(indexOfElement).changeRes(-tempflow);
+                edges[v].get(indexOfElementU).changeRes(tempflow);
+                v = u;
+            }
+
+            maxFlow += pathFlow;
+
+            queue.clear();
+        }
+        return maxFlow;
+        
+    }
+
+    MatchReduce() {
+
+        io = new Kattio(System.in, System.out);
+
+        readBipartiteGraph();
+        
+        int maxflow = fordFulkerson();
+
+        // Skriv ut antal hörn i X och i Y
+        io.println(xNodes + " " + yNodes);
+
+        // Skriv ut antalet kanter funna i matchningen (samma som maxflödet i en bipartit graf)
+        io.println(maxflow);
+
+        // Skriv ut alla kanter som ingår i matchningen
+        // Gå bara igenom kanterna från en X-nod till en Y-nod
+        for(int i = 2; i < edges.length-1-yNodes; i++){
+            for(Edge e: edges[i]){
+                if(e.getFlow() == 1){
+                    io.println((i-1) + " " + (e.getY()-1));
+                }
+            }
+        }
+
+        io.close();
+    }
+
+    public static void main(String args[]) {
+        new MatchReduce();
+    }
+}
diff --git a/ADK-labb3-Testing/SimpleEdge.class b/ADK-labb3-Testing/SimpleEdge.class
new file mode 100644
index 0000000..f51f8fe
Binary files /dev/null and b/ADK-labb3-Testing/SimpleEdge.class differ
diff --git a/ADK-labb3-Testing/SimpleEdge.java b/ADK-labb3-Testing/SimpleEdge.java
new file mode 100644
index 0000000..48baca4
--- /dev/null
+++ b/ADK-labb3-Testing/SimpleEdge.java
@@ -0,0 +1,23 @@
+/**
+ * @author Emilia Rieschel & Charlotta Johnsson
+ * @date 2021-11-03
+ */
+
+ 
+public class SimpleEdge {
+    private int from;
+    private int to;
+
+    SimpleEdge(int from, int to){
+        this.from = from;
+        this.to = to;
+    }
+
+    public int getFrom() {
+        return from;
+    }
+
+    public int getTo() {
+        return to;
+    }
+}
\ No newline at end of file
diff --git a/ADK-labb3-Testing/SolveFP.java b/ADK-labb3-Testing/SolveFP.java
new file mode 100644
index 0000000..f6df660
--- /dev/null
+++ b/ADK-labb3-Testing/SolveFP.java
@@ -0,0 +1,213 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Programmet löser flödesproblemet. 
+ * 
+ * @author Emilia Rieschel & Charlotta Johnsson
+ * @date 2021-11-03
+ */
+
+
+public class SolveFP{
+    private Kattio io;
+    private int sink;
+    private int source;
+    private int a;
+    private int b;
+    private int c;
+    private int e;
+    private int vertices;
+    private int[] parent;
+    private LinkedList<Edge>[]edges;
+    private Queue<Integer> queue;
+    
+    
+    SolveFP() {
+        io = new Kattio(System.in, System.out);
+        
+        // Läser in antalet noder och kanter samt source och sink.
+        vertices = io.getInt();
+        source = io.getInt();
+        sink = io.getInt();
+        e = io.getInt();
+
+        // Skapar arrayen med alla LinkedList som kommer att innehålla alla kanter
+        edges = new LinkedList[vertices+1];
+        for(int i = 1; i < edges.length; i++){
+            edges[i] = new LinkedList<Edge>();
+        }
+
+        // Läser in alla kanter och dess kapacitet, samt skapar en Edge för den kanten
+        for(int i = 0; i < e; i++){
+            a = io.getInt();
+            b = io.getInt();
+            c = io.getInt();
+            edges[a].add(new Edge(b, c, 0, c));
+        }
+
+        // Räknar ut det maximala flödet för den givna grafen
+        int flow = fordFulkerson();
+
+        // Skriver ut antalet kanter, source, sink, samt totala flödet från source till sink
+        io.println(vertices);
+        io.println(source + " " + sink + " " + flow);
+
+        // Räknar och skriver ut hur många kanter som ingår i flödet
+        int count = 0;
+        for(int i = 1; i < edges.length; i++){
+            for(Edge e: edges[i]){
+                if(e.getFlow() > 0){
+                    count++;
+                }
+            }
+        }
+        io.println(count);
+
+        // Skriver ut alla kanter som ingår i maximala flödet, samt kanternas flöde
+        for(int i = 1; i < edges.length; i++){
+            for(Edge e: edges[i]){
+                if(e.getFlow() > 0){
+                    io.println(i + " " + e.getY() + " " + e.getFlow());
+                }
+            }
+        }
+        
+        io.flush();
+        io.close(); 
+    }
+
+
+    /**
+     * Metod för att hitta vilket index i edges[from] som har y-värdet to. Om det inte tidigare finns någon kant
+     * mellan from och to, så skapas en ny kant mellan dem.
+     * @param from Noden som kanten går från.
+     * @param to Noden som kanten går till.
+     * @return Indexet för kanten i edges[from]
+     */
+    public int findIndex(int from, int to){
+        int index = 0;
+
+        // Gå igenom alla kanter tills man kommer till rätt, och returnera då indexet.
+        for(Edge e: edges[from]){
+            if(e.getY() == to){
+                return index;
+            }
+            index++;
+        }
+
+        // Om kanten inte fanns, skapa en ny kant och returnera indexet för den kanten.
+        edges[from].add(new Edge(to, 0, 0, 0));
+        return edges[from].size()-1;
+    }
+
+    /**
+     * Hittar den kortaste vägen med breddenförstsökning, och sparar den hittade vägen i parent.
+     * @param parent Här kommer den hittade vägen att komma.
+     * @return True om det hittas en väg, falskt annars.
+     */
+    public boolean bfs(int[] parent){
+
+        // Skapa en array visited för att hålla koll på vilka noder man redan har besökt.
+        boolean[] visited = new boolean[vertices+1];
+        for (int i = 0; i < vertices + 1; ++i)
+            visited[i] = false;
+ 
+        // Lägg till första noden, det vill säga source, till kön.
+        queue.add(source);
+        visited[source] = true;
+        parent[source] = -1; // Vi var inte på någon annan nod innan.
+ 
+        // Breddenförstsökning, forsätt med loopen tills det inte finns något element kvar i kön.
+        while (queue.size() != 0) {
+            int u = queue.poll();
+ 
+            // Gå igenom varje kant, det vill säga varje granne till u
+            for(Edge e: edges[u]){
+                int v = e.getY();
+
+                // Om vi inte tidigare har varit på noden och residualgrafens flöde är större än 0, lägg till noden i kön.
+                if(visited[v] == false && e.getRes() > 0){
+
+                    // Om vi har kommit till sink, har vi hittat en stig och vi är färdiga.
+                    if (v == sink) {
+                        parent[v] = u;
+                        return true;
+                    }
+
+                    // Annars lägger vi till noden i kön och fortsätter.
+                    queue.add(v);
+                    parent[v] = u;
+                    visited[v] = true;
+                }
+            }
+        }
+ 
+        // Det fanns ingen väg från source till sink, och det returneras därför false. 
+        return false;
+    }
+
+
+    public int fordFulkerson(){
+
+        // Vi skapar kön som kommer att användes i breddenförstsökningen.
+        queue = new LinkedList<Integer>();
+
+        // parent kommer att spara vägen som hittas i breddenförstsökningen
+        parent = new int[vertices+1];
+ 
+        // flödet är 0 från början
+        int maxFlow = 0;
+
+        while (bfs(parent)) {
+       
+            int pathFlow = Integer.MAX_VALUE;
+            int v = sink;
+            int u;
+
+            // För att vi inte ska behöva räkna ut samma index flera gånger.
+            int indexOfElement;
+            LinkedList<Integer> indexList = new LinkedList<>();
+            
+            // Hitta högsta möjliga flödet genom vägen given av parent.
+            while(v != source){
+                u = parent[v];
+                indexOfElement = findIndex(u, v);
+                pathFlow = Math.min(pathFlow, edges[u].get(indexOfElement).getRes());
+                v = u;
+                indexList.add(indexOfElement);
+            }
+
+            v = sink;
+            int tempflow;
+            int indexOfElementU;
+            
+            // Ändra flödet och residualgrafen enligt givna algoritmen för Ford-Fulkerson
+            while (v != source) {
+                indexOfElement = indexList.poll();
+                u = parent[v];
+                indexOfElementU = findIndex(v, u);
+
+                edges[u].get(indexOfElement).increaseFlow(pathFlow);
+                tempflow = edges[u].get(indexOfElement).getFlow();
+                edges[v].get(indexOfElementU).setFlow(-tempflow);
+                edges[u].get(indexOfElement).changeRes(-tempflow);
+                edges[v].get(indexOfElementU).changeRes(tempflow);
+                v = u;
+            }
+
+            // Lägg till flödet på totala flödet
+            maxFlow += pathFlow;
+
+            // Rensa kön som används i breddenförstsökningen
+            queue.clear();
+        }
+ 
+        // Returnera det totala flödet
+        return maxFlow;
+    }
+
+    public static void main(String args[]) {
+        new SolveFP();
+    }
+}
diff --git a/ADK-labb3-Testing/test.indata b/ADK-labb3-Testing/test.indata
new file mode 100644
index 0000000..6c4ec8e
--- /dev/null
+++ b/ADK-labb3-Testing/test.indata
@@ -0,0 +1,15 @@
+2 3
+4  
+1 3
+1 4
+2 3
+2 5
+7
+1 7 2
+6
+1 2 1
+1 3 1
+2 4 1
+3 6 1
+4 7 1
+6 7 1
\ No newline at end of file
diff --git a/ADK-labb3-Testing/test.utdata b/ADK-labb3-Testing/test.utdata
new file mode 100644
index 0000000..a042b58
--- /dev/null
+++ b/ADK-labb3-Testing/test.utdata
@@ -0,0 +1,5 @@
+1 2 1
+1 3 2
+2 4 2
+3 2 1
+3 4 1
diff --git a/C$pair.class b/C$pair.class
new file mode 100644
index 0000000..8b8a27c
Binary files /dev/null and b/C$pair.class differ
diff --git a/C.class b/C.class
new file mode 100644
index 0000000..879c7cf
Binary files /dev/null and b/C.class differ
diff --git a/C.java b/C.java
new file mode 100644
index 0000000..7eda2bf
--- /dev/null
+++ b/C.java
@@ -0,0 +1,217 @@
+import java.util.*;
+
+public class C {
+    private int verticalMoves;
+    private int horizontalMoves;
+    private int size;
+    boolean[][] visited; 
+    char chessboard[][];
+
+    static class pair{
+        int first, second;
+        
+        public pair(int first, int second) 
+        {
+            this.first = first;
+            this.second = second;
+        }   
+    }
+
+    public C(int verticalMoves, int horizontalMoves, int size) {
+        this.verticalMoves = verticalMoves;
+        this.horizontalMoves = horizontalMoves;
+        this.size = size;
+        this.visited = new boolean[size][size];
+        this.chessboard = new char[size][size];
+    }
+
+    public boolean isLegalMove(int positionX, int positionY) {
+        return (positionX < size && positionY < size && positionX >= 0 && positionY >= 0);
+
+    }
+
+    public void colorPath(int startColor, Stack<pair> path){
+        int colorindex = startColor;
+        while (!path.empty()){
+            pair curr = path.pop();
+            int row = curr.first;
+            int col = curr.second;
+            //System.out.println("row " + row + " col " + col);
+
+            if (colorindex % 2 == 0){
+                chessboard[row][col] = 'X';
+                //System.out.println("X");
+
+            }
+            else{
+                chessboard[row][col] = 'O';
+                //System.out.println("O");
+            }
+            colorindex++;
+        }
+        /* for ( int i = 0; i<size; i++){
+            for ( int  j= 0; j<size; j++){
+                System.out.print(chessboard[i][j] + " ");
+            }
+            System.out.println();
+        } */
+        
+        /* System.out.println();
+        System.out.println(); */
+
+    }
+
+    public boolean DFS(int row, int col){
+
+        Stack<pair> st = new Stack<pair>();
+        Stack <pair> path = new Stack<pair>();
+        st.push(new pair(row, col));
+
+        //visited[row][col] = true;
+ 
+
+        while (!st.empty()) {
+            // Pop the top pair
+            pair curr = st.pop();
+            
+            row = curr.first;
+            col = curr.second;
+
+            if (visited[row][col] == true){
+                continue;
+            }
+
+            visited[row][col] = true;
+            path.push(curr);
+
+            int[][] moves = possibleMoves(row, col);
+
+            //if no legal moves we have reached an end point, 
+            boolean reachedEnd = true;
+            
+            //System.out.println("pushing " + row + " " + col + "\n");
+            System.out.println("current square " + row + " "+ col);
+            for (int i = 0; i <moves.length; i++) {
+                if(isLegalMove(moves[i][0], moves[i][1])){
+                    System.out.println("possible moves " + moves[i][0] + " " + moves[i][1] + " visited " + visited[moves[i][0]][moves[i][1]]);
+                }
+            }
+            System.out.println();
+        
+
+            for (int i = 0; i <moves.length; i++) {
+
+                if (isLegalMove(moves[i][0], moves[i][1])) { 
+                    //System.out.println("legal move " + moves[i][0] + " " + moves[i][1]);
+
+                     
+                   if (visited[moves[i][0]][moves[i][1]] == false){ //unvisited square   
+                        st.push(new pair(moves[i][0], moves[i][1]));                  
+                        reachedEnd = false;  
+                    }                  
+                      
+
+                    else{ //visited square
+
+                        if (chessboard[moves[i][0]][moves[i][1]] == 'X') {
+                            if (chessboard[row][col] == 'X'){
+                                //System.out.println("Ahaaaaaa X");
+                            // return false;
+                            }
+                            colorPath(1, path);
+                            path = new Stack<pair>();
+                            reachedEnd = false;
+                        }
+                        else if (chessboard[moves[i][0]][moves[i][1]] == '0'){
+                            if (chessboard[row][col] == '0'){
+                                //System.out.println("Ahaaaaaa O");
+                                //return false;
+                            }
+                            colorPath(0, path);
+                            path = new Stack<pair>();
+                            reachedEnd = false;
+                        }         
+                    }                
+                    
+                }   
+            }
+            if (reachedEnd){ //if no legal moves we have reached an end point,
+                System.out.println("reached end");
+                colorPath(0, path);
+                path = new Stack<pair>();
+            }    
+        }
+        return true;
+    }
+
+    
+
+    public int[][] possibleMoves(int positionX, int positionY) {
+        int possibleMoves[][] = new int[8][2];
+        possibleMoves[0][0] = positionX + verticalMoves;
+        possibleMoves[0][1] = positionY + horizontalMoves;
+
+        possibleMoves[1][0] = positionX + verticalMoves;
+        possibleMoves[1][1] = positionY - horizontalMoves;
+
+        possibleMoves[2][0] = positionX - verticalMoves;
+        possibleMoves[2][1] = positionY + horizontalMoves;
+
+        possibleMoves[3][0] = positionX - verticalMoves;
+        possibleMoves[3][1] = positionY - horizontalMoves;
+
+        possibleMoves[4][0] = positionX + horizontalMoves;
+        possibleMoves[4][1] = positionY + verticalMoves;
+
+        possibleMoves[5][0] = positionX + horizontalMoves;
+        possibleMoves[5][1] = positionY - verticalMoves;
+
+        possibleMoves[6][0] = positionX - horizontalMoves;
+        possibleMoves[6][1] = positionY + verticalMoves;
+
+        possibleMoves[7][0] = positionX - horizontalMoves;
+        possibleMoves[7][1] = positionY - verticalMoves;
+        
+        return possibleMoves;
+  
+    }
+    
+    public char[][] createChessboard(){
+        
+        for (int i=0; i<size; i++){
+            for (int j=0; j<size; j++){
+                if (!DFS(i, j)){
+                    System.out.println("No solution");
+                    return null;
+                }               
+            }
+        }
+        return chessboard;
+    }    
+
+    public static void main(String[] args){
+        int KMoves = 1;
+        int IMoves = 1;
+        int size= 4 ;
+        C chessboardGenerator = new C(KMoves, IMoves, size);
+        char[][] chessboard = chessboardGenerator.createChessboard();
+        if (chessboard == null){
+            System.out.println("No solution");
+        }
+        else{
+            System.out.println("Solution found");
+            for ( int i = 0; i<size; i++){
+                for ( int  j= 0; j<size; j++){
+                    System.out.print(chessboard[i][j] + " ");
+                }
+                System.out.println();
+            }
+        }
+        //print chessboard
+    }
+}
+
+
+
+
+
diff --git a/ChessboardGenerator$pair.class b/ChessboardGenerator$pair.class
new file mode 100644
index 0000000..dfa7e3f
Binary files /dev/null and b/ChessboardGenerator$pair.class differ
diff --git a/ChessboardGenerator.class b/ChessboardGenerator.class
new file mode 100644
index 0000000..874b1a1
Binary files /dev/null and b/ChessboardGenerator.class differ
diff --git a/ChessboardGenerator.java b/ChessboardGenerator.java
new file mode 100644
index 0000000..56acb3d
--- /dev/null
+++ b/ChessboardGenerator.java
@@ -0,0 +1,276 @@
+import java.util.*;
+
+public class ChessboardGenerator {
+    private int verticalMoves;
+    private int horizontalMoves;
+    private int size;
+    boolean[][] visited; 
+    char chessboard[][];
+
+    static class pair{
+        int first, second;
+        
+        public pair(int first, int second) 
+        {
+            this.first = first;
+            this.second = second;
+        }   
+    }
+
+    public ChessboardGenerator(int verticalMoves, int horizontalMoves, int size) {
+        this.verticalMoves = verticalMoves;
+        this.horizontalMoves = horizontalMoves;
+        this.size = size;
+        this.visited = new boolean[size][size];
+        this.chessboard = new char[size][size];
+    }
+
+    public boolean isLegalMove(int positionX, int positionY) {
+        return (positionX < size && positionY < size && positionX >= 0 && positionY >= 0);
+
+    }
+
+    public void colorPath(int startColor, Stack<pair> path){
+        int colorindex = startColor;
+        while (!path.empty()){
+            pair curr = path.pop();
+            int row = curr.first;
+            int col = curr.second;
+            //System.out.println("row " + row + " col " + col);
+
+            if (colorindex % 2 == 0){
+                chessboard[row][col] = 'X';
+                //System.out.println("X");
+
+            }
+            else{
+                chessboard[row][col] = 'O';
+                //System.out.println("O");
+            }
+            colorindex++;
+        }
+        /* for ( int i = 0; i<size; i++){
+            for ( int  j= 0; j<size; j++){
+                System.out.print(chessboard[i][j] + " ");
+            }
+            System.out.println();
+        } */
+        
+        /* System.out.println();
+        System.out.println(); */
+
+    }
+
+    public boolean DFS(int row, int col){
+
+        //System.out.println("DFS starting at " + row + " " + col + "");
+        
+        // Initialize a stack of pairs and
+        // push the starting cell into it
+        Stack<pair> st = new Stack<pair>();
+        Stack <pair> path = new Stack<pair>();
+        st.push(new pair(row, col));
+ 
+
+        while (!st.empty()) {
+            // Pop the top pair
+            pair curr = st.pop();
+            
+            row = curr.first;
+            col = curr.second;
+
+            int[][] moves = possibleMoves(row, col);
+
+        /*  //print possible moves
+            System.out.println("current square " + row + " "+ col);
+            for (int i = 0; i <moves.length; i++) {
+                /* System.out.println("possible move " + moves[i][0] + " " + moves[i][1] + " " + isLegalMove(moves[i][0], moves[i][1]) ); // + " visited " + visited[moves[i][0]][moves[i][1]]);
+                if (isLegalMove(moves[i][0], moves[i][1])){
+                    System.out.println("possible move " + moves[i][0] + " " + moves[i][1] + " visited " + visited[moves[i][0]][moves[i][1]]);
+                }
+            }
+            System.out.println(); */
+
+            //if no legal moves we have reached an end point, 
+            boolean reachedEnd = true;
+            
+
+            if (!visited[row][col] ){
+                visited[row][col] = true;
+                path.push(new pair(curr.first, curr.second));
+                //System.out.println("pushing " + row + " " + col + "\n");
+                System.out.println("current square " + row + " "+ col);
+
+                for (int i = 0; i <moves.length; i++) {
+                    if (isLegalMove(moves[i][0], moves[i][1])) {
+                        //System.out.println("current square " + row + col + "\n" +   "possible move " + moves[i][0] + " " + moves[i][1] + "\n");
+
+                        if (visited[moves[i][0]][moves[i][1]] == false){ //unvisited square
+                            //System.out.println("pushing " + moves[i][0] + " " + moves[i][1] + "\n");
+                            st.push(new pair(moves[i][0], moves[i][1]));
+                            reachedEnd = false;
+                        }
+
+                        else{ //visited square
+                            //System.out.println("The move is already visited and move is " + moves[i][0] + " " + moves[i][1] + "\n");
+                            if (chessboard[moves[i][0]][moves[i][1]] == 'X') {
+                                if (chessboard[row][col] == 'X'){
+                                    System.out.println("Ahaaaaaa X");
+                                // return false;
+                                }
+                                //System.out.print("path empty " + path.empty() + "\n");
+                            /*  if (path.empty()){
+                                    System.out.println("X: " + chessboard[row][col]);
+                                    if (chessboard[row][col] == 'X'){
+                                        System.out.println("error");
+                                        return false;
+                                    }
+                                } */
+                                colorPath(1, path);
+                                path = new Stack<pair>();
+                                reachedEnd = false;
+                            }
+                            else if (chessboard[moves[i][0]][moves[i][1]] == '0'){
+                                if (chessboard[row][col] == '0'){
+                                    System.out.println("Ahaaaaaa O");
+                                    //return false;
+                                }
+                                /* if (path.empty()){
+                                    System.out.println("0: " + chessboard[row][col]);
+                                    if (chessboard[row][col] == '0'){
+                                        System.out.println("error");
+                                        return false;
+                                    }
+                                } */
+                                colorPath(0, path);
+                                path = new Stack<pair>();
+                                reachedEnd = false;
+                            
+                            }         
+                        }                
+                        if (reachedEnd){ //if no legal moves we have reached an end point,
+                            //System.out.println("reached end");
+                            colorPath(0, path);
+                            //print stack
+                            path = new Stack<pair>();
+                        }    
+                    }   
+                }
+            }
+        }
+        return true;
+    }
+
+    /* public void BFS(int row, int col){
+     
+        // Stores indices of the matrix cells
+        Queue<move > q = new LinkedList<>();
+    
+        q.add(new move(row, col));
+        //System.out.println("The first move is: " + row + " " + col);
+        //System.out.println("visited length " + visited.length);
+        visited[row][col] = true;
+        chessboard[row][col] = 'X';
+    
+        // Iterate while the queue
+        // is not empty
+        while (!q.isEmpty())
+        {
+            move square = q.peek();
+            int x = square.first;
+            int y = square.second;
+    
+            q.remove();
+
+            int[][] moves = possibleMoves(x, y);
+
+            for (int i = 0; i <moves.length; i++) {
+                if (isLegalMove(moves[i][0], moves[i][1])) {
+                    if (visited[moves[i][0]][moves[i][1]] == false){
+                        q.add(new move(moves[i][0], moves[i][1]));
+                        visited[moves[i][0]][moves[i][1]] = true;
+                        chessboard[row][col] = 'X';
+                    }
+                    else {
+                        chessboard[row][col] = 'O';
+                        //if the move is already visited, then we need to check if the move is a parent of the current move
+                        //System.out.println("The move is already visited");
+                    }
+                    
+                }
+            }
+    
+        }
+    } */
+
+    public int[][] possibleMoves(int positionX, int positionY) {
+        int possibleMoves[][] = new int[8][2];
+        possibleMoves[0][0] = positionX + verticalMoves;
+        possibleMoves[0][1] = positionY + horizontalMoves;
+
+        possibleMoves[1][0] = positionX + verticalMoves;
+        possibleMoves[1][1] = positionY - horizontalMoves;
+
+        possibleMoves[2][0] = positionX - verticalMoves;
+        possibleMoves[2][1] = positionY + horizontalMoves;
+
+        possibleMoves[3][0] = positionX - verticalMoves;
+        possibleMoves[3][1] = positionY - horizontalMoves;
+
+        possibleMoves[4][0] = positionX + horizontalMoves;
+        possibleMoves[4][1] = positionY + verticalMoves;
+
+        possibleMoves[5][0] = positionX + horizontalMoves;
+        possibleMoves[5][1] = positionY - verticalMoves;
+
+        possibleMoves[6][0] = positionX - horizontalMoves;
+        possibleMoves[6][1] = positionY + verticalMoves;
+
+        possibleMoves[7][0] = positionX - horizontalMoves;
+        possibleMoves[7][1] = positionY - verticalMoves;
+        
+        return possibleMoves;
+  
+    }
+    
+    public char[][] createChessboard(){
+        
+        for (int i=0; i<size; i++){
+            for (int j=0; j<size; j++){
+                if (!DFS(i, j)){
+                    System.out.println("No solution");
+                    return null;
+                }               
+            }
+        }
+        return chessboard;
+    }    
+
+    public static void main(String[] args){
+        int KMoves = 1;
+        int IMoves = 1;
+        int size= 4 ;
+        ChessboardGenerator chessboardGenerator = new ChessboardGenerator(KMoves, IMoves, size);
+        char[][] chessboard = chessboardGenerator.createChessboard();
+        if (chessboard == null){
+            System.out.println("No solution");
+        }
+        else{
+            System.out.println("Solution found");
+            for ( int i = 0; i<size; i++){
+                for ( int  j= 0; j<size; j++){
+                    System.out.print(chessboard[i][j] + " ");
+                }
+                System.out.println();
+            }
+        }
+
+        //print chessboard
+        
+    }
+}
+
+
+
+
+
diff --git a/SomeFile.txt b/SomeFile.txt
new file mode 100644
index 0000000..b93e8b2
--- /dev/null
+++ b/SomeFile.txt
@@ -0,0 +1,3 @@
+Ahaaaaaa X
+No solution
+No solution
diff --git a/Test.class b/Test.class
new file mode 100644
index 0000000..d869109
Binary files /dev/null and b/Test.class differ
diff --git a/Test.java b/Test.java
new file mode 100644
index 0000000..1673235
--- /dev/null
+++ b/Test.java
@@ -0,0 +1,55 @@
+public class Test{
+
+
+    public void printChess(char[][] chess){
+        for (int i =0; i<chess.length; i++){
+            for (int j = 0; j<chess.length; j++){
+                System.out.print(chess[i][j] + " ");
+            }
+            System.out.println();
+        }
+        System.out.println();
+    }
+
+    public boolean testChess(int size, int iMoves, int kMoves){
+        ChessboardGenerator chess = new ChessboardGenerator(iMoves, kMoves, size);
+        char[][] chessboard = chess.createChessboard();
+
+        for (int i = 0; i <size; i++){
+            for (int j = 0; j<size; j++){
+                int [][] possibleMoves = chess.possibleMoves(i, j);
+                for (int k = 0; k<8; k++){
+                    if (possibleMoves[k][0] >= 0 && possibleMoves[k][0] < size && possibleMoves[k][1] >= 0 && possibleMoves[k][1] < size){
+                        if (chessboard[possibleMoves[k][0]][possibleMoves[k][1]] == chessboard[i][j]){
+                            System.out.println("x = " + i + " y = " + j );
+                            System.out.println();
+                            printChess(chessboard);
+                            return false;
+                        }
+                    }
+                }
+
+            }
+        }
+        return true;
+
+    }
+    
+
+    public static void main(String[] args) {
+        Test test = new Test();
+
+        int n = 8;
+        for (int i = 2; i <= n; i++) {
+            for (int j=1; j<i-1; j++ ){
+                for (int k = 1; k<i-1; k++){
+                    if (!test.testChess(i, j, k)){
+                        System.out.println("size = " + n + " iMoves = " + j + " kMoves = " + k);
+                    }
+                }
+            }
+        
+        }
+    }
+}
+
diff --git a/adk-labb3 b/adk-labb3
new file mode 160000
index 0000000..379a6d8
--- /dev/null
+++ b/adk-labb3
@@ -0,0 +1 @@
+Subproject commit 379a6d8e2736a0fb1339876fe4a814e2d77db313
diff --git a/mastarprov.java b/mastarprov.java
new file mode 100644
index 0000000..bcb1977
--- /dev/null
+++ b/mastarprov.java
@@ -0,0 +1,111 @@
+public class Graph {
+
+    private Set<Node> nodes = new HashSet<>();
+    
+    public void addNode(Node nodeA) {
+        nodes.add(nodeA);
+    }
+
+    // getters and setters 
+}
+
+public class Node {
+    
+    private String name;
+    
+    private List<Node> shortestPath = new LinkedList<>();
+    
+    private Integer distance = Integer.MAX_VALUE;
+    
+    Map<Node, Integer> adjacentNodes = new HashMap<>();
+
+    public void addDestination(Node destination, int distance) {
+        adjacentNodes.put(destination, distance);
+    }
+ 
+    public Node(String name) {
+        this.name = name;
+    }
+    
+    // getters and setters
+}
+
+public static Graph calculateShortestPathFromSource(Graph graph, Node source) {
+    source.setDistance(0);
+
+    Set<Node> settledNodes = new HashSet<>();
+    Set<Node> unsettledNodes = new HashSet<>();
+
+    unsettledNodes.add(source);
+
+    while (unsettledNodes.size() != 0) {
+        Node currentNode = getLowestDistanceNode(unsettledNodes);
+        unsettledNodes.remove(currentNode);
+        for (Entry < Node, Integer> adjacencyPair: 
+          currentNode.getAdjacentNodes().entrySet()) {
+            Node adjacentNode = adjacencyPair.getKey();
+            Integer edgeWeight = adjacencyPair.getValue();
+            if (!settledNodes.contains(adjacentNode)) {
+                calculateMinimumDistance(adjacentNode, edgeWeight, currentNode);
+                unsettledNodes.add(adjacentNode);
+            }
+        }
+        settledNodes.add(currentNode);
+    }
+    return graph;
+}
+
+
+private static Node getLowestDistanceNode(Set < Node > unsettledNodes) {
+    Node lowestDistanceNode = null;
+    int lowestDistance = Integer.MAX_VALUE;
+    for (Node node: unsettledNodes) {
+        int nodeDistance = node.getDistance();
+        if (nodeDistance < lowestDistance) {
+            lowestDistance = nodeDistance;
+            lowestDistanceNode = node;
+        }
+    }
+    return lowestDistanceNode;
+}
+private static void CalculateMinimumDistance(Node evaluationNode,
+  Integer edgeWeigh, Node sourceNode) {
+    Integer sourceDistance = sourceNode.getDistance();
+    if (sourceDistance + edgeWeigh < evaluationNode.getDistance()) {
+        evaluationNode.setDistance(sourceDistance + edgeWeigh);
+        LinkedList<Node> shortestPath = new LinkedList<>(sourceNode.getShortestPath());
+        shortestPath.add(sourceNode);
+        evaluationNode.setShortestPath(shortestPath);
+    }
+}
+
+/* Node nodeA = new Node("A");
+Node nodeB = new Node("B");
+Node nodeC = new Node("C");
+Node nodeD = new Node("D"); 
+Node nodeE = new Node("E");
+Node nodeF = new Node("F");
+
+nodeA.addDestination(nodeB, 10);
+nodeA.addDestination(nodeC, 15);
+
+nodeB.addDestination(nodeD, 12);
+nodeB.addDestination(nodeF, 15);
+
+nodeC.addDestination(nodeE, 10);
+
+nodeD.addDestination(nodeE, 2);
+nodeD.addDestination(nodeF, 1);
+
+nodeF.addDestination(nodeE, 5);
+
+Graph graph = new Graph();
+
+graph.addNode(nodeA);
+graph.addNode(nodeB);
+graph.addNode(nodeC);
+graph.addNode(nodeD);
+graph.addNode(nodeE);
+graph.addNode(nodeF);
+
+graph = Dijkstra.calculateShortestPathFromSource(graph, nodeA); */
\ No newline at end of file
diff --git a/python.py b/python.py
new file mode 100644
index 0000000..695ca85
--- /dev/null
+++ b/python.py
@@ -0,0 +1,63 @@
+# Dijkstra's Algorithm in Python
+
+
+import sys
+
+# Providing the graph
+vertices = [[0, 0, 1, 1, 0, 0, 0],
+            [0, 0, 1, 0, 0, 1, 0],
+            [1, 1, 0, 1, 1, 0, 0],
+            [1, 0, 1, 0, 0, 0, 1],
+            [0, 0, 1, 0, 0, 1, 0],
+            [0, 1, 0, 0, 1, 0, 1],
+            [0, 0, 0, 1, 0, 1, 0]]
+
+edges = [[0, 0, 1, 2, 0, 0, 0],
+         [0, 0, 2, 0, 0, 3, 0],
+         [1, 2, 0, 1, 3, 0, 0],
+         [2, 0, 1, 0, 0, 0, 1],
+         [0, 0, 3, 0, 0, 2, 0],
+         [0, 3, 0, 0, 2, 0, 1],
+         [0, 0, 0, 1, 0, 1, 0]]
+
+# Find which vertex is to be visited next
+def to_be_visited():
+    global visited_and_distance
+    v = -10
+    for index in range(num_of_vertices):
+        if visited_and_distance[index][0] == 0 \
+            and (v < 0 or visited_and_distance[index][1] <=
+                 visited_and_distance[v][1]):
+            v = index
+    return v
+
+
+num_of_vertices = len(vertices[0])
+
+visited_and_distance = [[0, 0]]
+for i in range(num_of_vertices-1):
+    visited_and_distance.append([0, sys.maxsize])
+
+for vertex in range(num_of_vertices):
+
+    # Find next vertex to be visited
+    to_visit = to_be_visited()
+    for neighbor_index in range(num_of_vertices):
+
+        # Updating new distances
+        if vertices[to_visit][neighbor_index] == 1 and \
+                visited_and_distance[neighbor_index][0] == 0:
+            new_distance = visited_and_distance[to_visit][1] \
+                + edges[to_visit][neighbor_index]
+            if visited_and_distance[neighbor_index][1] > new_distance:
+                visited_and_distance[neighbor_index][1] = new_distance
+        
+        visited_and_distance[to_visit][0] = 1
+
+i = 0
+
+# Printing the distance
+for distance in visited_and_distance:
+    print("Distance of ", chr(ord('a') + i),
+          " from source vertex: ", distance[1])
+    i = i + 1
\ No newline at end of file