# Shortest path in a Binary Maze

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 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 C++ implementation of the idea –

`// 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 cordinates ` `struct` `Point ` `{ ` ` ` `int` `x; ` ` ` `int` `y; ` `}; ` ` ` `// A Data Structure for queue used in BFS ` `struct` `queueNode ` `{ ` ` ` `Point pt; ` `// The cordinates 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 cell ` `int` `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 function ` `int` `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 != INT_MAX) ` ` ` `cout << ` `"Shortest Path is "` `<< dist ; ` ` ` `else` ` ` `cout << ` `"Shortest Path doesn't exist"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

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

## Recommended Posts:

- 0-1 BFS (Shortest Path in a Binary Weight Graph)
- Shortest path from source to destination such that edge weights along path are alternatively increasing and decreasing
- Some interesting shortest path questions | Set 1
- Shortest Path using Meet In The Middle
- Shortest path in an unweighted graph
- Dijkstra’s shortest path algorithm using set in STL
- Multistage Graph (Shortest Path)
- Minimum length of the shortest path of a triangle
- Dijkstra's shortest path with minimum edges
- Dijkstra's Shortest Path Algorithm using priority_queue of STL
- Shortest Path in Directed Acyclic Graph
- Dijkstra's shortest path algorithm in Java using PriorityQueue
- Find shortest safe route in a path with landmines
- Multi Source Shortest Path in Unweighted Graph
- Shortest path with exactly k edges in a directed and weighted graph