Adds DFS, BFS and Dijkstra's algorithm solutions for "The Maze II"

src/main/java/algorithms/curated170/medium/maze2/TheMazeIIBFS.java

@@ -0,0 +1,59 @@
+package algorithms.curated170.medium.maze2;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+
+public class TheMazeIIBFS {
+int[][] maze;
+
+    public int shortestDistance(int[][] maze, int[] start, int[] dest) {
+        this.maze = maze;
+
+        int[][] distance = new int[maze.length][maze[0].length];
+        for (int[] row: distance)
+            Arrays.fill(row, Integer.MAX_VALUE);
+
+        distance[start[0]][start[1]] = 0;
+
+        int[][] directions = {{0, -1}, {1, 0}, {-1, 0}, {0, 1}};
+
+        Queue <int[]> queue = new LinkedList<>();
+        queue.add(start);
+        while (!queue.isEmpty()) {
+
+            int[] s = queue.remove();
+
+            for (int[] dir: directions) {
+                int x = s[0] + dir[0];
+                int y = s[1] + dir[1];
+                int count = 0;
+                while (canPass(x, y)) {
+                    x += dir[0];
+                    y += dir[1];
+                    count++;
+                }
+
+                int prx = x - dir[0];
+                int pry = y - dir[1];
+
+                int total = distance[s[0]][s[1]] + count; 
+
+                if ( total < distance[prx][pry]) {
+                    distance[prx][pry] = total;
+                    queue.add(new int[] {prx, pry});
+                }
+            }
+        }
+        return distance[dest[0]][dest[1]] == Integer.MAX_VALUE ? -1 : distance[dest[0]][dest[1]];
+    }
+
+    boolean canPass(int nextX, int nextY) {
+        return (nextX >= 0 && nextY >= 0
+                && nextX < maze.length
+                && nextY < maze[0].length
+                && maze[nextX][nextY] == 0);
+
+    }
+}

src/main/java/algorithms/curated170/medium/maze2/TheMazeIIDFS.java

@@ -0,0 +1,85 @@
+package algorithms.curated170.medium.maze2;
+
+import java.util.Arrays;
+
+
+public class TheMazeIIDFS {
+
+
+    int[][] maze;
+    int[] destination;
+    int[][] distance;
+
+    int[][] directions = {{0, -1}, {1, 0}, {-1, 0}, {0, 1}};
+
+    public int shortestDistance(int[][] maze, int[] start, int[] dest) {
+
+       this.maze = maze;
+       this.destination = dest;
+       this.distance = new int[maze.length][maze[0].length];
+
+        for (int[] row: distance)
+            Arrays.fill(row, Integer.MAX_VALUE);
+
+        distance[start[0]][start[1]] = 0;
+
+        dfs(start[0], start[1], -1);
+
+        return distance[dest[0]][dest[1]] == Integer.MAX_VALUE ? -1 : distance[dest[0]][dest[1]];
+    }
+
+    public void dfs(int x, int y, int arrivedFrom) {
+
+
+        if (x == destination[0] && y == destination[1]) {
+            return;
+        }
+
+
+        for (int i = 0; i<4; i++){
+
+            if((i == 0 && arrivedFrom == 3)
+                || (i == 1 && arrivedFrom == 2)
+                || (i == 2 && arrivedFrom == 1)
+                || (i == 3 && arrivedFrom == 0))
+                {
+                    continue;
+                }
+
+            int dirx = directions[i][0];
+            int diry = directions[i][1];
+
+            int nextX = x + dirx;
+            int nextY = y + diry;
+
+            int count = 0;
+
+           while (canPass(nextX, nextY) ) {
+
+                nextX += dirx;
+                nextY += diry;
+                count++;
+            }
+
+                int prx = nextX - dirx;
+                int pry = nextY - diry;
+
+                int total = distance[x][y] + count; 
+
+                if (total < distance[prx][pry]) {
+
+                      distance[prx][pry] = total;
+                      dfs(prx, pry, i);
+                }
+
+        }
+    }
+      boolean canPass(int nextX, int nextY) {
+        return (nextX >= 0 && nextY >= 0
+                && nextX < maze.length
+                && nextY < maze[0].length
+                && maze[nextX][nextY] == 0);
+
+    }
+
+}

src/main/java/algorithms/curated170/medium/maze2/TheMazeIIDijkstra.java

@@ -0,0 +1,74 @@
+package algorithms.curated170.medium.maze2;
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+
+public class TheMazeIIDijkstra {
+    final static int VISITED = -1;
+    int[][] maze;
+  public int shortestDistance(int[][] maze, int[] start, int[] dest) {
+
+        this.maze = maze;
+
+        return dijkstra(start, dest); 
+    }
+
+ public int dijkstra( int[] start, int[] destination) {
+
+        PriorityQueue<int[]> pq = new PriorityQueue<>((p1, p2) -> p1[2] - p2[2]); 
+        int[][] directions = {{0, -1}, {1, 0}, {-1, 0}, {0, 1}};
+
+        pq.add(new int[]{start[0], start[1], 0});
+        while (!pq.isEmpty()) {
+
+            int[] startPoint = pq.poll();
+
+            int x = startPoint[0];
+            int y = startPoint[1];
+
+            if(maze[x][y]==-1) continue;
+
+            maze[x][y] = VISITED;   
+            if (x == destination[0] && y == destination[1]) {
+                return startPoint[2];
+            }
+
+
+           for (int[] dir: directions) {
+                int dirx = dir[0];
+                int diry = dir[1];
+
+                int nextX = x;
+                int nextY = y;
+
+                int currentDistance =  startPoint[2];
+
+                while (canPass(nextX, nextY)) {
+                    nextX += dirx;
+                    nextY += diry;
+                    currentDistance++;
+                }
+
+                nextX -= dirx;
+                nextY -= diry;
+                currentDistance--;
+
+
+                 if(maze[nextX][nextY]!=-1) {
+
+                      pq.add(new int[]{nextX, nextY, currentDistance});
+                }
+            }
+        }
+        return VISITED;
+    }
+
+     boolean canPass(int nextX, int nextY) {
+            return (nextX >= 0 && nextY >= 0
+                    && nextX < maze.length
+                    && nextY < maze[0].length
+                    && maze[nextX][nextY] != 1);
+
+        }
+}