Shortest Path in a Binary Maze in Java

In the input, there is a MxN matrix with elements that may either be 0 or 1. The shortest route between a given source cell and a destination address cell must be found. A cell may only be used to make the route if its value is 1.

Example:

Input: mat[ROW][COL] = {{1,0,1,1,1},

{1,0,1,0,1},

{1,1,1,0,1},

{0,0,0,0,1},

{1,1,1,0,1}};

The source cell is (0,0) and the destination cell is (4,4).

Output: Shortest Path: 12

Approach: Using Depth-first search (DFS)

The maze is assumed to have walls represented by the value 1, and open spaces represented by the value 0. The algorithm starts at the top-left corner of the maze and explores all possible paths through the maze using recursion until it reaches the bottom-right corner. It keeps track of the length of the path found so far and updates the minimum path length when it reaches the destination. If no path is found, it returns -1.

Filename: ShortestPathDFS.java

// A Java program to find the shortest path in a maze using DFS algorithm
import java.util.*;
public class ShortestPathDFS {
// Declare a private variable to store the shortest path
private static int shortestPath;

// Method to find the shortest path in a given maze
public static int findShortestPath(int[][] maze) {
    
    // Check if the maze is empty or null, if so return 0
    if (maze == null || maze.length == 0 || maze[0].length == 0) {
        return 0;
    }
    
    // Initialize shortestPath to the maximum possible value
    shortestPath = Integer.MAX_VALUE;
    
    // Initialize a boolean array to keep track of visited cells
    boolean[][] visited = new boolean[maze.length][maze[0].length];
    
    // Invoke the dfs() method to find the shortest path
    dfs(maze, visited, 0, 0, 0);
    
    // Return the shortest path, or 0 if it was not found
    return shortestPath == Integer.MAX_VALUE ? 0 : shortestPath;
}

// Method to perform DFS traversal to find the shortest path
private static void dfs(int[][] maze, boolean[][] visited, int row, int col, int distance) {
    
    // Check if the current cell is out of bounds, a wall or has already been visited
    if (row < 0 || row >= maze.length || col < 0 || col >= maze[0].length || maze[row][col] == 0 || visited[row][col]) {
        return;
    }
    
    // Check if the current cell is the destination, if so update the shortestPath variable and return
    if (row == maze.length - 1 && col == maze[0].length - 1) {
        shortestPath = Math.min(shortestPath, distance);
        return;
    }
    
    // Mark the current cell as visited
    visited[row][col] = true;
    
    // Explore all possible paths from the current cell
    dfs(maze, visited, row + 1, col, distance + 1);
    dfs(maze, visited, row - 1, col, distance + 1);
    dfs(maze, visited, row, col + 1, distance + 1);
    dfs(maze, visited, row, col - 1, distance + 1);
    
    // Unmark the current cell as visited
    visited[row][col] = false;
}

// Main method to test the code
public static void main(String[] args) {
    
    // Initialize a 2D array to represent the maze
    int[][] maze = {
        {1, 0, 1, 1, 1},
        {1, 0, 1, 0, 1},
        {1, 1, 1, 0, 1},
        {0, 0, 0, 0, 1},
        {1, 1, 1, 0, 1}
    };
    
    // Find the shortest path in the maze using DFS and print it
    int shortest = findShortestPath(maze);
    System.out.println("Shortest Path using DFS: " + shortest);
}
}

Output:

Shortest Path using DFS: 12

Explanation: The given Java program implements the Depth First Search (DFS) algorithm to find the shortest path in a maze represented by a 2D array of integers. The program takes the maze as input and initializes a boolean array to keep track of visited cells. It starts exploring the maze from the top-left cell (0,0) and recursively traverses all possible paths until it reaches the bottom-right cell (maze.length-1, maze[0].length-1) or a dead end. During traversal, the program increments the distance by 1 for each visited cell and updates the shortestPath variable if it finds a shorter path to the destination cell. Finally, it returns the shortestPath value or 0 if no path exists. The program also contains a main method to demonstrate the functionality of the findShortestPath method by passing the given input maze and printing the shortest path using DFS.

Complexity Analysis: The time complexity of this implementation is O(m * n), where m is the number of rows and n is the number of columns in the input maze. The reason for this is that, in the DFS algorithm, each cell in the maze is visited at most once.

The space complexity is also O(m * n), due to the boolean visited array that is created to keep track of visited cells. Additionally, the recursive nature of the DFS algorithm can lead to a large stack space usage in the worst case. However, since the maze in this implementation is relatively small, this is not a significant concern.

