Shortest path in a Binary Maze - GeeksforGeeks

09 Jun, 2021
Given a MxN matrix where each element can either be 0 or 1. We need to find the shortest path between a given source cell to a destination cell. The path can only be created out of a cell if its value is 1.Expected time complexity is O(MN).For example – 
Input:
mat[ROW][COL]  = {{1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
                  {1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },
                  {1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },
                  {0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },
                  {1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },
                  {1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },
                  {1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
                  {1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
                  {1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }};
Source = {0, 0};
Destination = {3, 4};

Output:
Shortest Path is 11 
The idea is inspired from Lee algorithm and uses BFS.  
We start from the source cell and calls BFS procedure.We maintain a queue to store the coordinates of the matrix and initialize it with the source cell.We also maintain a Boolean array visited of same size as our input matrix and initialize all its elements to false.We LOOP till queue is not emptyDequeue front cell from the queueReturn if the destination coordinates have reached.For each of its four adjacent cells, if the value is 1 and they are not visited yet, we enqueue it in the queue and also mark them as visited.
We start from the source cell and calls BFS procedure.
We maintain a queue to store the coordinates of the matrix and initialize it with the source cell.
We also maintain a Boolean array visited of same size as our input matrix and initialize all its elements to false.We LOOP till queue is not emptyDequeue front cell from the queueReturn if the destination coordinates have reached.For each of its four adjacent cells, if the value is 1 and they are not visited yet, we enqueue it in the queue and also mark them as visited.
We LOOP till queue is not emptyDequeue front cell from the queueReturn if the destination coordinates have reached.For each of its four adjacent cells, if the value is 1 and they are not visited yet, we enqueue it in the queue and also mark them as visited.
We LOOP till queue is not empty
Dequeue front cell from the queue
Return if the destination coordinates have reached.
For each of its four adjacent cells, if the value is 1 and they are not visited yet, we enqueue it in the queue and also mark them as visited.
Note that BFS works here because it doesn’t consider a single path at once. It considers all the paths starting from the source and moves ahead one unit in all those paths at the same time which makes sure that the first time when the destination is visited, it is the shortest path.Below is the implementation of the idea –  
C++
Java
Python
C#
// C++ program to find the shortest path between// a given source cell to a destination cell.#include <bits/stdc++.h>using namespace std;#define ROW 9#define COL 10 //To store matrix cell coordinatesstruct Point{    int x;    int y;}; // A Data Structure for queue used in BFSstruct queueNode{    Point pt;  // The coordinates of a cell    int dist;  // cell's distance of from the source}; // check whether given cell (row, col) is a valid// cell or not.bool isValid(int row, int col){    // return true if row number and column number    // is in range    return (row >= 0) && (row < ROW) &&           (col >= 0) && (col < COL);} // These arrays are used to get row and column// numbers of 4 neighbours of a given cellint rowNum[] = {-1, 0, 0, 1};int colNum[] = {0, -1, 1, 0}; // function to find the shortest path between// a given source cell to a destination cell.int BFS(int mat[][COL], Point src, Point dest){    // check source and destination cell    // of the matrix have value 1    if (!mat[src.x][src.y] || !mat[dest.x][dest.y])        return -1;     bool visited[ROW][COL];    memset(visited, false, sizeof visited);         // Mark the source cell as visited    visited[src.x][src.y] = true;     // Create a queue for BFS    queue<queueNode> q;         // Distance of source cell is 0    queueNode s = {src, 0};    q.push(s);  // Enqueue source cell     // Do a BFS starting from source cell    while (!q.empty())    {        queueNode curr = q.front();        Point pt = curr.pt;         // If we have reached the destination cell,        // we are done        if (pt.x == dest.x && pt.y == dest.y)            return curr.dist;         // Otherwise dequeue the front        // cell in the queue        // and enqueue its adjacent cells        q.pop();         for (int i = 0; i < 4; i++)        {            int row = pt.x + rowNum[i];            int col = pt.y + colNum[i];                         // if adjacent cell is valid, has path and            // not visited yet, enqueue it.            if (isValid(row, col) && mat[row][col] &&               !visited[row][col])            {                // mark cell as visited and enqueue it                visited[row][col] = true;                queueNode Adjcell = { {row, col},                                      curr.dist + 1 };                q.push(Adjcell);            }        }    }     // Return -1 if destination cannot be reached    return -1;} // Driver program to test above functionint main(){    int mat[ROW][COL] =    {        { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },        { 1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },        { 1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },        { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },        { 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },        { 1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },        { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },        { 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }    };     Point source = {0, 0};    Point dest = {3, 4};     int dist = BFS(mat, source, dest);     if (dist != -1)        cout << "Shortest Path is " << dist ;    else        cout << "Shortest Path doesn't exist";     return 0;}
// Java program to find the shortest// path between a given source cell// to a destination cell.import java.util.*; class GFG{static int ROW = 9;static int COL = 10; // To store matrix cell coordinatesstatic class Point{    int x;    int y;     public Point(int x, int y)    {        this.x = x;        this.y = y;    }}; // A Data Structure for queue used in BFSstatic class queueNode{    Point pt; // The coordinates of a cell    int dist; // cell's distance of from the source     public queueNode(Point pt, int dist)    {        this.pt = pt;        this.dist = dist;    }}; // check whether given cell (row, col)// is a valid cell or not.static boolean isValid(int row, int col){    // return true if row number and    // column number is in range    return (row >= 0) && (row < ROW) &&           (col >= 0) && (col < COL);} // These arrays are used to get row and column// numbers of 4 neighbours of a given cellstatic int rowNum[] = {-1, 0, 0, 1};static int colNum[] = {0, -1, 1, 0}; // function to find the shortest path between// a given source cell to a destination cell.static int BFS(int mat[][], Point src,                            Point dest){    // check source and destination cell    // of the matrix have value 1    if (mat[src.x][src.y] != 1 ||        mat[dest.x][dest.y] != 1)        return -1;     boolean [][]visited = new boolean[ROW][COL];         // Mark the source cell as visited    visited[src.x][src.y] = true;     // Create a queue for BFS    Queue<queueNode> q = new LinkedList<>();         // Distance of source cell is 0    queueNode s = new queueNode(src, 0);    q.add(s); // Enqueue source cell     // Do a BFS starting from source cell    while (!q.isEmpty())    {        queueNode curr = q.peek();        Point pt = curr.pt;         // If we have reached the destination cell,        // we are done        if (pt.x == dest.x && pt.y == dest.y)            return curr.dist;         // Otherwise dequeue the front cell        // in the queue and enqueue        // its adjacent cells        q.remove();         for (int i = 0; i < 4; i++)        {            int row = pt.x + rowNum[i];            int col = pt.y + colNum[i];                         // if adjacent cell is valid, has path            // and not visited yet, enqueue it.            if (isValid(row, col) &&                    mat[row][col] == 1 &&                    !visited[row][col])            {                // mark cell as visited and enqueue it                visited[row][col] = true;                queueNode Adjcell = new queueNode                             (new Point(row, col),                                   curr.dist + 1 );                q.add(Adjcell);            }        }    }     // Return -1 if destination cannot be reached    return -1;} // Driver Codepublic static void main(String[] args){    int mat[][] = {{ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },                   { 1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },                   { 1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },                   { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },                   { 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },                   { 1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },                   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },                   { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },                   { 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }};     Point source = new Point(0, 0);    Point dest = new Point(3, 4);     int dist = BFS(mat, source, dest);     if (dist != -1)        System.out.println("Shortest Path is " + dist);    else        System.out.println("Shortest Path doesn't exist");    }} // This code is contributed by PrinciRaj1992
# Python program to find the shortest# path between a given source cell# to a destination cell. from collections import dequeROW = 9COL = 10 # To store matrix cell coordinatesclass Point:    def __init__(self,x: int, y: int):        self.x = x        self.y = y # A data structure for queue used in BFSclass queueNode:    def __init__(self,pt: Point, dist: int):        self.pt = pt  # The coordinates of the cell        self.dist = dist  # Cell's distance from the source # Check whether given cell(row,col)# is a valid cell or notdef isValid(row: int, col: int):    return (row >= 0) and (row < ROW) and                   (col >= 0) and (col < COL) # These arrays are used to get row and column# numbers of 4 neighbours of a given cellrowNum = [-1, 0, 0, 1]colNum = [0, -1, 1, 0] # Function to find the shortest path between# a given source cell to a destination cell.def BFS(mat, src: Point, dest: Point):         # check source and destination cell    # of the matrix have value 1    if mat[src.x][src.y]!=1 or mat[dest.x][dest.y]!=1:        return -1         visited = [[False for i in range(COL)]                       for j in range(ROW)]         # Mark the source cell as visited    visited[src.x][src.y] = True         # Create a queue for BFS    q = deque()         # Distance of source cell is 0    s = queueNode(src,0)    q.append(s) #  Enqueue source cell         # Do a BFS starting from source cell    while q:         curr = q.popleft() # Dequeue the front cell                 # If we have reached the destination cell,        # we are done        pt = curr.pt        if pt.x == dest.x and pt.y == dest.y:            return curr.dist                 # Otherwise enqueue its adjacent cells        for i in range(4):            row = pt.x + rowNum[i]            col = pt.y + colNum[i]                         # if adjacent cell is valid, has path             # and not visited yet, enqueue it.            if (isValid(row,col) and               mat[row][col] == 1 and                not visited[row][col]):                visited[row][col] = True                Adjcell = queueNode(Point(row,col),                                    curr.dist+1)                q.append(Adjcell)         # Return -1 if destination cannot be reached    return -1 # Driver codedef main():    mat = [[ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 ],           [ 1, 0, 1, 0, 1, 1, 1, 0, 1, 1 ],           [ 1, 1, 1, 0, 1, 1, 0, 1, 0, 1 ],           [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ],           [ 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 ],           [ 1, 0, 1, 1, 1, 1, 0, 1, 0, 0 ],           [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],           [ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 ],           [ 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 ]]    source = Point(0,0)    dest = Point(3,4)         dist = BFS(mat,source,dest)         if dist!=-1:        print("Shortest Path is",dist)    else:        print("Shortest Path doesn't exist")main() # This code is contributed by stutipathak31jan
// C# program to find the shortest// path between a given source cell// to a destination cell.using System;using System.Collections.Generic; class GFG{static int ROW = 9;static int COL = 10; // To store matrix cell coordinatespublic class Point{    public int x;    public int y;     public Point(int x, int y)    {        this.x = x;        this.y = y;    }}; // A Data Structure for queue used in BFSpublic class queueNode{    // The coordinates of a cell    public Point pt;         // cell's distance of from the source    public int dist;     public queueNode(Point pt, int dist)    {        this.pt = pt;        this.dist = dist;    }}; // check whether given cell (row, col)// is a valid cell or not.static bool isValid(int row, int col){    // return true if row number and    // column number is in range    return (row >= 0) && (row < ROW) &&           (col >= 0) && (col < COL);} // These arrays are used to get row and column// numbers of 4 neighbours of a given cellstatic int []rowNum = {-1, 0, 0, 1};static int []colNum = {0, -1, 1, 0}; // function to find the shortest path between// a given source cell to a destination cell.static int BFS(int [,]mat, Point src,                           Point dest){    // check source and destination cell    // of the matrix have value 1    if (mat[src.x, src.y] != 1 ||        mat[dest.x, dest.y] != 1)        return -1;     bool [,]visited = new bool[ROW, COL];         // Mark the source cell as visited    visited[src.x, src.y] = true;     // Create a queue for BFS    Queue<queueNode> q = new Queue<queueNode>();         // Distance of source cell is 0    queueNode s = new queueNode(src, 0);    q.Enqueue(s); // Enqueue source cell     // Do a BFS starting from source cell    while (q.Count != 0)    {        queueNode curr = q.Peek();        Point pt = curr.pt;         // If we have reached the destination cell,        // we are done        if (pt.x == dest.x && pt.y == dest.y)            return curr.dist;         // Otherwise dequeue the front cell        // in the queue and enqueue        // its adjacent cells        q.Dequeue();         for (int i = 0; i < 4; i++)        {            int row = pt.x + rowNum[i];            int col = pt.y + colNum[i];                         // if adjacent cell is valid, has path            // and not visited yet, enqueue it.            if (isValid(row, col) &&                    mat[row, col] == 1 &&               !visited[row, col])            {                // mark cell as visited and enqueue it                visited[row, col] = true;                queueNode Adjcell = new queueNode                           (new Point(row, col),                                curr.dist + 1 );                q.Enqueue(Adjcell);            }        }    }     // Return -1 if destination cannot be reached    return -1;} // Driver Codepublic static void Main(String[] args){    int [,]mat = {{ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },                  { 1, 0, 1, 0, 1, 1, 1, 0, 1, 1 },                   { 1, 1, 1, 0, 1, 1, 0, 1, 0, 1 },                  { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 },                  { 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 },                  { 1, 0, 1, 1, 1, 1, 0, 1, 0, 0 },                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },                  { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },                  { 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 }};     Point source = new Point(0, 0);    Point dest = new Point(3, 4);     int dist = BFS(mat, source, dest);     if (dist != -1)        Console.WriteLine("Shortest Path is " + dist);    else        Console.WriteLine("Shortest Path doesn't exist");    }} // This code is contributed by PrinciRaj1992
Output : 
Shortest Path is 11
This article is contributed by Aditya Goel. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Chinmay Singh
dgr8akki
princiraj1992
stutipathak31jan
ishitaaggarwal8
varshagumber28
Amazon
BFS
DFS
Google
Samsung
Shortest Path
Zoho
Graph
Mathematical
Matrix
Zoho
Amazon
Samsung
Google
Mathematical
DFS
Matrix
Graph
Shortest Path
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Topological Sorting
Detect Cycle in a Directed Graph
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples