Maze solver

Adrian Catalan · Adrian Catalan · commit aa452cdd44c9 · 2017-06-10T21:06:00.000+02:00
diff --git a/README.md b/README.md
@@ -22,6 +22,20 @@ Depth-first search (DFS) is an algorithm for traversing or searching tree or gra
 
 Una Búsqueda en profundidad (en inglés DFS o Depth First Search) es un algoritmo que permite recorrer todos los nodos de un grafo o árbol (teoría de grafos) de manera ordenada, pero no uniforme. Su funcionamiento consiste en ir expandiendo todos y cada uno de los nodos que va localizando, de forma recurrente, en un camino concreto. Cuando ya no quedan más nodos que visitar en dicho camino, regresa (Backtracking), de modo que repite el mismo proceso con cada uno de los hermanos del nodo ya procesado.
 
+****Maze Solver****
+
+***[en_GB]***
+
+There are a number of different maze solving algorithms, that is, automated methods for the solving of mazes. The random mouse, wall follower, Pledge, and Trémaux's algorithms are designed to be used inside the maze by a traveler with no prior knowledge of the maze, whereas the dead-end filling and shortest path algorithms are designed to be used by a person or computer program that can see the whole maze at once.
+
+Mazes containing no loops are known as "simply connected", or "perfect" mazes, and are equivalent to a tree in graph theory. Thus many maze solving algorithms are closely related to graph theory. Intuitively, if one pulled and stretched out the paths in the maze in the proper way, the result could be made to resemble a tree.
+
+***[es_ES]***
+
+Hay una serie de algoritmos de resolución de laberintos. Con un previo conocimiento del laberinto, busca un trayecto más corto y están diseñados para ser utilizados por una persona o un programa informático que pueda ver todo el laberinto a la vez.
+Los laberintos que no contienen bucles se conocen como laberintos "simplemente conectados" o "perfectos", y son equivalentes a un árbol en la teoría de grafos. Así, muchos algoritmos de resolución de laberintos están estrechamente relacionados con la teoría de grafos.
+
+
 **03 - Shortest Path**
 
 **04 - Artificial Intelligence**
diff --git a/src/main/java/mazeSolver/App.java b/src/main/java/mazeSolver/App.java
@@ -0,0 +1,19 @@
+package mazeSolver;
+
+
+/**
+ * Created by Adrian on 10/06/2017.
+ */
+public class App {
+
+    /**
+     * Maze solver Main
+     * @param args
+     */
+    public static void main (String[] args) {
+        FileReader fileReader = new FileReader("C:\\Users\\Adrian\\IdeaProjects\\algorithm\\src\\main\\java\\mazeSolver\\map.txt",4, 4);
+        fileReader.parseFile();
+        MazeSolver mazeSolver = new MazeSolver(fileReader.getMap(),fileReader.getStartPositionRow(), fileReader.getStartPositionCol());
+        mazeSolver.findWayOut();
+    }
+}
diff --git a/src/main/java/mazeSolver/FileReader.java b/src/main/java/mazeSolver/FileReader.java
@@ -0,0 +1,63 @@
+package mazeSolver;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+/**
+ * Created by Adrian on 10/06/2017.
+ */
+public class FileReader {
+    private int[][] map;
+    private String fileName;
+    private int numOfRows;
+    private int numOfColums;
+    private int startPositionCol;
+    private int startPositionRow;
+
+    public FileReader(String fileName, int numOfRows, int numOfColums) {
+        this.fileName = fileName;
+        this.numOfRows = numOfRows;
+        this.numOfColums = numOfColums;
+        this.map = new int[numOfRows][numOfColums];
+    }
+
+    /**
+     * Parse file with routes
+     */
+    public void parseFile() {
+
+        Scanner scanner = null;
+        try {
+            scanner = new Scanner(new File(this.fileName));
+
+            for (int i = 0; i < this.numOfRows; i++) {
+                for (int j = 0; j < this.numOfColums; j++) {
+                    map[i][j] = scanner.nextInt();
+                    if (map[i][j] == 2) {
+                        startPositionCol = j;
+                        startPositionRow = i;
+
+                    }
+                }
+            }
+            scanner.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public int[][] getMap() {
+        return map;
+    }
+
+    public int getStartPositionCol() {
+        return startPositionCol;
+    }
+
+    public int getStartPositionRow() {
+        return startPositionRow;
+    }
+}
+
+
diff --git a/src/main/java/mazeSolver/MazeSolver.java b/src/main/java/mazeSolver/MazeSolver.java
@@ -0,0 +1,70 @@
+package mazeSolver;
+
+/**
+ * Created by Adrian on 10/06/2017.
+ */
+public class MazeSolver {
+    private int[][] mazeMap;
+    private boolean[][] visited;
+    private int startPositionCol;
+    private int startPositionRow;
+
+    public MazeSolver(int[][] mazeMap, int startPositionCol, int startPositionRow) {
+        this.mazeMap = mazeMap;
+        this.visited = new boolean[mazeMap.length][mazeMap.length];
+        this.startPositionCol = startPositionCol;
+        this.startPositionRow = startPositionRow;
+    }
+
+
+    /**
+     * Find way
+     */
+    public void findWayOut() {
+        try {
+            dfs(startPositionRow, startPositionCol + 1);
+            System.out.println("No solution found...");
+        } catch (RuntimeException e){
+            System.out.println("ROUTE FOUND TO EXIT!!!");
+        }
+    }
+
+    /**
+     * Find correct route
+     * @param i
+     * @param j
+     */
+    private void dfs(int i, int j) {
+        System.out.println("Visiting i = "+i+" j= "+j);
+
+        if (this.mazeMap[i][j] == 3) {
+            //EXIT FOUND
+            throw new RuntimeException();
+        }
+
+        int endOfMap = this.mazeMap.length - 1;
+
+        if(visited[i][j]) {
+            // position visited
+            return;
+        } else if (i < 0 || i >= endOfMap) {
+            //Out of map
+            return;
+        } else if (j < 0 || j >= endOfMap) {
+            //Out of map
+            return;
+        } else if (this.mazeMap[i][j] == 1) {
+            // Route not valid.
+            return;
+        } else {
+            // Route valid.
+            this.visited[i][j] = true;
+
+            dfs(i+1,j); //  DOWN
+            dfs(i,j+1); // RIGHT
+            dfs(i,j-1); // LEFT
+            dfs(i-1,j); // UP
+
+        }
+    }
+}
diff --git a/src/main/java/mazeSolver/map.txt b/src/main/java/mazeSolver/map.txt
@@ -0,0 +1,5 @@
+1 1 1 1 1
+1 2 0 1 1
+1 0 0 1 1
+1 0 0 3 1
+1 1 1 1 1