Overall, this implementation is simple and easy to understand, but it may not be the most efficient for larger mazes. Other algorithms, such as Dijkstra's algorithm or A* search, may provide better performance for larger and more complex mazes.

Approach: Using Dijkstra's algorithm

Filename: BinaryMazeShortestPath.java

import java.util.*;
public class DijkstraShortestPath {
// constant representing infinity
static final int INF = Integer.MAX_VALUE;

public static int shortestPath(int[][] maze, int startX, int startY, int endX, int endY) {
    int n = maze.length;
    int m = maze[0].length;

    // arrays representing the directions for moving in the maze
    int[] dx = {0, 0, 1, -1};
    int[] dy = {1, -1, 0, 0};

    // 2D arrays representing the shortest distances and visited cells
    int[][] dist = new int[n][m];
    boolean[][] visited = new boolean[n][m];

    // initialize all distances to infinity except the starting cell
    for (int i = 0; i < n; i++) {
        Arrays.fill(dist[i], INF);
    }
    dist[startX][startY] = 0;

    // create a priority queue for storing cells to visit
    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
    pq.offer(new int[]{startX, startY, 0});

    // iterate while there are cells to visit
    while (!pq.isEmpty()) {
        // remove the cell with the smallest distance from the priority queue
        int[] curr = pq.poll();
        int x = curr[0];
        int y = curr[1];
        int d = curr[2];

        // if the cell has already been visited, skip it
        if (visited[x][y]) {
            continue;
        }

        // mark the cell as visited
        visited[x][y] = true;

        // if we've reached the end cell, return the shortest distance
        if (x == endX && y == endY) {
            return d;
        }

        // iterate over the neighboring cells and update their distances if necessary
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && maze[nx][ny] == 1 && !visited[nx][ny]) {
                int nd = d + 1;
                if (nd < dist[nx][ny]) {
                    dist[nx][ny] = nd;
                    pq.offer(new int[]{nx, ny, nd});
                }
            }
        }
    }

    // if we couldn't reach the end cell, return -1
    return -1;
}

public static void main(String[] args) {
    int[][] maze = {
            {1, 0, 1, 1, 1},
            {1, 0, 1, 0, 1},
            {1, 1, 1, 0, 1},
            {0, 0, 0, 0, 1},
            {1, 1, 1, 0, 1}
    };
    int startX = 0;
    int startY = 0;
    int endX = 4;
    int endY = 4;

    // calculate the shortest path in the maze
    int shortestPath = shortestPath(maze, startX, startY, endX, endY);

    // print the result
    System.out.println("Shortest path length: " + shortestPath);
}
}

Output:

Shortest path length: 12

Explanation: The above code implements Dijkstra's algorithm to find the shortest path between two points in a maze. The maze is represented as a 2D array where 1s represent paths and 0s represent walls. The algorithm uses a priority queue to select the unvisited cell with the minimum distance from the source cell.

The shortestPath function takes the maze, start coordinates (startX and startY) and end coordinates (endX and endY) as input and returns the shortest path length between the start and end points.

The function initializes the dist array to infinity for all cells except the start cell, which is set to 0. It also initializes a visited array to keep track of visited cells.

The algorithm then starts by adding the start cell to the priority queue with distance 0. It continues to loop until the priority queue is empty or the end cell is reached. In each iteration, the cell with the smallest distance is selected from the queue and its neighbors are explored. The distance of each neighbor is updated if a shorter path is found and the neighbor is added to the priority queue.

The method returns -1 if the end cell cannot be reached or the shortest path length if the end cell is reached.

The main method creates a maze and calls the shortestPath function with the start and end coordinates. The length of the shortest path is printed to the console.

Complexity Analysis: The time complexity of the Dijkstra's algorithm implementation in the given code is O(N^2 log N), where N is the number of nodes (or cells) in the input grid. The reason for this is that we use a priority queue to process the adjacent nodes of each node in the grid, taking at most O(log N) time per insertion or removal, and we ensure that each node is processed only once. In the worst case, all nodes are visited, and therefore the overall time complexity is O(N^2 log N). The space complexity is also O(N^2) because the algorithm stores the distance and visited status of each node in two separate N x N arrays.

Approach: Using Breadth-First Search Algorithm

Breadth-First Search (BFS) is one of the most common algorithms used to find the shortest path in a binary maze. It works by exploring all the neighbors of a cell before moving on to their neighbors.

Filename: ShortestPathBinaryMaze.java

import java.util.*;

public class ShortestPathBinaryMaze {
// A class to store the coordinates of a matrix cell
static class Point {
    int row, col;

    public Point(int row, int col) {
        this.row = row;
        this.col = col;
    }
}

// Check if a cell (row, col) is a valid cell or not
static boolean isValid(int[][] maze, int row, int col) {
    int rows = maze.length, cols = maze[0].length;
    return (row >= 0 && row < rows && col >= 0 && col < cols && maze[row][col] == 1);
}

// Find the shortest path in binary maze from source to destination using BFS
static int shortestPathBFS(int[][] maze, Point src, Point dest) {
    int rows = maze.length, cols = maze[0].length;

    // Array to store the distance of each cell from the source
    int[][] dist = new int[rows][cols];
    for (int[] row : dist) {
        Arrays.fill(row, Integer.MAX_VALUE);
    }

    // The source cell has distance of 0 from itself
    dist[src.row][src.col] = 0;

    // Create a queue for BFS
    Queue<Point> q = new LinkedList<>();
    q.add(src); // Enqueue the source cell

    // Arrays to get row and column numbers of 4 neighbors of a cell
    int[] rowNum = {-1, 0, 1, 0};
    int[] colNum = {0, -1, 0, 1};

    // Perform BFS
    while (!q.isEmpty()) {
        Point curr = q.poll();

        // If we have reached the destination cell, we are done
        if (curr.row == dest.row && curr.col == dest.col) {
            return dist[curr.row][curr.col];
        }

        // Visit all neighbors of the current cell
        for (int i = 0; i < 4; i++) {
            int row = curr.row + rowNum[i];
            int col = curr.col + colNum[i];

            // If the adjacent cell is valid, has a path, and not visited yet, enqueue it
            if (isValid(maze, row, col) && dist[row][col] > dist[curr.row][curr.col] + 1) {
                // Update the distance of the neighbor cell from the source
                dist[row][col] = dist[curr.row][curr.col] + 1;
                q.add(new Point(row, col)); // Enqueue the neighbor cell
            }
        }
    }

    // Destination cannot be reached
    return -1;
}

// Driver code
public static void main(String[] args) {
    int[][] maze = {
        {1, 0, 1, 1, 1},
        {1, 0, 1, 0, 1},
        {1, 1, 1, 0, 1},
        {0, 0, 0, 0, 1},
        {1, 1, 1, 0, 1}};

// create a starting point for the path
Point src = new Point(0, 0);

// create an ending point for the path
Point dest = new Point(4, 4);

// find the shortest path in the binary maze from the starting point to the ending point using BFS
int shortestPath = shortestPathBFS(maze, src, dest);

// if the shortest path is not possible, print a message
if (shortestPath == -1) {
System.out.println("Destination cannot be reached");
}
// otherwise, print the length of the shortest path
else {
System.out.println("Shortest path length: " + shortestPath);
}
}
}

Output:

Shortest path length: 12

Explanation: The above Java code implements the breadth-first search (BFS) algorithm to find the shortest path in a binary maze from a source point to a destination point. The code defines a nested class Point to store the coordinates of a matrix cell, and uses a 2D integer array to represent the maze where 1's indicate valid cells and 0's indicate blocked cells. The isValid function checks if a cell is within the maze bounds and is a valid cell to traverse. The shortestPathBFS function uses a queue to perform BFS on the maze, starting from the source point and stopping when the destination point is reached. The distance of each cell from the source is stored in a 2D integer array dist, and the function returns the distance of the destination point from the source, or -1 if the destination point cannot be reached.

Complexity Analysis

Time Complexity Analysis: The time complexity of the BFS algorithm is O(V+E), where V is the number of vertices and E is the number of edges. In this case, the number of vertices is equal to the number of cells in the matrix, which is rows x cols. The number of edges in the worst case can be considered as O(V), since each cell can have at most 4 edges (up, down, left, right) and in the worst case, all cells are connected to each other. Therefore, the time complexity of the algorithm is O(rows x cols), since V = rows x cols and E = O(V).

Space Complexity Analysis: The space complexity of the algorithm is O(V), where V is the number of vertices, i.e., rows x cols. The reason for this is that we keep track of the distance of each cell from the source by maintaining a distance matrix with dimensions of rows by cols. Additionally, we are using a queue to store the cells to be visited, which can have at most V elements in the worst case.

Overall, the time complexity of the algorithm is O(rows x cols) and the space complexity is O(rows x cols).

Approach: Using Backtracking

Backtracking algorithms work by recursively exploring the search space, marking each candidate solution as either a success or a failure, and then undoing each choice until a valid solution is found or all possibilities have been exhausted.

Implementation:

Filename: ShortestPathBacktracking.java

public class ShortestPathBacktracking {

    public static int findShortestPath(int[][] maze) {
        // Get the number of rows and columns in the maze
        int rows = maze.length;
        int cols = maze[0].length;

        // Create a boolean matrix to track visited cells
        boolean[][] visited = new boolean[rows][cols];

        // Initialize the shortest path to a very large number
        int[] shortestPath = {Integer.MAX_VALUE};

        // Call the recursive helper function to find the shortest path
        findShortestPath(maze, visited, 0, 0, rows - 1, cols - 1, 0, shortestPath);

        // Return the shortest path found
        return shortestPath[0];
    }

    private static void findShortestPath(int[][] maze, boolean[][] visited, int row, int col, int endRow, int endCol, int distance, int[] shortestPath) {
        // Check if the current cell is out of bounds, is blocked, or has already been visited
        if (row < 0 || row >= maze.length || col < 0 || col >= maze[0].length || maze[row][col] == 0 || visited[row][col]) {
            return; // If so, backtrack
        }
        
        // Check if the current cell is the destination
        if (row == endRow && col == endCol) {
            shortestPath[0] = Math.min(shortestPath[0], distance); // Update the shortest path found so far
            return; // Backtrack
        }
        
        // Mark the current cell as visited
        visited[row][col] = true;

        // Recursively call the function to explore the neighboring cells in all four directions
        findShortestPath(maze, visited, row + 1, col, endRow, endCol, distance + 1, shortestPath); // move down
        findShortestPath(maze, visited, row - 1, col, endRow, endCol, distance + 1, shortestPath); // move up
        findShortestPath(maze, visited, row, col + 1, endRow, endCol, distance + 1, shortestPath); // move right
        findShortestPath(maze, visited, row, col - 1, endRow, endCol, distance + 1, shortestPath); // move left

        // Mark the current cell as unvisited (for backtracking)
        visited[row][col] = false;
    }

    public static void main(String[] args) {
        // Create a 2D array representing the maze
        int[][] maze = {{1, 0, 1, 1, 1},
                        {1, 0, 1, 0, 1},
                        {1, 1, 1, 0, 1},
                        {0, 0, 0, 0, 1},
                        {1, 1, 1, 0, 1}};

        // Call the findShortestPath function to get the shortest path from the top-left cell to the bottom-right cell
        int shortestPath = findShortestPath(maze);

        // Print the shortest path found
        System.out.println("Shortest Path: " + shortestPath);
    }
}

Output:

Shortest Path: 12

Explanation: The ShortestPathBacktracking class contains a recursive method named findShortestPath that uses backtracking to find the shortest path in a maze from the starting point (0,0) to the end point (rows-1,cols-1). The maze is represented by a two-dimensional array of integers where 1 represents a valid path and 0 represents a wall. The algorithm uses a Boolean array called visited to keep track of the visited cells.

The findShortestPath method takes as input the maze, visited array, current row and column, end row and column, current distance, and an array to store the shortest path found so far. It first checks if the current cell is valid and not visited. If it is the end cell, it updates the shortest path if the current distance is less than the shortest path found so far. Then it sets the current cell as visited and recursively calls itself for the four possible moves: down, up, right, and left. After each recursive call, it unsets the visited flag of the current cell to allow it to be visited again in a different path.

The main method initializes the maze and calls the findShortestPath method, printing the result.

Complexity Analysis: The time complexity of this algorithm is O(4^(nm)) in the worst case, where n is the number of rows and m is the number of columns in the maze. By exploring each of the four possible directions for every cell, we use a recursive depth-first search to navigate through the maze until we arrive at the destination cell. In the worst case, we may need to explore all possible paths in the maze, which would give us a total of 4^(nm) possible paths to consider.

The space complexity of this algorithm is O(nm), where n is the number of rows and m is the number of columns in the maze. A boolean matrix is used to keep track of visited cells, and it has the same dimensions as the maze.Additionally, we use a recursive function that may call itself up to nm times, which could result in a maximum call stack depth of n*m.

Next Topiccustomized exception in Java

← prev next →